Question

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

现在我决定使用Threading或Delegate

在后台/异步中放置匹配进程

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

2. Matching related record with other record in database
            clsMatchMakingDAL objclsMatchMakingDAL = new clsMatchMakingDAL();
            objclsMatchMakingDAL.AcquireMatch(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();
}

Q2。 如何使用Delegate执行此任务？

Answer 1

您不能仅使用委托进行后台处理。委托与线程或异步进程完全不同。您可以将委托理解为指向函数的指针。线程使用委托来执行某个函数，但单独的委托不是任何类型的后台执行。做你提到的 - 在后台运行该过程，但你必须知道在后台以这种方式运行操作的成本。您还需要知道它是否确实需要在后台运行，或者只需要优化。

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

它很长，但它允许完全控制你的线程。

编辑：

未经测试的代码。我能想到的最短的解决方案。

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

Answer 3

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

在您的示例代码中，我没有看到您需要得到通知，操作完成后您可以执行以下操作：

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

这会在.Net为您管理的另一个线程上执行匹配功能。如果您需要在完成时收到通知，那么BeginInvoke调用的第一个参数可能是另一个处理完成事件的委托。

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

3 个答案: