public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

// 泛型版本
public interface IEnumerable<T> : IEnumerable
{
    new IEnumerator<T> GetEnumerator();
}

public interface IEnumerator
{
    bool MoveNext();
    object Current { get; }
    void Reset();
}

// 泛型版本
public interface IEnumerator<T> : IDisposable, IEnumerator
{
    new T Current { get; }
}

// 假设有一个集合 myCollection
IEnumerator<string> enumerator = myCollection.GetEnumerator();

// 这等价于 foreach (var item in myCollection) { ... }
while (enumerator.MoveNext()) // 1. 移动到下一个元素
{
    string item = enumerator.Current; // 2. 获取当前元素
    Console.WriteLine(item); // 3. 使用当前元素
}
// 4. 循环结束后，枚举器会被释放（Dispose）

List<string> fruits = new List<string> { "Apple", "Banana", "Orange" };

// 获取枚举器
IEnumerator<string> enumerator = fruits.GetEnumerator();

// 手动遍历
try
{
    while (enumerator.MoveNext())
    {
        string fruit = enumerator.Current;
        Console.WriteLine(fruit);
    }
}
finally
{
    // 重要：IEnumerator<T> 继承了 IDisposable，需要释放资源
    enumerator.Dispose();
}

// 输出
// Apple
// Banana
// Orange

// 一个简单的自定义集合，存储一个范围内的数字
public class NumberRange : IEnumerable<int>
{
    private int _start;
    private int _count;

    public NumberRange(int start, int count)
    {
        _start = start;
        _count = count;
    }

    // 实现 IEnumerable<T>.GetEnumerator()
    public IEnumerator<int> GetEnumerator()
    {
        // 这里使用了 yield return 语法糖（见下文）
        for (int i = _start; i < _start + _count; i++)
        {
            yield return i;
        }
    }

    // 实现非泛型 IEnumerable.GetEnumerator()（必须显式实现，泛型版本继承自非泛型版本）
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator(); // 只需返回泛型版本
    }
}

// 使用
class Program
{
    static void Main()
    {
        NumberRange range = new NumberRange(5, 3); // 数字 5, 6, 7

        // 使用 foreach 遍历（编译器会自动调用 GetEnumerator 和 Dispose）
        foreach (int number in range)
        {
            Console.WriteLine(number);
        }
        // 输出：
        // 5
        // 6
        // 7
    }
}

public class Counter
{
    public CounterEnumerator GetEnumerator() => new CounterEnumerator();
}

public class CounterEnumerator
{
    int _value = 0;

    public bool MoveNext()
    {
        _value++;
        return _value <= 3;
    }

    public int Current => _value;
}

// foreach
foreach (var x in new Counter())
    Console.WriteLine(x);

1
2
3

// 传统的异步方法返回 Task<IEnumerable<T>>的问题
public static async Task<IEnumerable<int>> GetDataAsync()
{
    var results = new List<int>();
    for (int i = 0; i < 10; i++)
    {
        // 模拟异步操作（如从数据库、API读取
        await Task.Delay(100);
        results.Add(i);
    }
    return results; // 必须等待所有数据就绪后才能返回
}

class Program
{
    static void Main()
    {
        var results = GetDataAsync();
        foreach (var result in results) // 拿到的是完整的results List
        {
            Console.WriteLine(result);
        }
    }
}

public async IAsyncEnumerable<int> GetDataAsync()
{
    for (int i = 0; i < 10; i++)
    {
        // 模拟异步操作
        await Task.Delay(100);
        yield return i; // 生产一个元素就能立即返回
    }
}

class Program
{
    static async Task Main() // 异步Main(C# 7.1+ 支持)
    {
        // await foreach会异步等待每一个元素
        await foreach(var item in GetDataAsync()) // 生成一个用一个
        {
            Console.WriteLine(item);
        }
    }
}

public interface IAsyncEnumerable<out T>
{
    IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default);
}

public interface IAsyncEnumerator<out T> : IAsyncDisposable
{
    T Current { get; }
    Value Task<bool> MoveNextAsync();
}

public interface IAsyncDisposable
{
    ValueTask DisposeAsync();
}

// 消费异步流
await foreach (var item in GetDataAsync())
{
    Console.WriteLine($"Received: {item} at {DateTime.Now:HH:mm:ss.fff}");
}

// 输出示例：
// Received: 0 at 14:30:01.123
// Received: 1 at 14:30:01.234  (大约100ms后)
// Received: 2 at 14:30:01.345  (再100ms后)
// ...

public static async IAsyncEnumerable<int> GetDataWithCancellationAsync(
    [EnumeratorCancellation] CancellationToken cancellationToken = default)
{
    for (int i = 0; i < 100; i++)
    {
        // 检查取消请求
        cancellationToken.ThrowIfCancellationRequested();
        
        await Task.Delay(100, cancellationToken);
        yield return i;
    }
}

// 使用
var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(3)); // 3秒后取消

