1
// 泛型类
2
class GenericClass<T>
3
{
4
    // 类型参数T可以在类内部作为类型使用
5
    private T _value;
6

7
    public void SetValue(T value)
8
    {
9
        _value = value;
10
    }
11

12
    public T GetValue()
13
    {
14
        return _value;
15
    }
16
}

1
// 单类型参数泛型类
2
public class Stack<T>
3
{
4
    private T[] _items;
5
    private int _count;
6

7
    public Stack(int capacity)
8
    {
9
        _items = new T[capacity];
10
        _count = 0;
11
    }
12

13
    public void Push(T item)
14
    {
15
        if (_count == _items.Length)
16
        {
17
            Array.Resize(ref _items, _items.Length * 2);
18
        }
19
        _items[_count++] = item;
20
    }
21

22
    public T Pop()
23
    {
24
        if (_count == 0)
25
        {
26
            throw new InvalidOperationException("Stack is empty");
27
        }
28
        return _items[--_count];
29
    }
30

31
    public bool IsEmpty => _count == 0;
32
}
33

34
// 使用泛型类
35
var intStack = new Stack<int>(5);
36
intStack.Push(10);
37
intStack.Push(20);
38
int value = intStack.Pop(); // 20
39

40
var stringStack = new Stack<string>(5);
41
stringStack.Push("Hello");
42
stringStack.Push("World");
43
string text = stringStack.Pop(); // "World"

1
// 泛型接口
2
public interface IRepository<T>
3
{
4
    T GetById(int id);
5
    void Add(T entity);
6
    void Update(T entity);
7
    void Delete(T entity);
8
    IEnumerable<T> GetAll();
9
}
10

11
// 实现泛型接口
12
public class UserRepository : IRepository<User>
13
{
14
    private List<User> _users = new List<User>();
15

16
    public User GetById(int id)
17
    {
18
        return _users.FirstOrDefault(u => u.Id == id);
19
    }
20

21
    public void Add(User entity)
22
    {
23
        _users.Add(entity);
24
    }
25

26
    public void Update(User entity)
27
    {
28
        var user = GetById(entity.Id);
29
        if (user != null)
30
        {
31
            user.Name = entity.Name;
32
            user.Email = entity.Email;
33
        }
34
    }
35

36
    public void Delete(User entity)
37
    {
38
        _users.Remove(entity);
39
    }
40

41
    public IEnumerable<User> GetAll()
42
    {
43
        return _users;
44
    }
45
}
46

47
public class User
48
{
49
    public int Id { get; set; }
50
    public string Name { get; set; }
51
    public string Email { get; set; }
52
}

1
public class GenericMethods
2
{
3
    // 泛型方法
4
    public T Max<T>(T a, T b) where T : IComparable<T>
5
    {
6
        return a.CompareTo(b) > 0 ? a : b;
7
    }
8

9
    // 静态泛型方法
10
    public static void Swap<T>(ref T a, ref T b)
11
    {
12
        T temp = a;
13
        a = b;
14
        b = temp;
15
    }
16

17
    // 泛型方法与类型推断
18
    public void Print<T>(T value)
19
    {
20
        Console.WriteLine($"Value: {value}, Type: {typeof(T).Name}");
21
    }
22
}
23

24
// 使用泛型方法
25
var genericMethods = new GenericMethods();
26

27
// 显式指定类型参数
28
int maxInt = genericMethods.Max<int>(10, 20); // 20
29
string maxString = genericMethods.Max<string>("apple", "banana"); // "banana"
30

31
// 类型推断
32
int a = 10, b = 20;
33
GenericMethods.Swap(ref a, ref b); // a=20, b=10
34

35
// 类型推断
36
genericMethods.Print(10); // Value: 10, Type: Int32
37
genericMethods.Print("Hello"); // Value: Hello, Type: String
38
genericMethods.Print(3.14); // Value: 3.14, Type: Double

1
// 编译器推断T为int
2
genericMethods.Print(10);
3

4
// 编译器推断T为string
5
genericMethods.Print("Hello");

1
// 多个约束，用逗号分隔
2
public class GenericConstraintExample<T, U>
3
    where T : class, IComparable<T>, new()
4
    where U : struct
