Самый простой способ сделать огонь и забыть метод в C #?

Я видел в WCF у них есть [OperationContract(IsOneWay = true)]атрибут. Но WCF кажется медленным и тяжелым только для того, чтобы создать неблокирующую функцию. В идеале было бы что-то вроде статического неблокирования пустот 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");
    }
}

NB : Каждый, кто читает это, должен подумать, действительно ли он хочет, чтобы метод закончился. (См. Ответ сверху # 2) Если метод должен завершиться, то в некоторых местах, например, в приложении ASP.NET, вам нужно будет что-то сделать, чтобы заблокировать и поддерживать поток живым. В противном случае это может привести к «запуску, но никогда не выполнению», и в этом случае, конечно, было бы проще вообще не писать код. ( Хорошее описание того, как это работает в ASP.NET )

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

(пять лет спустя...)

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

как указывает Луисперефд .

Для 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());

Чтобы добавить к ответу Уилла , если это консольное приложение, просто добавьте AutoResetEventa и 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();
    }
}

Самый простой способ - создать и запустить поток с лямбда без параметров:

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

или используя async:

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

Это прекрасно работает на веб-сайтах Azure.

Ссылка: Использование QueueBackgroundWorkItem для планирования фоновых заданий из приложения ASP.NET в .NET 4.5.2

Вызов beginInvoke и отсутствие перехвата EndInvoke не очень хороший подход. Ответ прост: причина, по которой вы должны вызывать EndInvoke, заключается в том, что результаты вызова (даже если нет возвращаемого значения) должны кэшироваться .NET до вызова EndInvoke. Например, если вызванный код генерирует исключение, то исключение кэшируется в данных вызова. Пока вы не вызовете EndInvoke, он останется в памяти. После вызова EndInvoke память может быть освобождена. В этом конкретном случае возможно, что память останется до тех пор, пока процесс не остановится, потому что данные поддерживаются внутренне кодом вызова. Я думаю, что GC может в конечном итоге собрать его, но я не знаю, как GC узнает, что вы отказались от данных, а просто потратили очень много времени на их получение. Я сомневаюсь, что это так. Следовательно, может произойти утечка памяти.

Больше можно найти на http://haacked.com/archive/2009/01/09/asynchronous-fire-and-forget-with-lambdas.aspx

Почти 10 лет спустя:

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