C# 使用线程或委托的后台/异步进程

在我的网站
1.填写表单后，在SQL数据库中插入该记录
2.在下一行中，我获取一些类对象，然后发送到与其他记录匹配的对象
3.在匹配应用程序中花费了这么多时间

现在我决定使用线程或委托将匹配的进程放在后台/异步中

我以前的代码是：
1.在数据库中插入所有信息 objclsbdal.InsertAcquirePrvider（objAcqProvBL）

问题1在后台/异步-线程或委托中运行进程的最佳方式是哪一种

现在我正在使用线程：

objclsBbDAL.InsertAcquirePrvider(objAcqProvBL);
//Threading
CallMatchMakingOnDiffThread(objAcqProvBL);

private void CallMatchMakingOnDiffThread(clsAcquireProviderBL objAcqPro)
{
    clsMatchMakingDAL objclsMatchMakingDAL = new clsMatchMakingDAL();
    Thread objThread = new Thread(() => objclsMatchMakingDAL.AcquireMatch(objAcqPro));
    objThread.Start();
}

---

问题2如何使用代理执行此任务？

您不能仅使用代理执行后台处理。 委托与线程或异步进程完全不同。 您可以将委托理解为指向函数的指针。 线程使用委托来执行某个函数，但委托本身并不是任何类型的后台执行。

---

执行上面提到的操作将在后台运行流程，但您必须知道以这种方式在后台运行操作的成本。您还需要知道它是真的需要在后台运行，还是只需要优化。

委托就像回调一样，您使用它们来通知异步任务已经完成，这意味着线程需要调用事件，该事件应该有一个委托连接到它上

例如：

public struct ThreadData
{
    public int handle;
    public string details;
    public ThreadData(int handle, string details)
    {
        this.handle = handle;
        this.details = details;
    }
}
public class ThreadWorker
{
    private List<Thread> threads = new List<Thread>();
    public int BeginAsyncWork(string details)
    {
        Thread thread = new Thread(new ParameterizedThreadStart(ThreadMethod));
        threads.Add(thread);
        thread.Start(new ThreadData(threads.Count - 1, details));
        return threads.Count - 1;
    }
    private void ThreadMethod(object parameter)
    {
        ThreadData data = (ThreadData)parameter;
        Console.WriteLine(data.details);
        if (ThreadFinished != null) { ThreadFinished(data.handle); }
    }
    public delegate void ThreadEndDelegate(int handle);
    public event ThreadEndDelegate ThreadFinished;
}
public static class Program
{
    private static int[] handles;
    public static void Main()
    {
        handles = new int[4];
        ThreadWorker worker = new ThreadWorker();
        worker.ThreadFinished += new ThreadWorker.ThreadEndDelegate(OnThreadFinished);
        for (int i = 0; i < 4; i++)
        {
            handles[i] = worker.BeginAsyncWork("working: " + i);
        }
        Console.ReadKey();
    }
    private static void OnThreadFinished(int handle)
    {
        Console.WriteLine("thread: " + handle + " finished");
        handles[handle] = 0;
    }
}

public struct ThreadData
{
公共int句柄；
公共字符串详细信息；
公共线程数据（int句柄、字符串详细信息）
{
this.handle=handle；
this.details=详细信息；
}
}
公营制线工
{
私有列表线程=新列表（）；
public int BeginAsyncWork（字符串详细信息）
{
线程线程=新线程（新的参数化线程启动（ThreadMethod））；
线程。添加（线程）；
Start（新的ThreadData（threads.Count-1，details））；
返回线程。计数为-1；
}
私有void ThreadMethod（对象参数）
{
ThreadData数据=（ThreadData）参数；
Console.WriteLine（数据.详细信息）；
如果（ThreadFinished！=null）{ThreadFinished（data.handle）；}
}
公共委托void ThreadEndDelegate（int句柄）；
公共事件ThreadEndDelegate ThreadFinished；
}
公共静态类程序
{
私有静态int[]句柄；
公共静态void Main（）
{
句柄=新整数[4]；
ThreadWorker=新的ThreadWorker（）；
worker.ThreadFinished+=新的ThreadWorker.ThreadEndDelegate（OnThreadFinished）；
对于（int i=0；i<4；i++）
{
handles[i]=worker.BeginAsyncWork（“working:+i”）；
}
Console.ReadKey（）；
}
私有静态无效已完成（int句柄）
{
控制台写入线（“线程：“+句柄+”完成”）；
句柄[句柄]=0；
}
}