5
{
6
    public T CreateInstance()
7
    {
8
        // 使用new()约束创建实例
9
        return new T();
10
    }
11

12
    public int Compare(T a, T b)
13
    {
14
        // 使用IComparable<T>约束调用CompareTo方法
15
        return a.CompareTo(b);
16
    }
17

18
    public void Process(U value)
19
    {
20
        // U是值类型
21
        Console.WriteLine($"Processing value: {value}");
22
    }
23
}
24

25
// 实现IComparable接口的类
26
public class Person : IComparable<Person>
27
{
28
    public string Name { get; set; }
29
    public int Age { get; set; }
30

31
    public int CompareTo(Person other)
32
    {
33
        if (other == null) return 1;
34
        return Age.CompareTo(other.Age);
35
    }
36
}
37

38
// 使用带约束的泛型类
39
var example = new GenericConstraintExample<Person, int>();
40
Person person = example.CreateInstance();
41
person.Name = "Alice";
42
person.Age = 30;
43

44
example.Process(42); // Processing value: 42

1
// 泛型委托定义
2
public delegate TResult Func<T, TResult>(T arg);
3
public delegate void Action<T>(T arg);
4
public delegate bool Predicate<T>(T obj);
5

6
// 自定义泛型委托
7
public delegate T Output<T, U, V>(U input1, V input2);
8

9
// 使用泛型委托
10
Func<int, int> square = x => x * x;
11
int result = square(5); // 25
12

13
Action<string> print = s => Console.WriteLine(s);
14
print("Hello World"); // 输出: Hello World
15

16
Predicate<int> isEven = x => x % 2 == 0;
17
bool even = isEven(4); // true
18

19
// 使用自定义泛型委托
20
Output<int, int, int> add = (a, b) => a + b;
21
int sum = add(3, 5); // 8

1
// 泛型事件参数
2
public class GenericEventArgs<T> : EventArgs
3
{
4
    public T Data { get; }
5

6
    public GenericEventArgs(T data)
7
    {
8
        Data = data;
9
    }
10
}
11

12
// 使用泛型委托的事件
13
public class Publisher<T>
14
{
15
    // 定义泛型事件
16
    public event EventHandler<GenericEventArgs<T>> GenericEvent;
17

18
    protected virtual void OnGenericEvent(T data)
19
    {
20
        GenericEvent?.Invoke(this, new GenericEventArgs<T>(data));
21
    }
22

23
    public void Publish(T data)
24
    {
25
        Console.WriteLine($"Publishing: {data}");
26
        OnGenericEvent(data);
27
    }
28
}
29

30
// 订阅泛型事件
31
public class Subscriber
32
{
33
    public void Subscribe<T>(Publisher<T> publisher)
34
    {
35
        publisher.GenericEvent += (sender, e) =>
36
            Console.WriteLine($"Received: {e.Data}, Type: {typeof(T).Name}");
37
    }
38
}
39

40
// 使用泛型事件
41
var publisher = new Publisher<int>();
42
var subscriber = new Subscriber();
43
subscriber.Subscribe(publisher);
44
publisher.Publish(42); // 输出: Publishing: 42  Received: 42, Type: Int32
45

46
var stringPublisher = new Publisher<string>();
47
subscriber.Subscribe(stringPublisher);
48
stringPublisher.Publish("Hello"); // 输出: Publishing: Hello  Received: Hello, Type: String

1
// 协变接口定义
2
public interface ICovariant<out T>
3
{
4
    T GetItem();
5
    // 以下方法会导致编译错误，因为T是协变的，不能作为参数
6
    // void SetItem(T item);
7
}
8

9
// 实现协变接口
10
public class CovariantImplementation<T> : ICovariant<T>
11
{
12
    private T _item;
13

14
    public CovariantImplementation(T item)
15
    {
16
        _item = item;
17
    }
18

19
    public T GetItem()
20
    {
21
        return _item;
22
    }
23
}
24

25
// 协变的使用
26
ICovariant<string> stringCovariant = new CovariantImplementation<string>("Hello");
27
// 协变：可以将ICovariant<string>赋值给ICovariant<object>
28
ICovariant<object> objectCovariant = stringCovariant;
29
object item = objectCovariant.GetItem(); // "Hello"
30

31
// .NET中的协变示例
32
IEnumerable<string> strings = new List<string> { "a", "b", "c" };
33
IEnumerable<object> objects = strings; // 协变

1
// 逆变接口定义
2
public interface IContravariant<in T>
3
{
4
    void SetItem(T item);
5
    // 以下方法会导致编译错误，因为T是逆变的，不能作为返回值
6
    // T GetItem();
7
}
8