await foreach (var item in GetDataWithCancellationAsync(cts.Token))
{
    Console.WriteLine(item);
}

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);
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 使用 List<T> 类，它实现了 ICollection<T>
        ICollection<string> collection = new List<string>();

        // 1. 添加元素
        collection.Add("Apple");
        collection.Add("Banana");
        collection.Add("Cherry");
        Console.WriteLine($"初始集合: {string.Join(", ", collection)}"); // 输出: Apple, Banana, Cherry
        Console.WriteLine($"Count: {collection.Count}"); // 输出: 3

        // 2. 检查元素是否存在
        bool hasBanana = collection.Contains("Banana");
        Console.WriteLine($"包含 ‘Banana‘: {hasBanana}"); // 输出: True

        // 3. 移除元素
        bool removed = collection.Remove("Banana");
        Console.WriteLine($"移除了 ‘Banana‘: {removed}"); // 输出: True
        Console.WriteLine($"移除后: {string.Join(", ", collection)}"); // 输出: Apple, Cherry

        // 4. 尝试移除不存在的元素
        removed = collection.Remove("Fig");
        Console.WriteLine($"移除了 ‘Fig‘: {removed}"); // 输出: False

        // 5. 复制到数组
        string[] array = new string[collection.Count];
        collection.CopyTo(array, 0);
        Console.WriteLine($"复制到数组: {string.Join(", ", array)}"); // 输出: Apple, Cherry

        // 6. 清空集合
        collection.Clear();
        Console.WriteLine($"清空后 Count: {collection.Count}"); // 输出: 0

        // 7. 只读检查
        Console.WriteLine($"集合是只读的吗？ {collection.IsReadOnly}"); // 输出: False (对于 List<T>)
    }
}

public void ProcessItems(ICollection<string> items)
{
    if (items.Contains("target"))
    {
        items.Remove("target");
    }
    // ... 其他操作
}

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

// 使用接口作为参数/返回类型
public void ProcessItems(IList<int> items)
{
    // ... 处理逻辑
}

// 依赖具体实现
public void ProcessItem(List<int> items)
{
    // ... 处理逻辑
}

IList<int> a = new List<int>();
a[0] = 10;

数组的本质是
- 大小固定
- 连续内存
- 极端高性能
- 协变

CLR为了让数组也能参与“泛化体系”，给它挂上了接口
- `IEnumerable`
- `ICollection<T>`
- `IList<T>`

但数组根本不是设计成“可修改结构”的，所以它只能做到
- 索引器可用（本身就有）
- `IndexOf`可以模拟（遍历）
- `Insert/Remove`直接抛异常

CLR只是让数组“看起来像”IList，而不完全“是”IList

所以，数组实现接口并不是OO，更多是在填框架的坑

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 创建一个 IList<T>。通常我们使用 List<T> 这个实现类。
        IList<string> fruits = new List<string>();

        // 1. 使用 Add 方法添加元素
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Orange");

        // 2. 使用索引器访问元素
        Console.WriteLine($"The first fruit is: {fruits[0]}"); // 输出: Apple

        // 3. 使用 Insert 方法在指定位置插入
        fruits.Insert(1, "Mango"); // 在索引1（Banana之前）插入
        // 现在顺序是: Apple, Mango, Banana, Orange

        // 4. 使用 IndexOf 查找元素位置
        int index = fruits.IndexOf("Banana");
        Console.WriteLine($"Banana is at index: {index}"); // 输出: 2

        // 5. 使用 RemoveAt 根据索引删除
        fruits.RemoveAt(index); // 删除 "Banana"

        // 6. 使用 Remove 根据值删除
        fruits.Remove("Apple"); // 删除 "Apple"

        // 7. 遍历集合 (来自 IEnumerable<T>)
        Console.WriteLine("\nRemaining fruits:");
        foreach (string fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
        // 输出:
        // Mango
        // Orange

        // 8. 检查是否只读和元素数量
        Console.WriteLine($"\nIs the list read-only? {fruits.IsReadOnly}"); // 输出: False
        Console.WriteLine($"Number of fruits: {fruits.Count}"); // 输出: 2
    }
}

// 最常见的用法：使用 Dictionary类
IDictionary<string, int> personAge = new Dictionary<string, int>();
// 或者更简单地
var personAge = new Dictionary<string, int>()

public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
{
    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);
}

TValue this[TKey key] { get; set; }

ICollection<TKey> Keys { get; }

ICollection<TValue> Values { get; }

void Add(TKey key, TValue value);

bool Remove(TKey key);

bool ContainsKey(TKey key);

bool TryGetValue(TKey key, out TValue value);

// 初始化一个字典
IDictionary<string, string> capitals = new Dictionary<string, string>();

// --- 添加元素 ---
capitals.Add("China", "Beijing");
capitals.Add("USA", "Washington D.C.");
capitals.Add("Japan", "Tokyo");

// 另一种添加方式：使用索引器
// 如果键不存在，会添加；如果存在，会修改其值
capitals["France"] = "Paris";
capitals["USA"] = "New York"; // 修改了 USA 的首都

// --- 访问元素 ---
// 使用索引器访问（键必须存在，否则抛出 KeyNotFoundException）
string chinaCapital = capitals["China"]; // "Beijing"

// 安全地访问：TryGetValue 方法（推荐）
if (capitals.TryGetValue("Germany", out string germanCapital))
{
    Console.WriteLine($"Germany's capital is {germanCapital}");
}
else
{
    Console.WriteLine("Germany is not in the dictionary.");
}

