C#编程技巧——1

1.委托和事件：
委托是一种类型，它可以存储对方法的引用。事件是基于委托的一种特殊机制，用于实现发布-订阅模式，允许对象间的松耦合通信。

在下面的例子中，我们将创建一个简单的计时器，当计时器触发事件时，将通知订阅者（监听器）。

using System;

// 定义一个委托用于表示事件处理方法的签名
public delegate void TimerEventHandler(object sender, EventArgs e);

// 定义事件参数类
public class EventArgs : EventArgs { }

// 计时器类
public class Timer
{
    // 声明一个事件
    public event TimerEventHandler TimerElapsed;

    // 触发事件的方法
    public void StartTimer(int interval)
    {
        Console.WriteLine("Timer started...");
        System.Threading.Thread.Sleep(interval); // 模拟计时器等待

        OnTimerElapsed(); // 触发事件
    }

    protected virtual void OnTimerElapsed()
    {
        TimerEventHandler handler = TimerElapsed;
        if (handler != null)
        {
            handler(this, new EventArgs());
        }
    }
}

// 订阅者类
public class Listener
{
    public void OnTimerElapsed(object sender, EventArgs e)
    {
        Console.WriteLine("Timer elapsed! Event handled by Listener.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Timer timer = new Timer();
        Listener listener = new Listener();

        // 订阅事件
        timer.TimerElapsed += listener.OnTimerElapsed;

        // 启动计时器
        timer.StartTimer(3000); // 模拟3秒后计时器触发事件

        Console.ReadLine();
    }
}

在这个例子中，我们定义了一个 Timer 类，其中声明了一个事件 TimerElapsed，并且定义了订阅者 Listener 类，它包含了处理事件的方法 OnTimerElapsed。在 Main 方法中，我们创建了一个 Timer 实例和一个 Listener 实例，然后订阅了 Timer 的 TimerElapsed 事件。当计时器启动后，经过一段时间后，TimerElapsed 事件被触发，并且订阅的监听器执行相应的处理方法。

2.利用 LINQ: Language Integrated Query (LINQ) 可以大大简化对集合的查询和操作。

假设我们有一个包含学生信息的集合，每个学生包含姓名和年龄。现在，我们想要从这个集合中筛选出年龄大于等于 18 岁的学生，并按照姓名字母顺序排序。

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        // 创建包含学生信息的集合
        List<Student> students = new List<Student>()
        {
            new Student() { Name = "Alice", Age = 20 },
            new Student() { Name = "Bob", Age = 18 },
            new Student() { Name = "Charlie", Age = 22 },
            new Student() { Name = "David", Age = 16 }
        };

        // 使用 LINQ 查询年龄大于等于 18 岁的学生，并按姓名字母顺序排序
        var result = from student in students
                     where student.Age >= 18
                     orderby student.Name
                     select student;

        // 输出查询结果
        Console.WriteLine("Adult students:");
        foreach (var student in result)
        {
            Console.WriteLine($"Name: {student.Name}, Age: {student.Age}");
        }
    }
}

// 学生类
public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

在这个例子中，我们使用 LINQ 查询语法从 students 集合中筛选出年龄大于等于 18 岁的学生，并按姓名字母顺序进行排序。最后，我们通过 foreach 循环输出查询结果。

3.C# 掌握异步编程: 使用 async/await 关键字进行异步编程，可以提高程序的响应性能。

步编程是 C# 中非常重要的概念，可以帮助改善程序的响应性能。使用 async/await 关键字可以简化异步操作的编写，使代码更加清晰和易于理解。

下面是一个简单的示例，演示如何使用 async/await 关键字进行异步编程：

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        await MakeRequestAsync();
    }

    static async Task MakeRequestAsync()
    {
        using (HttpClient client = new HttpClient())
        {
            string url = "https://jsonplaceholder.typicode.com/posts/1";
            HttpResponseMessage response = await client.GetAsync(url);
            if (response.IsSuccessStatusCode)
            {
                string content = await response.Content.ReadAsStringAsync();
                Console.WriteLine($"Response: {content}");
            }
            else
            {
                Console.WriteLine($"Failed to make the request. Status code: {response.StatusCode}");
            }
        }
    }
}

在这个示例中，我们定义了一个异步方法 MakeRequestAsync，里面使用了 HttpClient 类来发送异步 HTTP 请求。我们使用 await 关键字来等待异步操作完成，这样可以让程序保持响应并不阻塞，提高了程序的性能和并发处理能力。

使用 async/await 可以让异步编程变得更加简洁和可读，让开发者更容易理解和编写异步操作。记得在使用异步方法时，方法的返回类型应该是 Task 或 Task<T>，并且在方法内部使用 await 来等待异步操作完成。