9
// 实现逆变接口
10
public class ContravariantImplementation<T> : IContravariant<T>
11
{
12
    public void SetItem(T item)
13
    {
14
        Console.WriteLine($"Set item: {item}");
15
    }
16
}
17

18
// 逆变的使用
19
IContravariant<object> objectContravariant = new ContravariantImplementation<object>();
20
// 逆变：可以将IContravariant<object>赋值给IContravariant<string>
21
IContravariant<string> stringContravariant = objectContravariant;
22
stringContravariant.SetItem("Hello"); // Set item: Hello
23

24
// .NET中的逆变示例
25
Action<object> objectAction = o => Console.WriteLine(o);
26
Action<string> stringAction = objectAction; // 逆变
27
stringAction("Hello"); // Hello

1
// 基本使用
2
Func<int, int, int> add = delegate(int a, int b)
3
{
4
    return a + b;
5
};
6
int result = add(3, 5); // 结果为8
7

8
// 作为参数传递
9
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
10
List<int> evenNumbers = numbers.FindAll(delegate(int x) { return x % 2 == 0; });
11

12
// 闭包特性
13
int factor = 2;
14
Func<int, int> multiplyByFactor = delegate(int x) { return x * factor; };
15
int result2 = multiplyByFactor(5); // 结果为10，因为factor=2
16
factor = 3;
17
int result3 = multiplyByFactor(5); // 结果为15，因为factor=3（闭包捕获的是变量引用）

1
// 基本语法
2
// (参数列表) => 表达式
3
// 或
4
// (参数列表) => { 语句块 }
5

6
// 单行Lambda表达式
7
Func<int, int, int> add = (a, b) => a + b;
8
Func<string, int> getLength = s => s.Length;
9
Action<string> print = s => Console.WriteLine(s);
10

11
// 多行Lambda表达式
12
Func<int, int> calculateSquare = x =>
13
{
14
    Console.WriteLine($"计算 {x} 的平方");
15
    return x * x;
16
};
17

18
// 各种简写形式
19
Func<int, bool> isEven = x => x % 2 == 0; // 单个参数可省略括号
20
Action printHello = () => Console.WriteLine("Hello"); // 无参数
21
Func<int, int, bool> isGreater = (a, b) => a > b; // 多个参数

1
// 将Person对象转换为匿名类型
2
Func<Person, object> toAnonymousType = p => new { p.Name, AgeGroup = p.Age >= 18 ? "Adult" : "Minor" };
3

4
// 组合多个Func
5
Func<int, int> doubleIt = x => x * 2;
6
Func<int, int> addFive = x => x + 5;
7
Func<int, int> processNumber = x => addFive(doubleIt(x)); // 先乘2再加5
8
int result = processNumber(10); // 结果为25

1
// 根据条件返回不同的处理函数
2
Func<int, int> GetProcessor(bool useAddition)
3
{
4
    if (useAddition)
5
        return x => x + 10;
6
    else
7
        return x => x * 10;
8
}
9

10
// 使用
11
var processor = GetProcessor(true);
12
int result = processor(5); // 结果为15

1
// 对集合中的每个元素执行相同操作
2
void ProcessCollection<T>(IEnumerable<T> collection, Action<T> action)
3
{
4
    foreach (var item in collection)
5
    {
6
        action(item);
7
    }
8
}
9

10
// 使用
11
List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
12
ProcessCollection(names, name => Console.WriteLine(name.ToUpper()));

1
// 创建一个包含多个操作的复合Action
2
Action<string> log = s => Console.WriteLine($"[{DateTime.Now}] {s}");
3
Action<string> validate = s =>
4
{
5
    if (string.IsNullOrWhiteSpace(s))
6
        throw new ArgumentException("输入不能为空");
7
};
8
Action<string> process = s =>
9
{
10
    log($"开始处理: {s}");
11
    validate(s);
12
    log($"处理完成: {s}");
13
};
14

15
// 使用
16
process("有效输入");

1
public class Product
2
{
3
    public string Name { get; set; }
4
    public decimal Price { get; set; }
5
    public bool IsInStock { get; set; }
6
}
7

8
// 创建产品列表
9
List<Product> products = new List<Product>
10
{
11
    new Product { Name = "笔记本电脑", Price = 5999.99m, IsInStock = true },
12
    new Product { Name = "智能手机", Price = 3999.99m, IsInStock = true },
13
    new Product { Name = "平板电脑", Price = 2999.99m, IsInStock = false },
14
    new Product { Name = "无线耳机", Price = 999.99m, IsInStock = true }
15
};
16

