C# 消息队列、多线程、回滚、并行编程、异步编程、反射

消息队列

消息队列是一种在应用程序之间传递消息的异步通信机制。它可以使应用程序解耦并提高系统的可伸缩性和可靠性。在 C# 中，你可以使用多个消息队列技术，其中一种广泛使用的技术是 RabbitMQ。

RabbitMQ 是一个开源的消息代理，实现了高级消息队列协议（AMQP），提供了强大的功能来处理消息传递。以下是一个使用 RabbitMQ 的 C# 示例：

cs 复制代码

using RabbitMQ.Client;
using RabbitMQ.Client.Events;

// 创建连接和通道
var factory = new ConnectionFactory() { HostName = "localhost" };
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
    // 声明队列
    channel.QueueDeclare(queue: "hello",
                         durable: false,
                         exclusive: false,
                         autoDelete: false,
                         arguments: null);

    // 发布消息
    var message = "Hello, RabbitMQ!";
    var body = Encoding.UTF8.GetBytes(message);
    channel.BasicPublish(exchange: "",
                         routingKey: "hello",
                         basicProperties: null,
                         body: body);

    Console.WriteLine(" [x] Sent {0}", message);
}

以上示例演示了如何创建一个 RabbitMQ 连接，声明队列，并发布一条消息到该队列。

多线程

多线程允许在同一时间执行多个独立的任务，以提高程序的效率和响应性。在 C# 中，你可以使用 System.Threading.Thread 命名空间来处理多线程编程。以下是一个简单的多线程示例：

cs 复制代码

using System;
using System.Threading;

public class Program
{
    public static void Main()
    {
        // 创建并启动新线程
        Thread newThread = new Thread(WorkerMethod);
        newThread.Start();

        // 在主线程中执行其他任务
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("Main thread executing...");
            Thread.Sleep(1000);
        }

        // 等待新线程结束
        newThread.Join();

        Console.WriteLine("Main thread finished.");
    }

    public static void WorkerMethod()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("Worker thread executing...");
            Thread.Sleep(2000);
        }
    }
}

以上示例创建了一个新线程并在后台执行 WorkerMethod 方法。同时，主线程也在执行自己的任务。两个线程交替输出消息，直到达到各自执行次数的上限。

多线程处理逻辑

在多线程编程中，处理逻辑涉及管理线程之间的同步、协作和临界区等问题。C# 提供了几种机制来处理这些问题，如锁 (lock)、互斥体 (Mutex) 和信号量 (Semaphore)。以下是一个使用 lock 实现同步访问共享资源的示例：

cs 复制代码

using System;
using System.Threading;

public class Program
{
    private static object lockObj = new object();
    private static int counter = 0;

    public static void Main()
    {
        Thread thread1 = new Thread(IncrementCounter);
        Thread thread2 = new Thread(IncrementCounter);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Final counter value: " + counter);
    }

    public static void IncrementCounter()
    {
        for (int i = 0; i < 100000; i++)
        {
            lock (lockObj)
            {
                counter++;
            }
        }
    }
}

以上示例创建了两个线程来同时递增一个共享计数器变量。为了确保线程安全，我们使用 lock 语句将对共享资源的访问限制在一次只有一个线程进行。最终输出的计数器值应该是 200,000。

回滚

回滚是指撤销或取消已经执行的操作以返回到先前的状态。在 C# 中，你可以使用事务 (Transaction) 来实现回滚操作。事务允许你将多个相关操作包装在一起，并要么全部成功，要么全部失败。如果发生失败，可以回滚整个事务以恢复到初始状态。

以下是一个使用 TransactionScope 的回滚示例：

cs 复制代码

using System;
using System.Transactions;

public class Program
{
    public static void Main()
    {
        using (var scope = new TransactionScope())
        {
            try
            {
                // 执行一些数据库操作或其他事务性操作

                // 提交事务
                scope.Complete();
            }
            catch (Exception ex)
            {
                // 回滚事务
                Console.WriteLine("An error occurred: " + ex.Message);
            }
        }
    }
}

在以上示例中，我们使用 TransactionScope 来创建一个新的事务范围。在事务范围内执行的操作将受到该事务的管理。如果出现异常或未调用 scope.Complete()，事务将自动回滚。

并行编程

并行编程是指同时执行多个任务以提高程序性能的编程范例。在 C# 中，你可以使用 Task 和 Parallel 类来实现并行编程。以下是一个使用 Parallel.ForEach 进行并行迭代的示例：

cs 复制代码

using System;
using System.Threading.Tasks;

public class Program
{
    public static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };

        Parallel.ForEach(numbers, number =>
        {
            Console.WriteLine("Processing number: " + number);
            // 执行一些操作
        });
    }
}

以上示例使用 Parallel.ForEach 方法在多个线程中并行迭代给定的集合。每个数字都被发送到不同的线程进行处理，从而加快整体处理速度。

异步编程

异步编程允许在等待某些长时间运行的操作完成时释放主线程，以避免阻塞用户界面或其他任务。在 C# 中，你可以使用 async 和 await 关键字来实现异步编程。以下是一个异步方法的示例：

cs 复制代码

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

public class Program
{
    public static async Task Main()
    {
        await DoSomethingAsync();
    }

    public static async Task DoSomethingAsync()
    {
        HttpClient httpClient = new HttpClient();
        string result = await httpClient.GetStringAsync("https://www.example.com");
        Console.WriteLine(result);
    }
}

以上示例中的 DoSomethingAsync 方法执行了一个 HTTP 请求，并在等待请求完成时释放主线程。这样可以确保应用程序在请求期间仍然响应其他操作。

反射

反射是一种在运行时检查和修改类型、对象和成员信息的能力。在 C# 中，你可以使用 System.Reflection 命名空间中的类来实现反射。以下是一个使用反射获取和调用方法的示例：

cs 复制代码

using System;
using System.Reflection;

public class Program
{
    public static void Main()
    {
        Type type = typeof(MyClass);

        // 获取方法信息
        MethodInfo methodInfo = type.GetMethod("MyMethod");

        // 创建实例
        object instance = Activator.CreateInstance(type);

        // 调用方法
        methodInfo.Invoke(instance, null);
    }
}

public class MyClass
{
    public void MyMethod()
    {
        Console.WriteLine("Hello from MyMethod!");
    }
}

以上示例使用反射获取了 MyClass 类的 MyMethod 方法的信息，并通过反射调用该方法。这使得我们可以在运行时动态地发现和调用类型和成员。