// --- 检查元素 ---
// 检查键是否存在
bool hasJapan = capitals.ContainsKey("Japan"); // true
// 检查值是否存在（注意：此操作较慢，是 O(n)）
bool hasBeijing = capitals.ContainsValue("Beijing"); // true

// --- 删除元素 ---
// 删除指定键的键值对
capitals.Remove("Japan");

// --- 常用属性 ---
int count = capitals.Count; // 获取键值对的数量
var keys = capitals.Keys;   // 获取所有键的集合
var values = capitals.Values; // 获取所有值的集合

// --- 遍历字典 ---
// 方式1：遍历 KeyValuePair<TKey, TValue>
foreach (KeyValuePair<string, string> kvp in capitals)
{
    Console.WriteLine($"Country: {kvp.Key}, Capital: {kvp.Value}");
}

// 方式2：单独遍历所有键
foreach (string country in capitals.Keys)
{
    Console.WriteLine($"Country: {country}");
}

// 方式3：单独遍历所有值
foreach (string capital in capitals.Values)
{
    Console.WriteLine($"Capital: {capital}");
}

public interface ISet<T> : ICollection<T>, IEnumerable<T>, IEnumerable
{
    bool Add (T item);
    void ExceptWith(IEnumerable<T> other);
    void IntersectWith(IEnumerable<T> other);
    bool IsProperSubsetOf(IEnumerable<T> other);
    bool IsProperSupersetOf(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);
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 1. 创建 HashSet
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3, 4, 5 };
        HashSet<int> set2 = new HashSet<int> { 4, 5, 6, 7, 8 };

        Console.WriteLine("Set1: " + string.Join(", ", set1)); // 输出顺序可能不定
        Console.WriteLine("Set2: " + string.Join(", ", set2));

        // 2. 基本操作 - 添加重复元素无效
        bool added = set1.Add(3); // 返回 false，因为 3 已存在
        Console.WriteLine($"Added 3? {added}");

        // 3. 集合操作 - 这些操作会修改 set1
        // 并集
        set1.UnionWith(set2);
        Console.WriteLine("Union: " + string.Join(", ", set1)); // 1, 2, 3, 4, 5, 6, 7, 8

        // 重置 set1
        set1 = new HashSet<int> { 1, 2, 3, 4, 5 };

        // 交集
        set1.IntersectWith(set2);
        Console.WriteLine("Intersection: " + string.Join(", ", set1)); // 4, 5

        // 重置 set1
        set1 = new HashSet<int> { 1, 2, 3, 4, 5 };

        // 差集
        set1.ExceptWith(set2);
        Console.WriteLine("Difference (set1 - set2): " + string.Join(", ", set1)); // 1, 2, 3

        // 重置 set1
        set1 = new HashSet<int> { 1, 2, 3, 4, 5 };

        // 对称差集
        set1.SymmetricExceptWith(set2);
        Console.WriteLine("Symmetric Difference: " + string.Join(", ", set1)); // 1, 2, 3, 6, 7, 8

        // 4. 关系判断
        HashSet<int> smallSet = new HashSet<int> { 2, 3 };
        Console.WriteLine($"{{2, 3}} is subset of {{1,2,3,4,5}}? {smallSet.IsSubsetOf(new[] {1, 2, 3, 4, 5})}"); // True

        // 5. 使用 SortedSet（自动排序）
        SortedSet<string> sortedNames = new SortedSet<string> { "Charlie", "Alice", "Bob" };
        Console.WriteLine("SortedSet: " + string.Join(", ", sortedNames)); // Alice, Bob, Charlie
    }
}

public interface IReadOnlyCollection<out T> : IEnumerable<T>, IEnumerable
{
    int Count { get; }
}

IReadOnlyCollection<string> cities = new List<string> { "Beijing", "Shanghai", "Guangzhou" };

Console.WriteLine($"Count: {cities.Count}"); // 输出: Count: 3

foreach (var city in cities)
{
    Console.WriteLine(city);
}
// 不能执行 cities.Add("Shenzhen") - 编译错误

[DefaultMember("Item")]
public interface IReadOnlyList<out T> : IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
{
    T this[int index] { get; }
}

IReadOnlyList<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

Console.WriteLine($"Count: {numbers.Count}"); // Count: 5
Console.WriteLine($"First element: {numbers[0]}"); // First element: 1
Console.WriteLine($"Last element: {numbers[numbers.Count - 1]}"); // Last element: 5

// 支持索引访问，但不能修改
// numbers[0] = 10; // 编译错误

public interface IReadOnlyDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyCollection<KeyValuePair<TKey, TValue>>
{
    TValue this[TKey key] { get; }
    IEnumerable<TKey> Keys { get; }
    IEnumerable<TValue> Values { get; }

    bool ContainsKey(TKey key);
    bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
}

var dict = new Dictionary<string, int>
{
    ["Alice"] = 25,
    ["Bob"] = 30,
    ["Charlie"] = 35
};

IReadOnlyDictionary<string, int> readOnlyDict = dict;

Console.WriteLine($"Alice's age: {readOnlyDict["Alice"]}"); // Alice's age: 25

// 检查键是否存在
if (readOnlyDict.ContainsKey("Bob"))
{
    Console.WriteLine("Bob exists in dictionary");
}

