Найпростіший спосіб зробити вогонь і забути метод в 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());

як вказував luisperezphd .

Що стосується C # 4.0 та новіших версій, мені здається, що найкращу відповідь зараз дає Аде Міллер: Найпростіший спосіб зробити вогонь і забути метод в # 4,0

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

Або навіть...

Task.Factory.StartNew(FireAway);

Або ...

new Task(FireAway).Start();

Де FireAwayє

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

Таким чином, в силу назви класу та методу terseness це обробляє версію потокової нитки на шість-дев'ятнадцять символів залежно від обраного вами :)

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

Для .NET 4.5:

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

Щоб додати відповідь Вілла , якщо це консольний додаток, просто введіть AutoResetEventі, 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();
});

або за допомогою асинхронізації:

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