Llamar método por otro hilo sin peligro a caerse en .NET

IIS por defecto tiene la maña de coger tus hilos que lanzes por segundo plano y MATARLOS.

Que asesino eres IIS!

Entonces, lo que necesitamos es colocarnos un ESCUDO PROTECTOR!.

Para lograrlo entonces tenemos que implementar una clase (que por cierto no hice yo, sino un duro de stackoverflow y que lo compartió al mundo... gracias stackoverflow y Gervasio Marchand).

Ojo que hay que importar lo siguiente en la clase:

using System.Web.Hosting;

using System.Threading.Tasks;

Esta es la clase:

 public class BackgroundWorker
    {
        /// <summary>
        /// Runs a background task that is registered with the hosting environment
        /// so it is guaranteed to finish executing.
        /// </summary>
        /// <param name="action">The lambda expression to invoke.</param>
        public static void Run(Action action)
        {
            new IISBackgroundTask().DoWork(action);
        }

        /// <summary>
        /// Generic object for completing tasks in a background thread
        /// when the request doesn't need to wait for the results 
        /// in the response.
        /// </summary>
        class IISBackgroundTask : IRegisteredObject
        {
            /// <summary>
            /// Constructs the object and registers itself with the hosting environment.
            /// </summary>
            public IISBackgroundTask()
            {
                HostingEnvironment.RegisterObject(this);
            }

            /// <summary>
            /// Called by IIS, once with <paramref name="immediate"/> set to false
            /// and then again with <paramref name="immediate"/> set to true.
            /// </summary>
            void IRegisteredObject.Stop(bool immediate)
            {
                if (_task.IsCompleted || _task.IsCanceled || _task.IsFaulted || immediate)
                {
                    // Task has completed or was asked to stop immediately, 
                    // so tell the hosting environment that all work is done.
                    HostingEnvironment.UnregisterObject(this);
                }
            }

            /// <summary>
            /// Invokes the <paramref name="action"/> as a Task.
            /// Any exceptions are logged
            /// </summary>
            /// <param name="action">The lambda expression to invoke.</param>
            public void DoWork(Action action)
            {
                try
                {
                    _task = Task.Factory.StartNew(action);
                }

                catch (Exception ex)
                {
                    //Logger.Log(ex);
                }
            }

            private Task _task;

        }
    }

Una vez tengamos la clase metida en nuestro cs o donde vayas a lanzar el método sencillamente puedes llamarlo así:

BackgroundWorker.Run(() =>
                                      MiMetodoAsincronoConEscudo(parametro1, parametro2, parametro3)
                                );// run this in a background thread

Y todos seamos felices!!! Ahora nunca nuestros hilos de segundo plano los matará IIS... GAnamos!!!!!

Para más información puedes mirar los siguientes links:

El peligro de implementar tareas en segundo plano.

Una confirmación de que IIS mata los hilos

El link que nos salva a todos.

Y de nuevo una explicación detallada de como podría funcionar el ESCUDO

Aquí hay un framework que ayuda a esto también.

Sean felices! :) Y siéntanse libres de opinar ;)