17
// 定义复杂筛选条件
18
Predicate<Product> affordableInStockProducts = p =>
19
    p.IsInStock && p.Price < 3000;
20

21
// 使用Predicate筛选
22
List<Product> filteredProducts = products.FindAll(affordableInStockProducts);

1
// 组合多个条件
2
Predicate<int> isEven = x => x % 2 == 0;
3
Predicate<int> isGreaterThan5 = x => x > 5;
4
Predicate<int> isEvenAndGreaterThan5 = x => isEven(x) && isGreaterThan5(x);
5

6
// 使用
7
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
8
List<int> filtered = numbers.FindAll(isEvenAndGreaterThan5);

1
// 定义委托类型
2
delegate void NumberHandler(int number);
3

4
// 创建委托实例
5
NumberHandler printNumber = n => Console.WriteLine($"数字: {n}");
6
NumberHandler doubleNumber = n => Console.WriteLine($"两倍: {n * 2}");
7
NumberHandler squareNumber = n => Console.WriteLine($"平方: {n * n}");
8

9
// 组合委托链
10
NumberHandler chain = printNumber + doubleNumber + squareNumber;
11

12
// 调用委托链
13
chain(5);
14
// 输出:
15
// 数字: 5
16
// 两倍: 10
17
// 平方: 25
18

19
// 移除委托
20
chain -= doubleNumber;
21
chain(5);
22
// 输出:
23
// 数字: 5
24
// 平方: 25

1
// 定义事件参数类
2
public class OrderEventArgs : EventArgs
3
{
4
    public int OrderId { get; }
5
    public decimal TotalAmount { get; }
6
    public OrderEventArgs(int orderId, decimal totalAmount)
7
    {
8
        OrderId = orderId;
9
        TotalAmount = totalAmount;
10
    }
11
}
12

13
// 定义发布者类
14
public class OrderService
15
{
16
    // 声明事件
17
    public event EventHandler<OrderEventArgs> OrderPlaced;
18
    public event EventHandler<OrderEventArgs> OrderShipped;
19

20
    // 触发事件的方法
21
    protected virtual void OnOrderPlaced(OrderEventArgs e)
22
    {
23
        // 检查是否有订阅者
24
        OrderPlaced?.Invoke(this, e);
25
    }
26

27
    protected virtual void OnOrderShipped(OrderEventArgs e)
28
    {
29
        OrderShipped?.Invoke(this, e);
30
    }
31

32
    // 业务方法
33
    public void PlaceOrder(int orderId, decimal amount)
34
    {
35
        Console.WriteLine($"订单 {orderId} 已创建");
36
        // 触发事件
37
        OnOrderPlaced(new OrderEventArgs(orderId, amount));
38
    }
39

40
    public void ShipOrder(int orderId, decimal amount)
41
    {
42
        Console.WriteLine($"订单 {orderId} 已发货");
43
        // 触发事件
44
        OnOrderShipped(new OrderEventArgs(orderId, amount));
45
    }
46
}
47

48
// 定义订阅者类
49
public class EmailService
50
{
51
    public void HandleOrderPlaced(object sender, OrderEventArgs e)
52
    {
53
        Console.WriteLine($"发送确认邮件: 订单 {e.OrderId} (金额: {e.TotalAmount})");
54
    }
55

56
    public void HandleOrderShipped(object sender, OrderEventArgs e)
57
    {
58
        Console.WriteLine($"发送发货邮件: 订单 {e.OrderId} (金额: {e.TotalAmount})");
59
    }
60
}
61

62
// 使用示例
63
var orderService = new OrderService();
64
var emailService = new EmailService();
65

66
// 订阅事件
67
orderService.OrderPlaced += emailService.HandleOrderPlaced;
68
orderService.OrderShipped += emailService.HandleOrderShipped;
69

70
// 触发事件
71
orderService.PlaceOrder(1001, 99.99m);
72
orderService.ShipOrder(1001, 99.99m);
73

74
// 输出:
75
// 订单 1001 已创建
76
// 发送确认邮件: 订单 1001 (金额: 99.99)
77
// 订单 1001 已发货
78
// 发送发货邮件: 订单 1001 (金额: 99.99)