在C＃中最简单的方法来解决问题？

我在WCF中看到它们具有[OperationContract(IsOneWay = true)]属性。但是WCF似乎只是为了创建一个非阻塞函数而缓慢而繁重。理想情况下，会出现诸如static void nonblocking之类的东西MethodFoo(){}，但我认为这不存在。

在C＃中创建非阻塞方法调用的最快方法是什么？

例如

class Foo
{
    static void Main()
    {
        FireAway(); //No callback, just go away
        Console.WriteLine("Happens immediately");
    }

    static void FireAway()
    {
        System.Threading.Thread.Sleep(5000);
        Console.WriteLine("5 seconds later");
    }
}

注意：阅读此书的每个人都应该考虑他们是否真的希望该方法完成。（请参阅＃2最佳答案）如果该方法必须完成，则在某些地方（例如ASP.NET应用程序），您将需要执行某些操作来阻止线程并使线程保持活动状态。否则，这可能会导致“忘却却从未真正执行”，在这种情况下，完全不编写任何代码当然会更简单。（很好地描述了它如何在ASP.NET中工作）

ThreadPool.QueueUserWorkItem(o => FireAway());

（五年后...）

Task.Run(() => FireAway());

正如luisperezphd所指出的。

对于C＃4.0和更高版本，让我惊讶的是，Ade Miller现在在这里给出了最佳答案：在C＃4.0中执行射击和忘记方法的最简单方法

Task.Factory.StartNew(() => FireAway());

甚至...

Task.Factory.StartNew(FireAway);

要么...

new Task(FireAway).Start();

哪里FireAway是

public static void FireAway()
{
    // Blah...
}

因此，凭借类和方法名的简洁性，这取决于选择的字符集，使线程池版本比六个字符多十九个字符：)

ThreadPool.QueueUserWorkItem(o => FireAway());

对于.NET 4.5：

Task.Run(() => FireAway());

要添加到Will的答案中（如果这是一个控制台应用程序），只需在工作线程完成之前抛出an AutoResetEvent和a WaitHandle以防止其退出：

Using System;
Using System.Threading;

class Foo
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        ThreadPoolQueueUserWorkItem(new WaitCallback(FireAway), autoEvent);
        autoEvent.WaitOne(); // Will wait for thread to complete
    }

    static void FireAway(object stateInfo)
    {
        System.Threading.Thread.Sleep(5000);
        Console.WriteLine("5 seconds later");
        ((AutoResetEvent)stateInfo).Set();
    }
}

一种简单的方法是使用无参数lambda创建和启动线程：

(new Thread(() => { 
    FireAway(); 
    MessageBox.Show("FireAway Finished!"); 
}) { 
    Name = "Long Running Work Thread (FireAway Call)",
    Priority = ThreadPriority.BelowNormal 
}).Start();

通过在ThreadPool.QueueUserWorkItem上使用此方法，可以命名新线程以使其更易于调试。另外，不要忘记在例程中使用大量的错误处理，因为调试器之外的任何未处理的异常都会突然使您的应用程序崩溃：

在使用Asp.Net和.Net 4.5.2时，推荐的方法是使用QueueBackgroundWorkItem。这是一个帮助器类：

public static class BackgroundTaskRunner
{     
    public static void FireAndForgetTask(Action action)
    {
        HostingEnvironment.QueueBackgroundWorkItem(cancellationToken => // .Net 4.5.2 required
        {
            try
            {
                action();
            }
            catch (Exception e)
            {
                // TODO: handle exception
            }
        });
    }

    /// <summary>
    /// Using async
    /// </summary>
    public static void FireAndForgetTask(Func<Task> action)
    {
        HostingEnvironment.QueueBackgroundWorkItem(async cancellationToken => // .Net 4.5.2 required
        {
            try
            {
                await action();
            }
            catch (Exception e)
            {
                // TODO: handle exception
            }
        });
    }
}

用法示例：

BackgroundTaskRunner.FireAndForgetTask(() =>
{
    FireAway();
});

或使用异步：

BackgroundTaskRunner.FireAndForgetTask(async () =>
{
    await FireAway();
});

这在Azure网站上效果很好。

参考：使用QueueBackgroundWorkItem从.NET 4.5.2中的ASP.NET应用程序调度后台作业

调用beginInvoke而不捕获EndInvoke并不是一个好方法。答案很简单：之所以应调用EndInvoke，是因为调用的结果（即使没有返回值）也必须由.NET缓存，直到调用EndInvoke。例如，如果被调用的代码引发异常，则该异常将被缓存在调用数据中。在调用EndInvoke之前，它会保留在内存中。调用EndInvoke后，可以释放内存。对于这种特殊情况，由于数据是由调用代码在内部维护的，因此可能会保留内存，直到进程关闭。我想GC最终可能会收集它，但我不知道GC如何知道您已经放弃了数据，而花了很长时间才检索到它。我怀疑。因此，可能会发生内存泄漏。

可以在http://haacked.com/archive/2009/01/09/asynchronous-fire-and-forget-with-lambdas.aspx上找到更多信息

近十年后：

Task.Run(FireAway);

我将在FireAway中添加异常处理和日志记录

最简单的.NET 2.0和更高版本的方法是使用异步编程模型（即，委托上的BeginInvoke）：

static void Main(string[] args)
{
      new MethodInvoker(FireAway).BeginInvoke(null, null);

      Console.WriteLine("Main: " + Thread.CurrentThread.ManagedThreadId);

      Thread.Sleep(5000);
}

private static void FireAway()
{
    Thread.Sleep(2000);

    Console.WriteLine("FireAway: " + Thread.CurrentThread.ManagedThreadId );  
}