这是冗长的，但它允许完全控制你的线程

编辑：

未经测试的代码。我能想到的最短可能的解决办法

objclsBbDAL.InsertAcquirePrvider(objAcqProvBL);
//Threading
CallMatchMakingOnDiffThread(objAcqProvBL);

private void OnMatchAcquired(object match)
{
//do work with found match
}
private event Action<object> MatchAcquired = new Action<object>(OnMatchAcquired);

private void CallMatchMakingOnDiffThread(clsAcquireProviderBL objAcqPro)
{
    clsMatchMakingDAL objclsMatchMakingDAL = new clsMatchMakingDAL();
    Thread objThread = new Thread(
() => object match = (object)objclsMatchMakingDAL.AcquireMatch(objAcqPro); if(ThreadComplete!=nil){MatchAcquired(match);}
);
    objThread.Start();
}

objclsbdal.InsertAcquirePrvider（objAcqProvBL）；
//穿线
调用MatchMakingOnDiffThread（objAcqProvBL）；
已获取私有void onMatch（对象匹配）
{
//使用找到的匹配项进行工作
}
私有事件操作MatchAcquired=新操作（OnMatchAcquired）；
私有无效调用MatchMakingOnDiffThread（CLSAQUIREProviderBL objAcqPro）
{
clsMatchMakingDAL objclsMatchMakingDAL=新的clsMatchMakingDAL（）；
线程objThread=新线程(
（）=>objectmatch=（object）objclsMatchMakingDAL.AcquireMatch（objAcqPro）；if（ThreadComplete！=nil）{MatchAcquired（match）；}
);
objThread.Start（）；
}

最简单的方法（至少对我来说）是使用委托和BeginInvoke，它将立即返回，您可以为其提供一个回调，该回调在委托完成时执行。 更多信息

在您的示例代码中，我看不到在操作完成时需要通知您，以便您可以执行以下操作：

new Action(() =>
{
    clsMatchMakingDAL objclsMatchMakingDAL = new clsMatchMakingDAL();
    objclsMatchMakingDAL.AcquireMatch(objAcqPro);
}).BeginInvoke(null, null);

---

这将在另一个由.Net为您管理的线程上执行匹配功能。如果您需要在完成时收到通知，那么

BeginInvoke

调用的第一个参数可能是另一个处理完成事件的委托。

如何处理委托？我使用线程实现了什么？Thread objThread=new Thread（（）=>objclsMatchMakingDAL.AcquireMatch（objAcqPro））；部分“（）=>objclsMatchMakingDAL.AcquireMatch（objAcqPro）”是您为线程提供委托的地方。您好，Siraj….您的意思是…….新线程（委托（）{objclsMatchMakingDAL.AcquireMatch（objAcqPro）}）@KrantiSingh这正是您提供委托的方式，也是您在这里编写的实现也是一个委托提供程序，但语法不同。我重申委托只是指向函数的安全指针。这是一个使用委托进行线程处理的示例。我想你的答案不是他要的。但他的问题也是出于误解。啊，好吧，至少它给了我一些线程练习。忘了设置事件线程设计有多麻烦了。这很好。但是我知道我们可以用3-4行代码完成这项工作。我的简单问题是我想把我的配对任务异步化。我使用线程…1。如何使用委托？2.哪一个是快速线程还是委派线程和委派是完全不同的事情！

new Action(() =>
{
    clsMatchMakingDAL objclsMatchMakingDAL = new clsMatchMakingDAL();
    objclsMatchMakingDAL.AcquireMatch(objAcqPro);
}).BeginInvoke(null, null);