集合概述 #

IEnumerable
    ↓
ICollection
    ├── IList
    │   ├── List<T>
    │   └── Array
    └── IDictionary
        ├── Dictionary<K,V>
        └── SortedDictionary<K,V>

ISet
    ├── HashSet<T>
    └── SortedSet<T>

public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
}

public class NumberRange : IEnumerable<int>
{
    private readonly int _start;
    private readonly int _end;
    
    public NumberRange(int start, int end)
    {
        _start = start;
        _end = end;
    }
    
    public IEnumerator<int> GetEnumerator()
    {
        for (int i = _start; i <= _end; i++)
        {
            yield return i;
        }
    }
    
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

foreach (var n in new NumberRange(1, 5))
{
    Console.WriteLine(n);
}

public static IEnumerable<int> GetEvenNumbers(int max)
{
    for (int i = 0; i <= max; i += 2)
    {
        yield return i;
    }
}

public static IEnumerable<int> FilterPositive(IEnumerable<int> numbers)
{
    foreach (var n in numbers)
    {
        if (n > 0)
            yield return n;
    }
}

public interface ICollection<T> : IEnumerable<T>
{
    int Count { get; }
    bool IsReadOnly { get; }
    void Add(T item);
    void Clear();
    bool Contains(T item);
    void CopyTo(T[] array, int arrayIndex);
    bool Remove(T item);
}

ICollection<string> names = new List<string> { "张三", "李四" };

Console.WriteLine($"数量：{names.Count}");
Console.WriteLine($"只读：{names.IsReadOnly}");

names.Add("王五");
bool contains = names.Contains("张三");
bool removed = names.Remove("李四");
names.Clear();

public interface IList<T> : ICollection<T>
{
    T this[int index] { get; set; }
    int IndexOf(T item);
    void Insert(int index, T item);
    void RemoveAt(int index);
}

IList<string> names = new List<string> { "张三", "李四", "王五" };

string first = names[0];
names[1] = "赵六";

int index = names.IndexOf("王五");
names.Insert(0, "钱七");
names.RemoveAt(2);

public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>
{
    TValue this[TKey key] { get; set; }
    ICollection<TKey> Keys { get; }
    ICollection<TValue> Values { get; }
    void Add(TKey key, TValue value);
    bool ContainsKey(TKey key);
    bool Remove(TKey key);
    bool TryGetValue(TKey key, out TValue value);
}

IDictionary<string, int> scores = new Dictionary<string, int>();

scores["张三"] = 85;
scores.Add("李四", 92);

int score = scores["张三"];
bool exists = scores.ContainsKey("王五");

if (scores.TryGetValue("李四", out int liScore))
{
    Console.WriteLine($"李四的分数：{liScore}");
}

foreach (var key in scores.Keys)
{
    Console.WriteLine($"{key}: {scores[key]}");
}

public interface ISet<T> : ICollection<T>
{
    bool Add(T item);
    void ExceptWith(IEnumerable<T> other);
    void IntersectWith(IEnumerable<T> other);
    bool IsSubsetOf(IEnumerable<T> other);
    bool IsSupersetOf(IEnumerable<T> other);
    bool Overlaps(IEnumerable<T> other);
    bool SetEquals(IEnumerable<T> other);
    void SymmetricExceptWith(IEnumerable<T> other);
    void UnionWith(IEnumerable<T> other);
}

ISet<int> set1 = new HashSet<int> { 1, 2, 3, 4, 5 };
ISet<int> set2 = new HashSet<int> { 4, 5, 6, 7, 8 };

set1.UnionWith(set2);
set1.IntersectWith(set2);
set1.ExceptWith(set2);

bool isSubset = set1.IsSubsetOf(set2);
bool overlaps = set1.Overlaps(set2);

var list = new List<int> { 1, 2, 3, 4, 5 };
var dict = new Dictionary<string, int>
{
    ["张三"] = 85,
    ["李四"] = 92
};
var set = new HashSet<int> { 1, 2, 3 };

List<int> list = [1, 2, 3, 4, 5];
int[] array = [1, 2, 3];
HashSet<int> set = [1, 2, 3];

List<int> CreateList(int a, int b) => [a, b];

public IReadOnlyList<int> GetNumbers()
{
    return new List<int> { 1, 2, 3 }.AsReadOnly();
}

public IReadOnlyDictionary<string, int> GetScores()
{
    return new Dictionary<string, int>
    {
        ["张三"] = 85
    };
}

using System.Collections.Immutable;

var list = ImmutableList.Create(1, 2, 3);
var newList = list.Add(4);

var dict = ImmutableDictionary.CreateBuilder<string, int>();
dict.Add("张三", 85);
var immutableDict = dict.ToImmutable();