// 遍历所有键值对
foreach (var kvp in readOnlyDict)
{
    Console.WriteLine($"{kvp.Key}: {kvp.Value}");
}

// 获取所有键
foreach (var key in readOnlyDict.Keys)
{
    Console.WriteLine($"Key: {key}");
}

public interface IReadOnlySet<T> : IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
{
    bool Contains(T item);
    bool IsProperSubsetOf(IEnumerable<T> other);
    bool IsProperSuperOf(IEnumerable<T> other);
    bool IsSubsetOf(IEnumerable<T> other);
    bool IsSupersetOf(IEnumerable<T> other);
    bool Overlaps(IEnumerable<T> other);
    bool SetEquals(IEnumerable<T> other);
}

var setA = new HashSet<int> { 1, 2, 3, 4, 5 };
var setB = new HashSet<int> { 3, 4, 5, 6, 7 };
var setC = new HashSet<int> { 1, 2 };
var setD = new HashSet<int> { 1, 2, 3, 4, 5 };

IReadOnlySet<int> readOnlyA = setA;
IReadOnlySet<int> readOnlyB = setB;
IReadOnlySet<int> readOnlyC = setC;
IReadOnlySet<int> readOnlyD = setD;

// 子集检查
Console.WriteLine($"C is subset of A: {readOnlyC.IsSubsetOf(readOnlyA)}"); // True
Console.WriteLine($"C is proper subset of A: {readOnlyC.IsProperSubsetOf(readOnlyA)}"); // True

// 超集检查
Console.WriteLine($"A is superset of C: {readOnlyA.IsSupersetOf(readOnlyC)}"); // True
Console.WriteLine($"A is proper superset of C: {readOnlyA.IsProperSupersetOf(readOnlyC)}"); // True

// 重叠检查
Console.WriteLine($"A overlaps with B: {readOnlyA.Overlaps(readOnlyB)}"); // True

// 集合相等检查
Console.WriteLine($"A equals D: {readOnlyA.SetEquals(readOnlyD)}"); // True
Console.WriteLine($"A equals B: {readOnlyA.SetEquals(readOnlyB)}"); // False

public class DataProcessor
{
    // 使用只读接口作为参数，明确表示方法不会修改集合
    public void ProcessData(IReadOnlyList<int> data)
    {
        Console.WriteLine($"Processing {data.Count} items");
        
        for (int i = 0; i < data.Count; i++)
        {
            Console.WriteLine($"Item {i}: {data[i]}");
        }
        
        // data.Add(100); // 编译错误 - 无法修改
    }
    
    // 返回只读视图
    public IReadOnlyList<string> GetReadOnlyData()
    {
        List<string> internalList = new List<string> { "A", "B", "C" };
        return internalList.AsReadOnly();
    }
}

public class Repository
{
    private List<string> _internalData = new List<string>();
    
    // 对外暴露只读视图
    public IReadOnlyList<string> Data => _internalData.AsReadOnly();
    
    public void AddItem(string item)
    {
        _internalData.Add(item);
    }
    
    // 内部可以修改，外部只能读取
    public void Clear()
    {
        _internalData.Clear();
    }
}

// 使用
var repo = new Repository();
repo.AddItem("Item1");
repo.AddItem("Item2");

IReadOnlyList<string> data = repo.Data;
Console.WriteLine($"Items count: {data.Count}"); // Items count: 2

// data.Clear(); // 编译错误 - 无法通过只读接口修改

List<int> mutableList = new List<int> { 1, 2, 3 };
IReadOnlyList<int> readOnlyList = mutableList.AsReadOnly();

List<string> originalList = new List<string> { "a", "b", "c" };
var readOnlyCollection = new ReadOnlyCollection<string>(originalList);

int[] array = { 1, 2, 3 };
IReadOnlyList<int> readOnlyArray = array;

public interface IComparable<in T>
{
    int CompareTo(T? other);
}

class Player : IComparable<Player>
{
    public int Score { get; set; }
    public string Name { get; set; }

    public Player(int score, string name)
    {
        Score = score;
        Name = name;
    }

    public int CompareTo(Player other)
    {
        return Score.CompareTo(other.Score);
    }
}

class Program
{
    static void Main()
    {
        var playerlist = new List<Player>();

        var player1 = new Player(12, "Player1");
        var player2 = new Player(22, "Player2");
        var player3 = new Player(13, "Player3");

        playerlist.Add(player1);
        playerlist.Add(player2);
        playerlist.Add(player3);

        playerlist.Sort();

        foreach (var player in playerlist) 
            Console.WriteLine(player.Score + " " + player.Name);
    }
}

public interface IComparer<in T>
{
    int Compare(T? x, T? y);
}

// 按姓名排序的比较器
public class NameComparer : IComparer<Player>
{
    public int Compare(Player? x, Player? y)
    {
        // 处理 null 值
        if (x is null && y is null) return 0;
        if (x is null) return -1; // null 排在前面
        if (y is null) return 1;  // null 排在后面

        // 使用 String.Compare 进行字符串比较
        return string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);
    }
}

// 按年龄降序排序的比较器
public class AgeDescendingComparer : IComparer<Player>
{
    public int Compare(Player? x, Player? y)
    {
        if (x is null && y is null) return 0;
        if (x is null) return -1;
        if (y is null) return 1;

        // 注意：为了降序，我们反转了 x 和 y 的位置
        return y.Score.CompareTo(x.Score);
    }
}

