Programando a medianoche

Muchas veces tenemos que firmar un PDF utilizando un certificado X.509, y el iTextSharp (una excelente librería) nos puede ayudar a realizar esta tarea. Para esto les dejo un método que utilizo para hacer esto, que seguramente les va a ser de utilidad.

Para poder utilizar este código deben bajarse la librería iTextSharp (http://sourceforge.net/projects/itextsharp), y referenciar esta DLL y “System.Security” desde su proyecto.

A continuación les dejo el código:

using System;
using System.Collections;
using System.IO;
using System.Security.Cryptography;
using System.Security.Cryptography.Pkcs;
using iTextSharp.text;
using iTextSharp.text.pdf;
using Org.BouncyCastle.X509;
using SysX509 = System.Security.Cryptography.X509Certificates;

/// <summary>
/// Helper para el firmado de PDFs con la librería iTextSharp
/// </summary>
public static class PDF
{
    /// <summary>
    /// Firma un documento
    /// </summary>
    /// <param name="Source">Documento origen</param>
    /// <param name="Target">Documento destino</param>
    /// <param name="Certificate">Certificado a utilizar</param>
    /// <param name="Reason">Razón de la firma</param>
    /// <param name="Location">Ubicación</param>
    /// <param name="AddVisibleSign">Establece si hay que agregar la firma visible al documento</param>
    public static void SignHashed(string Source, string Target, SysX509.X509Certificate2 Certificate, string Reason, string Location, bool AddVisibleSign)
    {
        X509CertificateParser objCP = new X509CertificateParser();
        X509Certificate[] objChain = new X509Certificate[] { objCP.ReadCertificate(Certificate.RawData) };

        PdfReader objReader = new PdfReader(Source);
        PdfStamper objStamper = PdfStamper.CreateSignature(objReader, new FileStream(Target, FileMode.Create), '\0');
        PdfSignatureAppearance objSA = objStamper.SignatureAppearance;

        if (AddVisibleSign)
            objSA.SetVisibleSignature(new Rectangle(100, 100, 300, 200), 1, null);

        objSA.SignDate = DateTime.Now;
        objSA.SetCrypto(null, objChain, null, null);
        objSA.Reason = Reason;
        objSA.Location = Location;
        objSA.Acro6Layers = true;
        objSA.Render = PdfSignatureAppearance.SignatureRender.NameAndDescription;
        PdfSignature objSignature = new PdfSignature(PdfName.ADOBE_PPKMS, PdfName.ADBE_PKCS7_SHA1);
        objSignature.Date = new PdfDate(objSA.SignDate);
        objSignature.Name = PdfPKCS7.GetSubjectFields(objChain[0]).GetField("CN");
        if (objSA.Reason != null)
            objSignature.Reason = objSA.Reason;
        if (objSA.Location != null)
            objSignature.Location = objSA.Location;
        objSA.CryptoDictionary = objSignature;
        int intCSize = 4000;
        Hashtable objTable = new Hashtable();
        objTable[PdfName.CONTENTS] = intCSize * 2 + 2;
        objSA.PreClose(objTable);

        HashAlgorithm objSHA1 = new SHA1CryptoServiceProvider();

        Stream objStream = objSA.RangeStream;
        int intRead = 0;
        byte[] bytBuffer = new byte[8192];
        while ((intRead = objStream.Read(bytBuffer, 0, 8192)) > 0)
            objSHA1.TransformBlock(bytBuffer, 0, intRead, bytBuffer, 0);
        objSHA1.TransformFinalBlock(bytBuffer, 0, 0);

        byte[] bytPK = SignMsg(objSHA1.Hash, Certificate, false);
        byte[] bytOut = new byte[intCSize];

        PdfDictionary objDict = new PdfDictionary();

        Array.Copy(bytPK, 0, bytOut, 0, bytPK.Length);

        objDict.Put(PdfName.CONTENTS, new PdfString(bytOut).SetHexWriting(true));
        objSA.Close(objDict);
    }

    /// <summary>
    /// Crea la firma CMS/PKCS #7
    /// </summary>
    private static byte[] SignMsg(byte[] Message, SysX509.X509Certificate2 SignerCertificate, bool Detached)
    {
        //Creamos el contenedor
        ContentInfo contentInfo = new ContentInfo(Message);

        //Instanciamos el objeto SignedCms con el contenedor
        SignedCms objSignedCms = new SignedCms(contentInfo, Detached);

        //Creamos el "firmante"
        CmsSigner objCmsSigner = new CmsSigner(SignerCertificate);

        // Include the following line if the top certificate in the
        // smartcard is not in the trusted list.
        objCmsSigner.IncludeOption = SysX509.X509IncludeOption.EndCertOnly;

        //  Sign the CMS/PKCS #7 message. The second argument is
        //  needed to ask for the pin.
        objSignedCms.ComputeSignature(objCmsSigner, false);

        //Encodeamos el mensaje CMS/PKCS #7
        return objSignedCms.Encode();
    }
}

Aquí les dejo un proyecto de ejemplo donde se pide un PDF a firmar, luego donde escribir PDF firmado y toma el primer certificado personal que posea clave privada y lo utiliza para firmar el PDF.

Espero que este código les sea de utilidad.
Suerte!

Artículos relacionados

• Conceptos de Certificado Digital y Firma Digital
• Crear certificados de prueba para servidor y cliente
• Como calcular el Hash de un vector de bytes o un string
• Utilizar certificados digitales desde .NET

Visual Studio

Visual Studio 2010 Quick Reference Guidance
Guía de referencia rápida de Visual Studio 2010. También en español.

Visual Studio 2010 Keybinding Cards
Configuración de las teclas de Visual Studio 2010 para Visual Basic, Visual C#, Visual C++ y Visual F#.

Visual C# 2008 Keybinding Reference Poster
Configuración de las teclas de Visual Studio 2008 y Visual Studio Express para Visual C#.

Visual Basic 2008 Keybinding Reference Poster
Configuración de las teclas de Visual Studio 2008 y Visual Studio Express para Visual Basic.

Visual C++ 2008 Keybinding Reference Poster
Configuración de las teclas de Visual Studio 2008 y Visual Studio Express para Visual C++.

Visual C# 2005 Keyboard Shortcut Reference Poster
Configuración de las teclas de Visual Studio 2005 para Visual C#.

Visual Basic 2005 Keyboard Shortcut Reference Poster
Configuración de las teclas de Visual Studio 2005 para Visual Basic.

Visual C++ 2005 Keyboard Shortcut Reference Poster
Configuración de las teclas de Visual Studio 2005 para Visual C++.

.NET Framework

.NET Framework 4.0 Namespaces and Types Poster
Poster con las más importantes clases y Namespaces de .NET Framework 4.0.

.NET Framework 3.5 Common Namespaces and Types Poster
Poster con las clases y Namespaces más utilizados de .NET Framework 3.5.

.NET Framework 3.0 Namespaces and Types Poster
Poster con las clases y Namespaces más utilizados de .NET Framework 3.0.

.NET Framework 2.0 Commonly used Types and Namespaces
Poster con las clases y Namespaces más utilizados de .NET Framework 2.0.

Silverlight

Microsoft Silverlight 2 Developer Reference Poster
Poster de referencia de Silverlight 2.0

Microsoft Silverlight 1.1 Developer Reference Poster
Poster de referencia de Silverlight 1.1

BizTalk Server

BizTalk Server 2009 Runtime Architecture Poster
Detalle del flujo típico de mensajes y datos y referencias de BizTalk 2009.

BizTalk Server 2009 Capabilities Poster
Lista de las capacidades de BizTalk Server 2009.

BizTalk Server 2009 Scale-out Configurations Poster
Este póster describe las configuraciones típicas de las configuraciones y opciones de BizTalk Server 2009.

BizTalk Server 2009 Database Infrastructure Poster
Descripción de la base de datos, componentes asociados, trabajos, servicios, UI y eventos.

BizTalk Server 2009 BAM Poster
Este poster permite comprender los conceptos, procesos y gestión del BAM.

BizTalk ESB Toolkit Architecture Poster
Arquitectura del ESB Toolkit.

BizTalk Adapter Pack 2.0/WCF LOB Adapter SDK Poster
Este póster describe la funcionalidad, componentes, arquitectura y escenarios de uso/hosting de BizTalk Adapter Pack 2.0 y el WCF LOB Adapter SDK.

BizTalk Server 2006 R2 Runtime Architecture Poster
Detalle de los módulos y componentes de la arquitectura de BizTalk Server 2006 R2, junto con su flujo típico de mensajes y datos.

BizTalk Server 2006 R2 Scale-Out Configurations
Configuraciones y opciones de BizTalk Server 2006 R2.

BizTalk Server 2006 R2 Capabilities Poster
Lista de las capacidades de BizTalk Server 2006 R2.

BizTalk Server 2006 R2 Database Infrastructure Poster
Descripción de la base de datos, componentes asociados, trabajos, servicios, UI y eventos.

BAM Poster for Microsoft BizTalk Server 2006 R2
Este poster permite comprender los conceptos, procesos y gestión del BAM.

Exchange Server

Exchange Component Architecture Poster
Arquitectura y características de Microsoft Exchange Server 2007.

Windows Server

Windows Server 2008 R2 Feature Components Poster
Este póster proporciona una referencia visual de las tecnologías clave en Windows Server 2008 R2.

Windows Server 2008 R2: Hyper-V Component Architecture
Este póster proporciona una referencia visual para las tecnologías clave de comprensión en Windows Server 2008 R2 Hyper-V.

Windows Server 2008 Component Posters
Póster de componentes de Windows Server 2008, originalmente impreso en la edición de julio de 2007 de TechNet Magazine.

Windows Server 2008 Component Posters
Póster con los componentes de Windows Server 2008, originalmente impreso en el TechNet Magazine de Julio de 2007.

TechNet Magazine Active Directory Component Jigsaw Poster
Póster de Active Directory Component, originalmente impresor en el TechNet Magazine de marzo-abril de 2006.

Office

2007 Microsoft Office System Logical Architecture
Arquitectura de Office 2007.

Developer Map for the 2007 Microsoft® Office system
Mapa de desarrollo de Microsoft Office 2007,

Microsoft® Office InfoPath® 2007 Managed Object Model
Mapa con el modelo de objetos de Microsoft InfoPath 2007.

Developer Map for SharePoint® Products and Technologies
Mapa de desarrollador para SharePoint productos y tecnologías

P&P

PnP Overview Poster
Póster de introducción de patrones y prácticas

Smart Client Poster
Póster de patrones y prácticas de Smart Client

Microsoft CRM

Microsoft CRM 3.0 Logical Database Diagrams
Diagrama de la base de datos de Microsoft CRM 3.0.

Microsoft CRM 1.2 Logical Database Diagram
Diagrama de la base de datos de Microsoft CRM 1.2.

Aquellos que trabajamos en Visual Basic y C# extrañamos algunas veces, al utilizar este segundo lenguaje, la posibilidad de tener parámetros opcionales que si nos permite VB. La buena noticia es que con la llegada de C# 4.0 ahora es posible hacerlo desde este lenguaje.
Veamos un ejemplo, supongamos que tenemos este método:

public void Prueba(string param1, int param2, bool param3) { }

Si queremos que se lo pueda llamar utilizando parámetros opcionales simplemente tenemos que definir los valores por defecto de cada uno, por ejemplo, de esta manera:

public void Prueba(string param1 = null, int param2 = 0, bool param3 = false) { }

Luego, al llamarlo se pueden obviar los parámetros que no queremos proporcionar, por ejemplo, en el siguiente ejemplo sólo le pasamos el valor del parámetro “param1”:

Prueba("cadena de ejemplo");

Pero esto no es todo, si quisiéramos pasar el valor del segundo parámetro sin especificar un valor para el primero lo podríamos hacer así:

Prueba(param2 : 200);

Y si quisiéramos pasar el segundo y tercero podríamos hacer esto:

Prueba(param2 : 200, param3 : true);

Como pueden ver su uso es muy similar a la forma de definir los valores de las propiedades de los atributos de las clases o métodos, aunque en ese caso se usa el igual (=) en lugar del signo “dos puntos” (:).
Espero que este pequeño “tip” les haya sido útil.
Suerte!

Este poster posee las clases del .NET Framework 4.0, diferenciando las que son de comunicación, workflow, cliente, identity, web, datos y del core. También diferencia cuales están en el client profile y cuales en Silverlight.
El poster en formato PNG lo pueden descargar pulsando sobre la imagen, y en PDF pulsando en este enlace.

En el día de ayer Microsoft® liberó la especificación del lenguaje C# 4.0 (C# Language Specification 4.0) y la de Visual Basic 10.0 (Visual Basic Language Specification 10.0). En estos documentos tendremos la definición de las expresiones, clases base, estructuras, interfaces, estructura del léxico, Namespaces, delegados, etc., de la nueva versión de estos lenguajes.

Los documentos se pueden descargar en formato HTML o DOC de los siguiente enlaces:

• C# Language Specification 4.0
• Visual Basic Language Specification 10.0

Suerte!

Hay una característica en el método string.Format que es poco conocida, la cual nos permite establecer el tamaño mínimo de caracteres que ocupará el valor de los parámetros.
Pero mejor que explicarlo con palabras es mostrar un ejemplo: supongamos que queremos concatenar un número a un texto, pero éste debe estar alineado a la derecha, seguramente contaremos la cantidad de caracteres que ocupa, se lo restaremos al tamaño del espacio asignado para ese valor y le agregamos esa cantidad de espacios a su izquierda.
Otra forma, mucho más práctica, es utilizar el string.Format y pasarle el tamaño, por ejemplo:

string.Format("Precio:{0,10}", 1234);

Este código nos va a devolver la siguiente cadena:

Precio:      1234

Nótese que antes del número se agregaron 6 espacios, para así completar los 10 caracteres mínimos que especificamos en {0,10}.
Si en cambio en lugar de establecer un valor positivo le pasamos un valor negativo el texto se alineará a la izquierda, pero se seguirá llenando con espacios a su derecha hasta completar la cantidad de caracteres establecidos. Si este valor es menor al tamaño del parámetro simplemente se ignorará.
A continuación les muestro un ejemplo, el código siguiente define y guarda cadenas en tres variables:

string strTexto1 = string.Format("Texto 1: {0,12}!", "Scientia");
string strTexto2 = string.Format("Texto 2: {0,-12}!", "Scientia");
string strTexto3 = string.Format("Texto 3: {0,5}!", "Scientia");

Éstas variables, strTexto1, strTexto2 y strTexto3, valdrán los siguientes valores:

Texto 1:     Scientia!
Texto 2: Scientia    !
Texto 3: Scientia!

Espero que este tip les sea de utilidad.
Suerte!

Microsoft ha publicado un paquete gratuito con 101 ejemplos y documentación de C# 4.0 para usarse con Visual Studio 2010 RTM (el cual fue liberado antes de ayer). Los ejemplos incluyen proyectos que muestran el uso de Dynamics con Office, IronPython, Threading, Partial Types, seguridad, sobrecarga de operadores, código no manejado (Unsafe), delegados anónimos (Anonymous Delegates), métodos condicionales, interfaces explícitas, LINQ to Objects, LINQ to XML, QueryVisualizer, Reflection, DynamicQuery, XQuery y muchos más.

También publicaron otro paquete con otros 101 ejemplos y documentación pero en este caso de Visual Basic 10.0. Los ejemplos de este paquete incluyen ClickOnce, TCPRemoting, ejemplo para Tablet PC, WCF, WinForms, seguridad, LINQ, XQuery y muchos otros más.

Los enlaces para más información y descarga de los paquetes se los dejo a continuación:

• Visual C# 2010 Samples
• Descarga de los ejemplos y documentación de C# 4.0
• Visual Basic 2010 Samples
• Descarga de los ejemplos y documentación de Visual Basic 10.0

Espero que esta información les sea de utilidad.
Suerte!

En Scientia® Soluciones Informáticas desarrollamos una aplicación sencilla pero muy útil utilizando los servicios de traducción que ofrece Bing^TM: creamos un traductor de recursos de .NET. La idea es muy sencilla, abre un archivo de recursos seleccionado por el usuario (un archivo .resx) y crea los archivos de recursos en los idiomas requeridos. Por ejemplo, podemos tomar un recurso con textos en español y crear los archivos con los textos en inglés, portugués, japonés y tailandés.

Cabe mencionar que este software lo creamos sin fines de lucro, o sea, para utilizarlo y distribuirlo gratuitamente.

A continuación les dejo una captura de la pantalla:

A modo de prueba traducimos los textos de la misma aplicación, y ahora soporta más de 20 culturas, lo cual se puede visualizar en el menú de selección de idioma:

Para quien desee utilizarlo o probarlo lo invito a descargarlo de la página de nuestra empresa: http://www.scientia.com.ar/descargas.aspx

Espero que esta herramienta les sea de utilidad.

Revisando los newsgroups de Microsoft encontré una persona que preguntaba cómo hacer para “ejecutar un string”, o sea, escribir una fórmula matemática en una cadena de texto y luego obtener el resultado de la misma. En ese momento recordé que hace unos años tuve que hacer esto mismo utilizando .NET Framework 1.1, fue entonces cuando me decidí a buscar aquel código y escribir este artículo.
Para hacer esto necesitamos crear una clase, compilarla en memoria, luego instanciarla y por último ejecutar el método que devuelva el resultado en cuestión.

La clase la debemos crear en un string incluyendo los using necesarios, el namespace a utilizar y el método a ejecutar, el cual va a resolver la fórmula. Al compilador debemos pasarle varios parámetros a través de la clase CompilerParameters, donde vamos a indicarle que debe generar el ensamblado en memoria, que no debe generar un ejecutable y que no incluya (o si, depende de la necesidad) la información para debug.

CompilerParameters Parametros = new CompilerParameters()
{
    GenerateInMemory = true,
    GenerateExecutable = false,
    IncludeDebugInformation = false
};

Luego debemos crear el compilador con el método estático CreateProvider de la clase CodeDomProvider, al cual debemos pasarle el lenguaje que queremos utilizar, en nuestro ejemplo “CSharp”. Hay que tener en cuenta que el nombre del lenguaje es “case sensitive”, por lo que hay que tener cuidado de escribirlo con las mayúsculas y minúsculas correspondientes.

CodeDomProvider objCompiler = CodeDomProvider.CreateProvider("CSharp");

Una vez creado el compilador debemos pasarle la clase y los parámetros creados anteriormente para que genere el ensamblado necesario en memoria:

CompilerResults objResultados = objCompiler.CompileAssemblyFromSource(objParametros, strClase);

Por último debemos crear una instancia de la clase y llamar al método que creamos y que va a calcular la fórmula:

object objClase = objResultados.CompiledAssembly.CreateInstance("MiNamespace.MiClase", false, BindingFlags.CreateInstance, null, null, null, null);
return objClase.GetType().InvokeMember("MiMetodo", BindingFlags.InvokeMethod, null, objClase, null);

El método CreateInstance posee varios parámetros para globalización, parámetros para pasarle al método, etc., pero para nuestro ejemplo, al no necesitarlos, los vamos a establecer en null.

Una vez explicado lo que necesitamos hacer, les paso el código del método a ejecutar para que resuelva fórmulas o cualquier línea de C# (por ejemplo, búsquedas de cadenas de texto, etc.) y devuelva el valor:

namespace WebApplication1
{
    using System.CodeDom.Compiler;
    using System.Reflection;

    public static class Formula
    {
        /// <summary>
        /// Resuelve el valor de una fórmula
        /// </summary>
        /// <param name="Formula">Fórmula a resolver</param>
        /// <returns>Resultado</returns>
        /// <example>double Resultado = Formula.Resolver("2 * 8 + 3");</example>
        public static object Resolver(string Formula)
        {
            //Parámetros del compilador
            CompilerParameters objParametros = new CompilerParameters()
            {
                GenerateInMemory = true,
                GenerateExecutable = false,
                IncludeDebugInformation = false
            };

            //Clase
            string strClase =
                "using System;" +
                "namespace Scientia {" +
                "public class Formula {" +
                    "public object Ejecutar() {" +
                        "return " + Formula +
                ";}}}";

            //Compilo todo y ejecuto el método
            CodeDomProvider objCompiler = CodeDomProvider.CreateProvider("CSharp");

            //En .NET 1.1 usaba esta linea:
            //ICodeCompiler ICC = (new CSharpCodeProvider()).CreateCompiler();

            CompilerResults objResultados = objCompiler.CompileAssemblyFromSource(objParametros, strClase);
            object objClase = objResultados.CompiledAssembly.CreateInstance("Scientia.Formula",
                false, BindingFlags.CreateInstance, null, null, null, null);
            return objClase.GetType().InvokeMember("Ejecutar", BindingFlags.InvokeMethod, null, objClase, null);
        }
    }
}

Como ejemplo podemos crear una página donde el usuario pueda ingresar una fórmula y al pulsar en un botón se muestre el resultado en la misma. La página debería quedar así:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="WebApplication1._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Ejemplo de Scientia® Soluciones Informáticas</title>
</head>
<body>
    <form id="form1" runat="server">
    <asp:Panel DefaultButton="btnCalcular" runat="server">
        <asp:TextBox ID="txtFormula" runat="server" />
        <asp:Button ID="btnCalcular" runat="server" Text="=" OnClick="btnCalcular_Click" />
        <asp:Label ID="lblResultado" runat="server" />
    </asp:Panel>
    </form>
</body>
</html>

Y en el code behind de ésta debería tener lo siguiente:

using System;

namespace WebApplication1
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
        }

        protected void btnCalcular_Click(object sender, EventArgs e)
        {
            lblResultado.Text = Formula.Resolver(txtFormula.Text).ToString();
        }
    }
}

