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.


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 :)

Cómo descomprimir archivos .zip en .net (C#)

Después de dos años sin ser actualizado este blog por los miembros del equipo, en concreto unos cuatro o cinco años por mi parte, vuelvo a la carga con un nuevo post.

Debido a cambios en mi vida laboral, después de unos cuantos años vuelvo a retomar la programación en C#, por lo que tengo que refrescar unas cosas y aprender otras nuevas. En la parte de aprender nuevas hoy he descubierto cómo se puede descomprimir un archivo .zip con .NET.

Es muy sencillo, tan solo necesitamos la librería open source SharpZipLib, que podéis encontrar en este enlace  http://www.icsharpcode.net/OpenSource/SharpZipLib/Download.aspx.

Hay que descomprimir el archivo y copiar la .dll en algún directorio de tu proyecto. En concreto he usado la librería que se encuentra en la carpeta "net-20". Entonces agregas la referencia a esta librería (Botón derecho -> Agregar Referencia -> Examinar) y usas un sencillo método:

FastZip fZip = new FastZip();
fZip.ExtractZip(@”C:\miarchivo.zip”, @”C:\Temp”, “”);
El primer argumento es la ruta completa del archivo a descomprimir. El segundo argumento es la ruta donde queremos descomprimir el contenido del archivo. El tercer argumento, que en este caso está vacío, se puede usar para poner expresiones regulares que indiquen qué tipo de archivos queremos descomprimir; si lo dejamos en blanco se extraerán todos los archivos. Un ejemplo de expresión regular para descomprimir sólo las imágenes: “(?i)^.*(?:(?:.jpg)|(?:.png))$” .
 
 
 
Fuente: http://robertoyudice.wordpress.com/2009/05/10/como-descomprimir-archivos-zip-en-net-c/

Edito: Como bien indican en los comentarios, se me olvidó comentar que hay que añadir el "using" de la librería al principio:
using ICSharpCode.SharpZipLib.Zip;
 Gracias por vuestros comentarios.

Comparación de características entre versiones de SQLServer 2005

MSDN: http://www.microsoft.com/Sqlserver/2005/en/us/compare-features.aspx

Actualizar una base de datos de SQL Server 2000 a SQL Server 2005

Para actualizar una base de datos de SQL2000 a SQL2005 bastará con destatacharla del servidor 2000 y atacharla al servidor de 2005.
Tras esto habrá que ejecutar el comando:

DBCC UPDATEUSAGE

MSDN: http://msdn.microsoft.com/es-es/library/ms189625.aspx

Método IsDate como extensor de String

Tras leer un árticulo en la web sobre métodos extensores en Visual Studio 2008 y para probar la facilidad de uso de estos he implementado en método IsDate, extensor de String que siempre viene bien para comprobar las cadenas que son fechas válidas. El código quedaría como sigue:

using System;

///
/// Clase que implementa métodos extensores.
///

public static class Extensores
{
///
/// Determina si una cadena es o no una fecha válida.
///

/// Cadena a validar.
///
/// true si la cadena es una fecha válida, sino false.
///

public static bool IsDate(this String cadena)
{
DateTime d;
return DateTime.TryParse(cadena, out d);
}
}

Es decir basta con crear una clase estática con una función estatica IsDate con un parámetro (this String cadena). Con esta nomenclatura le estamos diciendo que el metodo extensor es para la clase String.
He usado la funcion TryParse de DateTime porque según he leido es más eficiente que usar bloques try - catch - finally.
No es muy dificil de implementar pues y el uso seria muy facil puesto que ahora nuestra clase String posee un metodo nuevo al que podremos acceder facilmente:
String.Empty.IsDate()
Esa llamada se evalua como falso ya que la cadena vacia no es una fecha válida.

Buscar este blog

Cargando...

Seguidores

Blogs amigos