class Program
{
    static void Main()
    {
        var playerlist = new List<Player>
        {
            new Player(98, "Alice"),
            new Player(60, "Amanda"),
            new Player(98, "Eric"),
            new Player(77, "Jeff"),
            new Player(60, "Evi"),
            new Player(100, "Jeffrey")

        };

        playerlist.Sort();
        foreach (var player in playerlist)
            Console.WriteLine(player.Score + " " + player.Name);
        // 60 Amanda
        // 60 Evi
        // 77 Jeff
        // 98 Alice
        // 98 Eric
        // 100 Jeffrey

        playerlist.Sort(new NameComparer());
        foreach (var player in playerlist)
            Console.WriteLine(player.Score + " " + player.Name);
        // 98 Alice
        // 60 Amanda
        // 98 Eric
        // 60 Evi
        // 77 Jeff
        // 100 Jeffrey

        playerlist.Sort(new ScoreDescendingComparer());
        foreach (var player in playerlist)
            Console.WriteLine(player.Score + " " + player.Name);
        // 100 Jeffrey
        // 98 Alice
        // 98 Eric
        // 77 Jeff
        // 60 Amanda
        // 60 Evi
    }
}

var comparer = 
    Comparer<Player>.Create((a, b) => b.Score.CompareTo(a.Score))
    .ThenBy(p => p.Name)
    .ThenBy(p => p.JoinDate);

public interface IEquatable<T>
{
    bool Equals(T? other);
}

public class Person : IEquatable<Person>
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    // 实现 IEquatable<Person>.Equals
    public bool Equals(Person? other)
    {
        // 使用模式匹配进行 null 检查（C# 9.0+）
        if (other is null)
            return false;

        // 如果是引用类型，检查是否是同一个实例
        if (ReferenceEquals(this, other))
            return true;

        // 定义“相等”的逻辑：这里认为姓名和年龄都相同就是同一个人
        return FirstName == other.FirstName &&
               LastName == other.LastName &&
               Age == other.Age;
    }

    // 重写 object.Equals
    public override bool Equals(object? obj) => Equals(obj as Person);

    // 重写 GetHashCode - 必须与 Equals 逻辑一致！
    public override int GetHashCode()
    {
        // 使用 HashCode.Combine 来方便地生成组合哈希码（.NET Core 2.1+）
        return HashCode.Combine(FirstName, LastName, Age);
        
        // 旧版本 .NET 的替代方案：
        // unchecked
        // {
        //     int hash = 17;
        //     hash = hash * 23 + (FirstName?.GetHashCode() ?? 0);
        //     hash = hash * 23 + (LastName?.GetHashCode() ?? 0);
        //     hash = hash * 23 + Age.GetHashCode();
        //     return hash;
        // }
    }

    // 可选：重写 == 和 != 操作符
    public static bool operator ==(Person? left, Person? right) => Equals(left, right);
    public static bool operator !=(Person? left, Person? right) => !Equals(left, right);
}

// 使用
var person1 = new Person { FirstName = "John", LastName = "Doe", Age = 30 };
var person2 = new Person { FirstName = "John", LastName = "Doe", Age = 30 };

Console.WriteLine(person1.Equals(person2)); // True (调用了 IEquatable<Person>.Equals)
Console.WriteLine(person1 == person2);      // True (如果重载了操作符)

public interface IEqualityComparer<T>
{
    bool Equals(T? x, T? y);
    int GetHashCode(T obj);
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Category { get; set; }
}

// 比较器1：按ID比较
public class ProductByIdComparer : IEqualityComparer<Product>
{
    public bool Equals(Product? x, Product? y)
    {
        if (ReferenceEquals(x, y)) return true;
        if (x is null) return false;
        if (y is null) return false;

        return x.Id == y.Id;
    }

    public int GetHashCode(Product obj) => obj.Id.GetHashCode();
}

// 比较器2：按名称（不区分大小写）比较
public class ProductByNameIgnoreCaseComparer : IEqualityComparer<Product>
{
    public bool Equals(Product? x, Product? y)
    {
        if (ReferenceEquals(x, y)) return true;
        if (x is null) return false;
        if (y is null) return false;

        return string.Equals(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);
    }

    public int GetHashCode(Product obj) => obj.Name?.ToLowerInvariant().GetHashCode() ?? 0;
}

// 使用
var product1 = new Product { Id = 1, Name = "Laptop", Category = "Electronics" };
var product2 = new Product { Id = 2, Name = "laptop", Category = "Computers" };

var idComparer = new ProductByIdComparer();
var nameComparer = new ProductByNameIgnoreCaseComparer();

Console.WriteLine(idComparer.Equals(product1, product2));    // False (ID不同)
Console.WriteLine(nameComparer.Equals(product1, product2));  // True (名称忽略大小写后相同)

// 在集合中使用
var productSetById = new HashSet<Product>(new ProductByIdComparer());
productSetById.Add(product1);
productSetById.Add(product2); // 可以添加，因为ID不同

var productSetByName = new HashSet<Product>(new ProductByNameIgnoreCaseComparer());
productSetByName.Add(product1);
productSetByName.Add(product2); // 不会被添加，因为名称被视为相同

