Trabajando con hilos en C# - Working with threads in C#

Cuando alguien está desarrollando aplicaciones de escritorio, las cuales cada vez son menores ya que la mayoría de aplicaciones que se desarrollan hoy en día son Web, a menudo se encuentra con que un algoritmo tarda un poco más de la cuenta, con el resultado de que bloquea el proceso y por una parte no te deja hacer nada más con la aplicación, mientras que por otro lado parece que se haya quedado colgada, cosa que puede dar problemas porque el usuario cierre la aplicación, mate el proceso o cualquier otra acción similar. Por ello siempre se recomienda el uso de hilos o threads.

Como hacía bastante tiempo que no desarrollaba aplicaciones de escritorio el tema de los threads no lo tenía muy fresco, por lo que tuve que buscar algo de información para pequeños detalles que no recordaba. Los resultados los encontré en diferentes sitios, por eso me animé a reunirlos todos en este post, por si le pudiera servir a alguien de ayuda en un futuro.

Crear y lanzar un nuevo thread es fácil:

public class Simple
{
   public static int Main()
   {
      Console.WriteLine("Thread Start/Stop/Join Sample");
      
      // Create the thread object, passing in the Alpha.Beta method
      // via a ThreadStart delegate. This does not start the thread.
      Thread oThread = new Thread(new ThreadStart(this.Beta));

      // Start the thread
      oThread.Start();

      // Spin for a while waiting for the started thread to become
      // alive:
      while (!oThread.IsAlive);
      
      // Put the Main thread to sleep for 1 millisecond to allow oThread
      // to do some work:
      Thread.Sleep(1);
      
      // Request that oThread be stopped
      oThread.Abort();
      
      // Wait until oThread finishes. Join also has overloads
      // that take a millisecond interval or a TimeSpan object.
      oThread.Join();
      
      Console.WriteLine();
      Console.WriteLine("Alpha.Beta has finished");
      
      try 
      {
         Console.WriteLine("Try to restart the Alpha.Beta thread");
         oThread.Start();
      }
      catch (ThreadStateException) 
      {
         Console.Write("ThreadStateException trying 
         to restart Alpha.Beta. ");
         Console.WriteLine("Expected since aborted threads 
         cannot be restarted.");
      }
      return 0;
   }
}

En el código anterior tenéis, además, formas de pausar o detener un hilo.
Al crear el hilo hemos puesto this.Beta porque el método al que llamamos está en nuestra clase. Si el método al que queremos llamar se encontrara en otra clase deberíamos poner su nombre primero:

      Thread oThread = new Thread(new ThreadStart(Classname.Beta));

Bueno, hasta aquí todo sencillo. Ahora toca saber cómo pasarle parámetros al método al que llamamos. Olvidaos de ParameterizedThreadStart, con esta forma podréis pasarle múltiples parámetros:

string filename = ...
Thread thread = new Thread(() => download(filename)); 

thread.Start(); 

Y de momento es todo por hoy. En un próximo artículo explicaré cómo poder acceder a esos objetos que quedan bloqueados por el hilo principal y nos traen de cabeza.

Cómo obtener las variables de entorno de Windows con C#

Otro caso con el que me he enfrentado recientemente, cómo crear o copiar archivos a una ruta física con tu servicio web pero haciéndolo portable para cualquier servidor con IIS. Pues la solución fue más sencilla de lo que pensaba. Gracias a un compañero que me sugirió utilizar las variables de entorno, conseguí acceder fácilmente a mi carpeta del IIS creando una variable de entorno y accediendo a ella con C#.


Las variables de entorno son aquellas que nos ofrecen un "atajo" para acceder a algunos directorios del sistema, como Archivos de Programa, simplemente ejecutando en la herramienta de Ejecutar o en la barra de direcciones en una ventana el siguiente código:

%ProgramFiles%

Pues bien, yo me creé la variable %iisdir% para que me abriera /Inetpub/wwwroot/ y así instalar ahí lo que necesitaba.

Para acceder a las variables de entorno desde C# hay que hacer lo siguiente:

Primero añadimos el siguiente using:
using System.Collections;

Luego empezamos a obtener los valores que necesitamos:

//Ruta hasta la carpeta System32 de Windows
Console.WriteLine(Environment.SystemDirectory);

//Nombre de la máquina
Console.WriteLine(Environment.MachineName);

//Ruta del directorio desde donde se está trabajando (Esto ya lo utilizamos en un anterior post del blog)
Console.WriteLine(Environment.CurrentDirectory);

//Sistema operativo y versión
Console.WriteLine(Environment.OSVersion.ToString());

//Todas las variables de entorno y sus valores respectivos
IDictionary variablesEntorno = Environment.GetEnvironmentVariables();
foreach (DictionaryEntry de in variablesEntorno)
{
Console.WriteLine(de.Key+": "+de.Value);
}

//Y para obtener una en concreto de la cual conoces la clave, el ejemplo que yo utilicé, %issdir%:

Console.WriteLine(Environment.GetEnvironomentVariable("issdir"));

Con esto solucioné mi problema y pude acceder a ese directorio fácilmente, eso sí, después de reiniciar, porque hasta que no lo hice la aplicación no reconocía mi nueva variable de entorno.

Fuente: Blog de Reisbel

Obtener el directorio de ejecución de tu aplicación con C# (equivalencia a App.Path)

Hace años ya me enfrenté a este problema y en su día lo solucioné, pero hoy me he vuelto a enfrentar a él y no recordaba cómo era. Lo que sí recordaba era que había varias formas, pero sólo una de ellas era la idónea para mí, para lo que necesitaba hacer en ese momento. Pues bien, ahora me encuentro en  una situación similar a la de entonces y lo que necesito es obtener la ruta de mi aplicación, pero en un formato adecuado para crear/modificar/eliminar archivos allí, es decir, para usar la librería System.IO.File.


Una forma para conocer la ruta es la que más se encuentra si "googleas" un poco:

System.Reflection.Assembly.GetExecutingAssembly(). GetName().CodeBase

Pero te devuelve la ruta en este formato: 

file://C:/Users/...

Con lo cual no es útil para lo que yo lo necesito. Entonces si lo que quiero es obtener la ruta en este formato:

C:\Users\Admin\...

Tengo que hacerlo de esta forma:

Environment.CurrentDirectory

Y con esto ya tengo solucionado el problema. Es similar al App.Path de Visual Basic, fácil de recordar y útil para usar la ruta.




Espero que la próxima vez que tenga que buscar esto mire antes en mi blog :)