Como obtener el hash MD5 en C#

Según la wikipedia MD5 (abreviatura de Message-Digest Algorithm 5) es un algoritmo de reducción criptográfico de 128 bits ampliamente usado. Su uso es muy variado y lo podemos encontrar en:

• Los resúmenes MD5 se utilizan extensamente en el mundo del software para proporcionar la seguridad de que un archivo descargado de Internet no se ha alterado. Comparando una suma MD5 publicada con la suma de comprobación del archivo descargado, un usuario puede tener la confianza suficiente de que el archivo es igual que el publicado por los desarrolladores.
• En sistemas UNIX y GNU/Linux se utiliza el algoritmo MD5 para calcular el hash de las claves de los usuarios. En el disco se guarda el resultado del MD5 de la clave que se introduce al dar de alta un usuario, y cuando éste quiere entrar en el sistema se compara el hash MD5 de la clave introducida con el hash que hay guardado en el disco duro. Si coinciden, es la misma clave y el usuario será autenticado.
• El MD5 también se puede usar para comprobar que los correos electrónicos no han sido alterados usando claves públicas y privadas.

Pues bien, como no podía ser de otra manera, .NET nos ofrece la posibilidad de obtener el valor MD5 de una manera muy sencilla. Tan sólo debemos usar el siguiente código

public static string MD5Encrypt(string value)
{
  MD5CryptoServiceProvider provider = new MD5CryptoServiceProvider();
 
  byte[] data = System.Text.Encoding.ASCII.GetBytes(value);
  data = provider.ComputeHash(data);
 
  string md5 = string.Empty;
 
  for (int i = 0; i < data.Length; i++)
    md5 += data[i].ToString("x2").ToLower();
 
  return md5;
}

También hay que tener en cuenta que debemos importar el espacio de nombres System.Security.Cryptography.

using System.Security.Cryptography;

Algunos ejemplos

MD5('') = d41d8cd98f00b204e9800998ecf8427e
MD5('MD5') = 7f138a09169b250e9dcb378140907378

Happy coding!

Analizando el Null-coalescing operator u operador ?? en C#

En mi anterior artículo sobre el operador ?? y tras un comentario sobre la legibilidad del código me surgió la duda de como resolvería internamente el compilador este operador, porque si lo resuelve como el clásico if...then...else puede que alguno prefiera esta sintaxis a la del operador ??, aunque a mi personalmente me gusta más el código limpio así que cuanto menos escriba mejor.

Para hacer la prueba usaré el siguiente código

public string ObtenerValor()
{
    return null;
}

public string Test1()
{
    if (ObtenerValor() == null)
        return "Test1";
    else
        return ObtenerValor();
}

public string Test2()
{
    return (ObtenerValor() == null ? "Test2" : ObtenerValor());
}

public string Test3()
{
    return (ObtenerValor() ?? "Test3");
}

Como vemos no se trata de un código muy complejo, simplemente simulamos una llamada a un método que he llamado ObtenerValor, que devuelve un simple null. Este método puede ser la obtención de un valor en una base de datos y llevarnos muchos segundos. Tras compilar el código lo analizamos con el IL Disassembler de lo que obtenemos lo siguiente

Ahí vemos nuestros métodos ObtenerValor, Test1, Test2 y Test3 y al hacer doble click en ellos veremos el código CIL, anteriormente llamado MSIL, que ha generado el compilador.

 Código CIL de nuestro método Test1

  Código CIL de nuestro método Test2

Código CIL de nuestro Test3

Como en código CIL del método Test1 hace dos llamadas a nuestra función ObtenerValor. El código del método Test2, aun siendo más corto que el del método Test1 sigue haciendo también dos llamadas a nuestro método ObtenerValor. El código del método Test3 nos muestra tal y como esperábamos una sola  llamada al método ObtenerValor por lo que ganamos en eficiencia en el código ejecutado y en la legibilidad del código fuente (desde mi punto de vista). Así que, ¿a qué esperamos para usar el operador ?? en todas nuestras comparaciones con null?


Para el que esté interesado en como se ejecuta cada uno de los métodos puede ver que significa cada OpCode en las referencias del artículo.


Happy coding!

Mas info | Código CIL | OpCodes Fields

Depurando las consultas SQL generadas por Entity Framework

Muchas veces, sobre todo en consultas complejas Entity Framework puede no devolvernos los datos que esperábamos. Normalmente cuando esto ocurre suelo recurrir al SQL Server Profiler, pero no siempre lo tengo disponible ya que es una funcionalidad que no está presente en la versión Express del SQL Server. Pero como siempre, los chicos de Microsoft han pensado en todo y hay una forma bastante simple de obtener la consulta que ha generado el Entity Framework para poder jugar con ella y ver donde está el fallo.

using (FooEntities entities = new FooEntities())
{
 var result = (from p in entities.Bar
   where p.IdBar.Equals(1001)
   select p);

 System.Diagnostics.Trace.Write(string.Format("SQL: {0}", ((System.Data.Objects.ObjectQuery)result).ToTraceString()));    
}

Esto nos devolverá en nuestra ventana de Resultados lo siguiente

SQL: SELECT 
[Extent1].[IdBar] AS [IdBar], 
[Extent1].[BarDesc] AS [BarDesc], 
[Extent1].[Valor] AS [Valor], 
[Extent1].[FC] AS [FC], 
[Extent1].[UC] AS [UC]
FROM [dbo].[Bar] AS [Extent1]
WHERE 1001 = [Extent1].[IdBar]

Algo bastante simple que nos puede ayudar bastante en algún momento.

Happy coding!

Null-coalescing operator u operador ?? en C#

El operador ?? o null-coalescing operator se utiliza para definir un valor predeterminado para los tipos de valor que aceptan valores NULL así como los tipos de referencia. Dicho operador devuelve el operando izquierdo si es NOT NULL; en los demás casos, devuelve el operando derecho. Dicho de otra manera, devuelve el operando izquierdo si es not-null, en los demás casos devuelve el operando derecho.

De esta manera el siguiente código

if (p == null)
  return "default";
else
  return p;

Que tambíen puede ser escrito así

return (p == null ? "default" : p);

Se podría escribir de la siguiente manera

return (p ?? "default");

Como vemos, el código es mucho más limpio y legible. Ahora veamos otro pequeño ejemplo donde el operador ?? nos puede ser útil.

string p = obtenerValor();
if (p == null)
  return "default";
else
  return p;

Supongamos que la llamada al método obtenerValor() es una llamada costosa con multiples accesos a datos y complejos cálculos en memoria y cometieramos el error de por legibilidad usar el operar ?

return (obtenerValor() == null ? "default" : obtenerValor());

Vemos que en este caso hemos mejorado la legibilidad del código pero hemos empeorado considerablemente la eficiencia de nuestro código ya que en muchos casos haremos dos llamadas al método obtenerValor. En este caso el operador ?? viene a nuestro rescate quedando el código de la siguiente manera

return (obtenerValor() ?? "default");

Happy coding!

Más referencias | El operador ??