bool Equals(T other)

public override bool Equals(object obj)

p1.Equals(p2); // 用 IEquatable<T>的逻辑
((object)p1).Equals(p2); // 用的是object.Equals的默认逻辑

class Person : IEquatable<Person>
{
    public int Id;

    public bool Equals(Person other) => other != null && Id == other.Id;

    // 未重写GetHashCode
}

var set = new HashSet<Person>();

var p1 = new Person { Id = 1 };
var p2 = new Person { Id = 1 };

set.Add(p1);
bool contains = set.Contains(p2);

Console.WriteLine(contains);

public interface IProducerConsumerCollection<T> : IEnumerable<T>, IEnumerable, ICollection
{
    void CopyTo(T[] array, int index);
    T[] ToArray();
    bool TryAdd(T item);
    bool TryTake([MaybeNullWhen(false)] out T item);
}

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        // ConcurrentQueue 实现了 IProducerConsumerCollection<int>
        IProducerConsumerCollection<int> queue = new ConcurrentQueue<int>();

        // 生产者任务
        var producer = Task.Run(() => {
            for (int i = 0; i < 10; i++) {
                // 使用 TryAdd 添加元素
                while (!queue.TryAdd(i)) {
                    // 如果添加失败（对于ConcurrentQueue几乎不会发生），稍等再试
                    Thread.Sleep(10);
                }
                Console.WriteLine($"Produced: {i}");
                Thread.Sleep(100); // 模拟生产耗时
            }
        });

        // 消费者任务
        var consumer = Task.Run(() => {
            int item;
            for (int i = 0; i < 10; i++) {
                // 使用 TryTake 取出元素
                while (!queue.TryTake(out item)) {
                    // 如果取出失败（队列为空），稍等再试
                    Thread.Sleep(10);
                }
                Console.WriteLine($"Consumed: {item}");
                Thread.Sleep(150); // 模拟消费耗时
            }
        });

        Task.WaitAll(producer, consumer);
        Console.WriteLine("Done!");
    }
}

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        // 创建一个有界（容量为5）的阻塞集合，底层使用ConcurrentQueue
        using (BlockingCollection<int> collection = new BlockingCollection<int>(boundedCapacity: 5))
        {
            // 生产者任务
            var producer = Task.Run(() => {
                for (int i = 0; i < 10; i++) {
                    // Add 方法在集合满时会阻塞，直到有空间
                    collection.Add(i);
                    Console.WriteLine($"Produced: {i}");
                }
                // 通知消费者不再生产了
                collection.CompleteAdding();
            });

            // 消费者任务
            var consumer = Task.Run(() => {
                // GetConsumingEnumerable() 会阻塞直到有元素可取或CompleteAdding被调用
                foreach (var item in collection.GetConsumingEnumerable()) {
                    Console.WriteLine($"Consumed: {item}");
                }
            });

            Task.WaitAll(producer, consumer);
        }
        Console.WriteLine("Done!");
    }
}

public class ValidatedProductCollection : CollectionBase
{
    public void Add(Product product)
    {
        List.Add(product);
    }

    public Product this[int index]
    {
        get { return (Product)List[index]; }
        set { List[index] = value; }
    }

    // 重写 OnValidate 来确保添加的不是 null
    protected override void OnValidate(object value)
    {
        base.OnValidate(value); // 良好实践：调用基类方法
        if (value == null)
        {
            throw new ArgumentNullException(nameof(value), "Product cannot be null.");
        }
        if (!(value is Product))
        {
            throw new ArgumentException("Value must be of type Product.", nameof(value));
        }
    }

    // 重写 OnInsertComplete 来记录或触发事件
    protected override void OnInsertComplete(int index, object value)
    {
        base.OnInsertComplete(index, value);
        Console.WriteLine($"Product '{(value as Product).Name}' was added to the collection.");
        // 这里也可以触发一个自定义的 'ItemAdded' 事件
    }
}

public class Collection<T> : IList<T>, IList, IReadOnlyList<T>
{
    private IList<T> items;

    public Collection()
    {
        items = new List<T>();
    }

    protected virtual void InsertItem(int index, T item) { ... }
    protected virtual void SetItem(int index, T item) { ... }
    protected virtual void RemoveItem(int index) { ... }
    protected virtual void ClearItems() { ... }
}

public class LoggingCollection<T> : Collection<T>
{
    protected override void InsertItem(int index, T item)
    {
        Console.WriteLine($"Add: {item}");
        base.InsertItem(index, item);
    }

    protected override void RemoveItem(int index)
    {
        Console.WriteLine($"Remove at {index}");
        base.RemoveItem(index);
    }
}

protected override void RemoveItem(int index)
{
    throw new InvalidOperationException("This collection does not allow removing items.");
}

public abstract class DictionaryBase : ICollection, IEnumerable, IDictionary
{
    protected DictionaryBase();

    public int Count { get; }
    protected IDictionary Dictionary { get; }
    protected Hashtable InnerHashtable { get; }