Espero que este artículo les sea de utilidad y, como siempre, les dejo el proyecto de ejemplo para Visual Studio® 2008.

Tal como fue expresado por Gordon Moore, cofundador de Intel, en 1965 en la conocida “Ley de Moore”, la cantidad de transistores que poseen las computadoras se duplicaría aproximadamente cada 18 meses (un año y medio), y esta tendencia continuaría durante las siguientes dos décadas. Unos diez años después corrigió su ley diciendo que la cantidad de transistores se duplicará cada 24 meses (2 años). Esta ley fue cumplida durante mucho tiempo (mucho más del que él pensaba al momento de formularla) generando una carrera en la generación de procesadores cada vez más potentes, hasta hace unos pocos años. Al llegar al límite (o muy cerca) del tamaño que se le puede dar a éstos transistores (por lo menos utilizando las técnicas actuales) se comenzaron a generar nuevos procesadores con varios núcleos, o sea, varios procesadores en una misma “pastilla”. Esto dio origen a los primeros procesadores Multi-Core, los cuales hoy en día son muy comunes en los equipos de escritorio y notebooks.

Hasta aquí todo parece ser bueno, pero para los desarrolladores no lo es tanto, ya que las aplicaciones que venimos desarrollando son, por lo general, creadas para ejecutarse en un único hilo (thread), y para poder utilizar el poder de estos nuevos procesadores hay que cambiar la forma de programar. Supongamos que tenemos una aplicación que calcula los números primos existentes entre el 1 y 1.000.000.000, seguramente esta tarea llevaría bastante tiempo, y aunque lo ejecutemos en una máquina con ocho núcleos (o, por ejemplo, cuatros procesadores con doble núcleo) veremos que sólo uno de los procesadores trabajará al 100%, mientras que el resto no realizará ninguna tarea. Para mejorar la performance de esta aplicación en esta máquina lo optimo sería distribuir la tarea en ocho threads para que cada uno se ejecute en un procesador distinto y reducir de esta manera el tiempo en conseguir el resultado.