    public void Clear();
    public void CopyTo(Array array, int index);
    public IDictionaryEnumerator GetEnumerator();
    protected virtual void OnClear();
    protected virtual void OnClearComplete();
    protected virtual object? OnGet(object key, object? currentValue);
    protected virtual void OnInsert(object key, object? value);
    protected virtual void OnInsertComplete(object key, object? value);
    protected virtual void OnRemove(object key, object? value);
    protected virtual void OnRemoveComplete(object key, object? value);
    protected virtual void OnSet(object key, object? oldValue, object? newValue);
    protected virtual void OnSetComplete(object key, object? oldValue, object? newValue);
    protected virtual void OnValidate(object key, object? value);
}

using System;
using System.Collections;

public class ShortStringDictionary : DictionaryBase
{
    // 强类型索引器
    public string this[string key]
    {
        get => (string)Dictionary[key];
        set => Dictionary[key] = value;
    }

    // 强类型 Add/Remove/Contains
    public void Add(string key, string value) => Dictionary.Add(key, value);
    public bool Contains(string key) => Dictionary.Contains(key);
    public void Remove(string key) => Dictionary.Remove(key);

    // 在插入/设置前校验 —— 限制 value 长度不超过 5
    protected override void OnValidate(object key, object value)
    {
        if (key == null) throw new ArgumentNullException(nameof(key));
        if (!(key is string)) throw new ArgumentException("key must be string", nameof(key));
        if (!(value is string)) throw new ArgumentException("value must be string", nameof(value));
        if (((string)value).Length > 5) throw new ArgumentException("value length > 5");
    }
}

public class Product
{
    public string Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

private void AddKey(TKey key, TItem item)
{
    if (dict != null)
    {
        dict.Add(key, item);
    }
    else if (keyCount == threshold) // 达到阈值时创建字典
    {
        CreateDictionary();
        dict!.Add(key, item);
    }
    else
    {
        if (Contains(key)) // 小集合时使用线性搜索检查重复键
        {
            throw new ArgumentException(SR.Format(SR.Argument_AddingDuplicate, key), nameof(key));
        }
        keyCount++;
    }
}

private readonly IEqualityComparer<TKey> comparer;
private Dictionary<TKey, TItem>? dict; // 可空的字典
private int keyCount; // 小集合时的键计数
private readonly int threshold; // 字典创建阈值

private void AddKey(TKey key, TItem item)
{
    // 在添加键时的重复检查
    if (Contains(key))
    {
        throw new ArgumentException(SR.Format(SR.Argument_AddingDuplicate, key), nameof(key));
    }
}

public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TItem item)
{
    ArgumentNullException.ThrowIfNull(key);

    if (dict != null)  // 有字典：O(1) 查找
    {
        return dict.TryGetValue(key, out item!);
    }

    // 无字典：O(n) 线性搜索
    foreach (TItem itemInItems in Items)
    {
        TKey keyInItems = GetKeyForItem(itemInItems);
        if (keyInItems != null && comparer.Equals(key, keyInItems))
        {
            item = itemInItems;
            return true;
        }
    }

    item = default;
    return false;
}

protected override void InsertItem(int index, TItem item)
{
    TKey key = GetKeyForItem(item);
    if (key != null)
    {
        AddKey(key, item); // 先添加键
    }
    base.InsertItem(index, item); // 再添加项
}

protected override void RemoveItem(int index)
{
    Tkey key = GetKeyForItem(Items[index]);
    if (key != null)
    {
        RemoveKey(key); // 先移除键
    }
    base.RemoveItem(index); // 再移除项
}

protected void ChangeItemKey(TItem item, TKey newKey)
{
    if (!ContainsItem(item))
    {
        throw new ArgumentException(SR.Argument_ItemNotExist, nameof(item));
    }

    TKey oldKey = GetKeyForItem(item);
    if (!comparer.Equals(oldKey, newKey))
    {
        if (newKey != null)
        {
            AddKey(newKey, item);
        }
        if (oldKey != null)
        {
            RemoveKey(oldKey);
        }
    }
}

public KeyedCollection(IEqualityComparer<TKey>? comparer, int dictionaryCreationThreshold)
{
    if (dictionaryCreationThreshold < -1)
    {
        throw new ArgumentOutOfRangeException(nameof(dictionaryCreationThreshold), 
            SR.ArgumentOutOfRange_InvalidThreshold);
    }
    
    this.comparer = comparer ?? EqualityComparer<TKey>.Default;
    threshold = dictionaryCreationThreshold == -1 ? int.MaxValue : dictionaryCreationThreshold;
}

public class Product
{
    public string Sku { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }

    public Product(string sku, string name, decimal price, int stock)
    {
        Sku = sku; Name = name; Price = price; Stock = stock;
    }

    public override string ToString() => $"{Sku}: {Name} - ${Price} (Stock: {Stock})";
}

public class ProductCollection : KeyedCollection<string, Product>
{
    protected override string GetKeyForItem(Product item)
    {
        return item.Sku;
    }
}