Crear estos threads y distribuir la carga de trabajo hace que nuestro código sea más largo, difícil de leer, propenso a errores, y el crear ocho threads (como comentamos antes) no siempre es lo mejor, ya que esto depende de la carga de los procesadores y de la cantidad de éstos que dispongamos en cada máquina donde se vaya a ejecutar nuestra aplicación. Para facilitar estas tareas aparece la .NET Task Parallel Library, o como se la conoce, la TPL.

Task Parallel Library

Esta librería fue creada en un esfuerzo en conjunto del Microsoft® Research, el equipo del Parallel Computing Platform y el equipo del Microsoft® Common Language Runtime (CLR). La misma se encuentra incluida en la beta 1 del .NET Framework 4.0, pero puede utilizarse su versión CTP para .NET Framework 3.5 descargándola de la siguiente página: Microsoft Parallel Extensions to .NET Framework 3.5, June 2008 Community Technology Preview.

Cabe mencionar que en .NET Framework 4.0 hay muchas novedades sobre paralelismo, por ejemplo, está Parallel LINQ (también conocido como PLINQ), una librería para utilizar LINQ distribuyendo su carga en los procesadores disponibles, Parallel Pattern Library (o PPL) una librería de patrones utilizados en algoritmos concurrentes, y varias cosas más que exceden el alcance de este artículo.

TPL nos brinda distintas clases y métodos para distribuir y hacer un balance de carga de las tareas que debe realizar nuestra aplicación sobre los distintos procesadores que tengamos disponibles en la máquina en tiempo de ejecución. Por ejemplo, supongamos que tenemos una máquina con un procesador de doble núcleo y nuestra aplicación debe realizar tres tareas, el TPL ejecutará las dos primeras, una en cada núcleo, y al concluir cualquiera de éstas comenzará a ejecutar la tercera tarea en el núcleo disponible. Si esta misma aplicación la corremos en una máquina que posea más de dos núcleos ejecutará las tres tareas al mismo tiempo.

Hay que mencionar que la creación, administración y sincronización de estas tareas y threads por parte del TPL generan una carga extra de trabajo, pero ésta es muy pequeña y la ganancia al utilizar todos los procesadores de la máquina es enorme.

En .NET Framework 4.0 esta librería está incluida en el archivo mscorlib.dll, con lo cual podemos utilizarla sin necesidad de agregar librerías, pero si queremos usarla desde una aplicación desarrollada con .NET 3.5, además de bajar e instalar el CTP desde la dirección mostrada anteriormente, tenemos que referenciar el archivo System.Threading.dll desde nuestro proyecto.

La librería posee complejos algoritmos para la distribución dinámica de la carga entre los procesadores, pero esto sólo representa una posible ejecución en paralelo, ya que en una máquina con un único procesador las iteraciones se ejecutarán de manera secuencial en el mismo thread. Sin embargo hay que tener en cuenta que cuando utilizamos esta librería en una máquina multi-core es muy probable que se ejecuten varias acciones al mismo tiempo, por lo tanto es necesario tratar de evitar el uso compartido de variables entre éstas ya que podrían solaparse, pero para el caso en que esto sea necesario, más adelante mostraré como se puede hacer de manera segura.