class Program
{
    static void Main()
    {
        var products = new ProductCollection();

        products.Add(new Product("NB-001", "Notebook", 2.50m, 100));
        products.Add(new Product("PN-002", "Pen", 1.20m, 200));
        products.Add(new Product("ER-003", "Eraser", 0.80m, 150));

        for (int i = 0; i < products.Count; i++)
        {
            Console.WriteLine($"[{i}] {products[i]}");
        }

        Console.WriteLine($"SKU 'PN-002': {products["PN-002"]}");

        foreach (var product in products)
            Console.WriteLine(product);

        Console.WriteLine($"Contains 'NB-001': {products.Contains("NB-001")}");
        Console.WriteLine($"Contains 'XX-999': {products.Contains("XX-999")}");

        if (products.TryGetValue("ER-003", out var eraser))
        {
            Console.WriteLine($"Found: {eraser}");
        }

        products.Remove("PN-002");
        Console.WriteLine($"After removal, Count: {products.Count}");
    }
}

using System;
using System.Collections.ObjectModel;

public class Student
{
    public int StudentId { get; }  // 学号作为键
    public string Name { get; set; }
    public Dictionary<string, double> Grades { get; } = new();

    public Student(int studentId, string name)
    {
        StudentId = studentId;
        Name = name;
    }

    public void AddGrade(string subject, double grade)
    {
        Grades[subject] = grade;
    }

    public double GetAverageGrade()
    {
        return Grades.Values.Any() ? Grades.Values.Average() : 0;
    }

    public override string ToString()
    {
        return $"ID: {StudentId}, Name: {Name}, Avg: {GetAverageGrade():F2}";
    }
}

public class StudentCollection : KeyedCollection<int, Student>
{
    // 使用自定义比较器（例如按学号模10分组）
    public StudentCollection() : base(new StudentIdComparer()) { }

    protected override int GetKeyForItem(Student student)
    {
        return student.StudentId;
    }

    // 自定义比较器：学号最后一位相同的视为相等（示例用途）
    private class StudentIdComparer : IEqualityComparer<int>
    {
        public bool Equals(int x, int y) => (x % 10) == (y % 10);
        public int GetHashCode(int obj) => (obj % 10).GetHashCode();
    }
}

class AdvancedExample
{
    static void Main()
    {
        var students = new StudentCollection();

        // 添加学生
        students.Add(new Student(1001, "Alice") { Grades = { ["Math"] = 85, ["Science"] = 92 } });
        students.Add(new Student(1002, "Bob") { Grades = { ["Math"] = 78, ["Science"] = 88 } });
        students.Add(new Student(1011, "Charlie") { Grades = { ["Math"] = 95, ["Science"] = 90 } });

        Console.WriteLine("=== 所有学生 ===");
        foreach (var student in students)
        {
            Console.WriteLine(student);
        }

        Console.WriteLine("\n=== 键访问和比较器测试 ===");
        // 由于比较器，1001 和 1011 被视为相同键
        Console.WriteLine($"Contains 1001: {students.Contains(1001)}");
        Console.WriteLine($"Contains 1011: {students.Contains(1011)}"); // 返回 true！

        // 尝试访问会抛出异常，因为键冲突
        try
        {
            var student = students[1011];
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"错误: {ex.Message}");
        }

        Console.WriteLine("\n=== 性能阈值测试 ===");
        TestPerformanceThreshold();
    }

    static void TestPerformanceThreshold()
    {
        // 创建延迟字典创建的集合（阈值=5）
        var smallCollection = new KeyedCollection<string, string>(null, 5)
        {
            "A", "B", "C", "D"  // 前4个元素不会创建字典
        };

        // 此时内部应该还没有字典
        Console.WriteLine($"Count: {smallCollection.Count}");
        
        smallCollection.Add("E");  // 第5个元素，达到阈值，创建字典
        Console.WriteLine("Added 5th item - dictionary created internally");
    }
}

public abstract class ReadOnlyCollectionBase : ICollection, IEunmerable
{
    protected ReadOnlyCollectionBase();

    public virtual int Count { get; }
    protected ArrayList InnerList { get; }

    public virtual IEnumerator GetEnumerator();
}

public abstract class ReadOnlyCollectionBase : ICollection
{
    private ArrayList? _list;

    protected ArrayList InnerList => _list ??= new ArrayList();

    public virtual int Count
    {
        get { return InnerList.Count; }
    }

    bool ICollection.IsSynchronized
    {
        get { return InnerList.IsSynchronized; }
    }

    object ICollection.SyncRoot
    {
        get { return InnerList.SyncRoot; }
    }

    void ICollection.CopyTo(Array array, int index)
    {
        InnerList.CopyTo(array, index);
    }

    public virtual IEnumerator GetEnumerator()
    {
        return InnerList.GetEnumerator();
    }
}

using System;
using System.Collections;

public class MyReadOnlyCollection : ReadOnlyCollectionBase
{
    // 使用内部的 InnerList 来构建只读集合
    public MyReadOnlyCollection(ArrayList list)
    {
        InnerList.AddRange(list);
    }

    // 添加方法 (只是为了展示，这不会改变集合的只读性)
    public void DisplayItems()
    {
        foreach (var item in InnerList)
        {
            Console.WriteLine(item);
        }
    }
}

class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList { "Apple", "Banana", "Cherry" };

        MyReadOnlyCollection readOnlyCollection = new MyReadOnlyCollection(list);

        // 打印所有元素
        readOnlyCollection.DisplayItems();

        // 尝试修改 InnerList（不推荐，演示目的）// 根本访问不到 protected
        // readOnlyCollection.InnerList[0] = "Orange"; // 这样会修改原始数据，但不影响 ReadOnlyCollection
    }
}