Muchas veces necesitamos comparar un array de bytes, verificar que una contraseña es correcta sin almacenar la original o verificar la firma digital de un documento. Para realizar esto se puede crear el Hash del set de datos original y compararlo con el del nuevo. En el caso de la contraseña, se puede almacenar el Hash de la clave original y luego verificar que este dato sea igual al de la clave a comparar, logrando de esta manera que se pueda garantizar que aunque alguien pueda ingresar en la base de datos (incluso el mismo personal de la empresa) no podrán obtener la clave ingresada del usuario.
Para calcular el Hash primero hay que crear una instancia del algoritmo a utilizar, los cuales se encuentran en el namespace System.Security.Cryptography y heredan de la clase HashAlgorithm. Ejemplos de estas clases son RIPEMD160, MD5 y SHA512.

Luego de esto simplemente tenemos que invocar el método ComputeHash de la instancia pasándole el vector de bytes del cual se desea calcular el Hash. En caso de querer calcular el de un texto primero se deberá obtener los bytes del texto, por ejemplo, utilizando el método GetBytes de algún Enconding.

El Hash es otro vector de bytes por lo cual, si queremos mostrarlo en pantalla, podríamos convertirlo a base 64.

A continuación les dejo un ejemplo de cómo calcular el Hash de un string con el algoritmo SHA512 y guardarlo en otro string:

using System.Security.Cryptography;
using System.Text;
using System;
…
string strOriginal = "Cadena de la cual calcular el hash";
byte[] bytOriginal = Encoding.ASCII.GetBytes(strOriginal);
SHA512 objAlgoritmo = SHA512.Create();
byte[] bytHash = objAlgoritmo.ComputeHash(bytOriginal);
string strHash = Convert.ToBase64String(bytHash);

Por último les dejo un pequeño proyecto hecho con WPF donde se calculo el hash de un texto ingresado utilizando distintos algoritmos.

Artículos relacionados

• Conceptos de Certificado Digital y Firma Digital
• Crear certificados de prueba para servidor y cliente
• Utilizar certificados digitales desde .NET
• Cómo firmar un PDF desde C# con iTextSharp

Ya está disponible el Community Technology Preview del Visual Studio 2010 y del .NET Framework 4!  Esta información está disponible en Microsoft Connect.  La dirección de donde bajarse el CTP es esta: http://www.microsoft.com/downloads/details.aspx?FamilyId=922B4655-93D0-4476-BDA4-94CF5F8D4814&displaylang=en.  Cabe mencionar que la descarga ocupa alrededor de 7.2 Gb. y es una máquina virtual para Microsoft Virtual PC 2007, lo que permite que hagamos pruebas con estos productos sin alterar o dañar ninguna de las otras versiones que podamos tener instaladas en nuestro PC.