sábado, 29 de diciembre de 2012

Trabajando con tipos binarios BLOB (Binary Large Object ) en PostgreSQL.

En el estándar SQL están definidos dos tipos de datos para guardar grandes cantidades de información, el CLOB (CHARACTER LARGE OBJECT) que se utiliza para información de tipo texto y el BLOB (BINARY LARGE OBJECT).

El tipo de datos CLOB se representa en la base de datos como un registro con una gran cantidad de información de tipo carácter, estos caracteres pertenecen al conjunto de caracteres definidos por la base de datos (generalmente ASCII) siendo de un solo byte por lo que se utiliza para guardar archivos de texto como por ejemplo los archivos XML. Por su parte el tipo de datos BLOB se representa como un registro de una gran cantidad de información binaria sin estructura distribuida de forma aleatoria por lo que es ideal para archivos binarios como los mapas, las gráficas, y todos los archivos multimedia.

Trabajando tipos de datos BLOB con funciones predeterminadas de PostgreSQL

PostgreSQL proporciona el soporte para tipos de datos BLOB mediante las funciones predeterminadas: lo_import() y lo_export(), las cuales importan y exportan archivos desde el sistema de archivos hacia la base de datos y viceversa. Para ejemplificar el uso de estas funciones tenemos una tabla llamada Books con el siguiente script SQL:


Es esta tabla la columna picture tiene un tipo de dato oid el cual es un identificador que se utiliza como referencia hacia la tabla de sistema pg_largeobject la cual almacena el objeto binario en una o más filas, por lo que la columna picture almacena únicamente el apuntador hacia la información del objeto binario no el objeto binario en si. Como ejemplo agregamos un registro a la tabla, importando la imagen desde el sistema de archivos hacia la base de datos con la función: lo_import()



Ahora recuperamos el registro obteniendo la imagen desde la base de datos hacia el sistema de archivos con la función lo_export().


Las funciones lo_import() y lo_export() son ejecutadas directamente por el servidor de PostgreSQL por lo que la ruta completa del archivo debe tener los permisos correspondientes para ser accesibles desde el servidor, es necesario que el usuario de PostgreSQL tenga el rol de superuser de PostgreSQL (no confundir con el root de Linux).

Descargar el código SQL(Download the source code)

viernes, 14 de diciembre de 2012

Algoritmo Genético para el TSP (Traveling Salesman Problem) con Monodevelop utilizando C#

La computación evolutiva es una parte de la inteligencia artificial donde se agrupan diferentes técnicas adaptativas enfocadas a encontrar las mejores soluciones para resolver problemas de optimización, estas técnicas parten de una de las principales ideas que existen en la teoría de la evolución biológica propuesta por Charles Darwin, la selección natural es el proceso histórico de transformación de unas especies en otras especies descendientes e incluye la extinción de la gran mayoría de las especies que han existido, lo que es sin duda un problema de optimización además de que muchos de los términos que utiliza la computación evolutiva son tomados de la biología, con la advertencia de que se son usados para representar más o menos la misma idea biológica lo que no equivale a que sean iguales.

La computación evolutiva se compone por las siguientes técnicas:

  1. Programación evolutiva: Son una estrategia de optimización estocástica hacen un énfasis específico en los operadores genéticos tal y como se observan en la naturaleza.
  2. Estrategias evolutivas: Esta técnica esta básicamente enfocada hacia la optimización. En esencia son métodos estocásticos con paso adaptativo, que permiten resolver problemas. A este método se le han agregado procedimientos propios de la computación evolutiva, que lo han convertido en un paradigma más de dicha metodología.
  3. Algoritmos genéticos: Usan métodos que tienen analogía en la selección natural y la evolución.
Entre los usos de la computación evolutiva se encuentran la planificación, el diseño de sistemas, la simulación, el reconocimiento de patrones, el control y la clasificación de datos.

La alternativa para una solución de problemas de planificación y de optimización donde la mayoría están se ubican dentro de la categoría de los problemas NP los cuales no pueden ser resueltos usando las técnicas convencionales y solo pueden ser atacados desde las técnicas de computación evolutiva donde el dominio de esos problemas le corresponden a los algoritmos genéticos (John H. Holland, 1975) 

Como ejemplo de este tipo de aplicaciones me encontré en este web site (http://www.heatonresearch.com) un Applet Java, que utiliza algoritmos genéticos para obtener una solución optima al problema del agente viajero (Traveling Salesman Problem), en el mismo web site el autor nos hace un resumen del problema.

Pues bien como un ejercicio de aprendizaje, traduje el código del applet de Java a C# como un proyecto de Monodevelop utilizando Winforms, a continuación algunas screenshots y el código fuente del proyecto. He de aclarar que debido a la falta de tiempo hice casi copia tal cuál del código, modificando las partes de Java que el compilador me marcaba como errores.

Inicio de la aplicación

Aplicación en ejecucción

Resultado de la aplicación

En su web site el autor Jeff Heaton además del código fuente del applet, ofrece libros acerca de inteligencia artificial y de programación con Java y C#.

Descarga el código fuente en un proyecto para MonoDevelop o Visual Studio

martes, 2 de octubre de 2012

Utilizando secuencias (sequences) en PostgreSQL con C# .

Con frecuencia en un buen diseño de bases de datos es necesario que las tablas tengan al menos un identificador único para poderlas relacionar con otras, siguiendo las recomendaciones de las conocidas reglas de Codd para el modelo relacional de bases de datos.Para cumplir con este requerimiento podemos fijarnos en la entidad que representa cada tabla y seguir la especificación del identificador único que le correspondería según nos dicten las reglas del negocio o el tipo de sistema que vamos a construir.

Hay casos en donde la tabla no tiene una entidad definida sino sirve únicamente como tabla de soporte para una relación muchos a muchos, como un catálogo o un listado de parámetros para el sistema, en estos casos donde no se tiene una especificación definida para asignar un identificador único lo más recomendado es utilizar una serie o un contador como valor para ese identificador.

PostgreSQL proporciona unos objetos llamados secuencias (sequences) que sirven para crear contadores o series, las secuencias son objetos de bases de datos al mismo nivel que las tablas, vistas, triggers o funciones.

Aunque pueden crearse contadores y series de forma manual esto no será tan eficiente como los objetos sequence que nos proporciona PostgreSQL ya que mejoran el desempeño de la base de datos sobretodo en sistemas multiusuario. La forma automática de crear una secuencia es utilizar el tipo de dato serial en una columna, como se muestra a continuación con el siguiente script para una tabla llamada Publishers.


Al ejecutar este script se crean dos objetos: la secuencia (sequence) y la tabla (en ese orden), como lo muestra la pestaña messages de pgadmin al finalizar la ejecución del script.


Ahora creamos una función plpgsql con la que agregaremos los registros a la tabla, en esta función establecemos los valores mediante parámetros para cada una de las columnas, excepto claro el identificador (columna publisherid), ya que de ese valor se encargará la secuencia.


Ahora con el siguiente programa en C# probaremos la secuencia agregando algunos registros e imprimiendo sus identificadores en la consola.


Compilamos el programa con el siguiente comando.

$ gmcs -r:/home/martin/lib/Npgsql2.0.11.94/Mono2.0/bin/Npgsql.dll,System.Data Main.cs

Al ejecutar el programa, se mostrarán los registros agregados y los valores que les asigno la secuencia como identificador.


También podemos crear una secuencia (sequence) de forma manual siguiendo la sintaxis:

create sequence [name] start with [number] increment by [number]

De manera predeterminada las secuencias comienzan en el número 1 al menos no se indique con el comando start with. Por ejemplo creamos una secuencia que se incremente de 6 en 6

Test=# CREATE SEQUENCE my_first_sequence_seq INCREMENT BY 6;

Para acceder a los valores de la secuencia lo hacemos con un SELECT y la función nextval() como se muestra a continuación:


Observamos que la secuencia comienza en 1 e incrementa de 6 en 6.
Para acceder al valor actual de la secuencia lo hacemos con la función currval() como se muestra a continuación:


Para establecer un nuevo valor en la secuencia utilizamos la función setval()


Por último podemos eliminar la secuencia creada con el comando:

DROP SEQUENCE [name]

Como se muestra a continuación, en la siguiente imagen:


Descargar el código fuente del ejemplo (Download the source code)

jueves, 6 de septiembre de 2012

Utilizando parameterized commands (comandos con parámetros) de ADO.NET en PostgreSQL con GTK#

Para complementar el tema del post anterior, como un segundo ejemplo mostramos un formulario GTK# que utiliza una función PL/SQL, en donde además de los parámetros de entrada se establecen dos parámetros de salida, los cuales una vez de ejecutada la función devuelve los valores número de referencia y la fecha actual, que el formulario GTK# muestra en un mensaje.
Para preparar el ejemplo, creamos una base de datos llamada Test con una tabla llamada workitems en donde la función creará un nuevo registro.
Aquí el código de la tabla:




A continuación el código de la función.




Esta función utiliza la función createrefnum(id) utilizada en la primera parte de este tutorial.
En esta función los parámetros de salida se especifican con la palabra reservada OUT junto a los parámetros de entrada en los argumentos, inmediatamente después del la declaración del nombre, como se muestra el siguiente fragmento del código.



create or replace function usp_createworkitem(out nref varchar,varchar,varchar,varchar,
varchar,out creationDate timestamp)

En este ejemplo debemos de tener una solución en MonoDevelop con dos tipos de proyectos: uno de tipo library en donde se pondrán las siguientes clases:
WorkItem.cs : representa la clase de transporte de datos o POCO.
MessageDAC.cs: que representa la clase de acceso a PostgreSQL.

El otro es un proyecto tipo GTK# que contiene las clases Main.cs y MainWindow.cs correspondientes a la GUI del formulario y al manejo de eventos.
La solución deberá de verse como en la siguiente imagen:



El diseño del formulario queda como en la siguiente imagen:



A continuación el código de las clases de la solución.
Aquí el código de las clase Workitem.cs




Aquí el código de la clase MessageDAC.cs




Aquí el código de la clase MainWindow.cs




En la clase MessageDAC se encuentra el código en donde ejecutamos la función, para que se ejecute correctamente debemos establecer la propiedad CommandType de la clase NpgsqlCommand con el valor de la enumeración CommandType.StoredProcedure.


cmd.CommandType = CommandType.StoredProcedure;

Entonces creamos los parámetros de entrada y de salida, para los de salida se crea un NpgsqlParameter por cada uno y se establece su propiedad Direction con la enumeración ParameterDirection.Output, es importante no olvidar agregarlos a la enumeración Parameters del NpgsqlCommand.


NpgsqlParameter nref = new NpgsqlParameter("nref",NpgsqlDbType.Varchar);
nref.Direction = ParameterDirection.Output;
cmd.Parameters.Add(nref);
cmd.Parameters.Add("Title",NpgsqlDbType.Varchar).Value = wk.Title;
cmd.Parameters.Add("AssignedTo",NpgsqlDbType.Varchar).Value = wk.AssignedTo;
cmd.Parameters.Add("Area",NpgsqlDbType.Varchar).Value = wk.Area;
cmd.Parameters.Add("Reason",NpgsqlDbType.Varchar).Value = wk.Reason;
NpgsqlParameter created = new NpgsqlParameter("creationDate",NpgsqlDbType.Timestamp);
created.Direction = ParameterDirection.Output;
cmd.Parameters.Add(created);


Después de ejecutar el comando para llamar la función obtenemos el valor de regreso, haciendo referencia por su nombre de la enumeración Parameters.


wk.Numref = cmd.Parameters["nref"].Value.ToString();
wk.Created = Convert.ToDateTime(cmd.Parameters["creationDate"].Value);


Al compilar y ejecutar el formulario se verá como en la siguiente imagen:



Al introducir los valores y presionar el botón OK se ejecutará el llamado a la función agregando el registro y devolviendo los valores de salida, que se mostrarán con un mensaje como se ve en la siguiente imagen:



Si todo se ejecuto correctamente, podemos consultar el registro ejecutando el siguiente comando desde una terminal:



$ psql Test –c “Select * from workitems” - A

Descarga el código fuente en un proyecto para MonoDevelop o Visual Studio

viernes, 31 de agosto de 2012

Utilizando parameterized commands (comandos con parámetros) de ADO.NET en PostgreSQL con C#.


Aunque este tutorial se centra en PostgreSQL, utilizo la clase genérica
DbCommand, ya que estos conceptos son aplicables a otros manejadores de bases de datos como Oracle o SQL Server, únicamente reemplazando las clases DbCommand y DbParameter por las clases específicas de ADO .NET para estas bases de datos.


La clase DbCommand de ADO .NET nos proporciona la capacidad de ejecutar comandos parametrizados, lo que nos permite pasar información en tiempo de ejecución a los store procedures o comandos SQL que nuestra aplicación .NET envié hacia la base de datos.
Estos parámetros se clasifican por su valor dentro de la enumeración ParameterDirection:


  • Input: Son el tipo predeterminado, envía los valores hacia la base de datos, es posible tener múltiples parámetros de entrada.

  • Output: Similar a los parámetros Input, solo que regresan los valores de retorno una vez que el comando es ejecutado, es posible tener múltiples parámetros de salida.

  • InputOutput: El parámetro es capaz de enviar y recibir un valor después de que el comando es ejecutado.

  • ReturnValue: El parámetro representa el valor de retorno de la función.


El uso de comandos parametrizados nos ofrece los siguientes beneficios:


  • Nos permite definir el tipo de dato del parámetro.

  • Evita la concatenación de sentencias SQL en el código, con lo que disminuye el riesgo de un ataque SQL Injection.

  • Obtenemos un mejor rendimiento, las consultas pre-compiladas tienen un mejor desempeño al ejecutarse ya que el plan de ejecución es reutilizado para la misma consulta en vez construirlo repetidamente en cada ejecución como ocurre con las consultas SQL literales.

  • Los parámetros son revisados y validados para comprobar que no exista código malicioso, una de esas validaciones es la longitud, por ejemplo si el parámetro especifica una longitud de 50 caracteres, entonces solo 50 caracteres serán aceptados.


DbCommand tiene la propiedad Parameters que representa la colección de parámetros que están asociados al comando SQL. Estos parámetros son representados por el objeto DbParameter el cual tiene las siguientes propiedades:

    DbType: Representa el tipo de dato de la fuente de datos como un tipo CLR.
    Direction: Indica si el parámetro es de entrada, de salida o bidireccional.
    IsNullable: Indica si el parámetro acepta valores nulos.
    ParameterName: Representa el nombre del parámetro.
    Size: Representa la longitud del parámetro.
    Value: Obtiene u establece el valor del parámetro.

Como ejemplo un programa C# que muestra el uso de los comandos parametrizados llamando a una función de PL/pgSQL en PostgreSQL que realiza una concatenación de un número aleatorio, el año actual y el parámetro de entrada para crear un número distinto cada vez que se ejecute.
El código PL/pgsql de la función es el siguiente:



El resultado de la ejecución de la función es:


A continuación un ejemplo en C# en donde se muestra el uso de los parámetros ejecutando la función anterior con su parámetro de entrada (input) y recibiendo el valor de retorno.




Este ejemplo en MonoDevelop puede construirse como una aplicación de consola, agregando las refrencias al ensamblado Npgsql, como se muestra en la siguiente imagen:



La salida de la ejecucción de este programa es:


Si se ejecuta desde MonoDevelop la salida es:

Descargar el código fuente del ejemplo (Download the source code)

domingo, 29 de julio de 2012

Power Shell para Mono

Power Shell es el más reciente intérprete de comandos o CLI (Command Line Interface) para ambientes Windows similar a la consola de MS-DOS pero a diferencia de esta; Power Shell es además un lenguaje de guiones (Scripting Language) con derecho propio para competir con las opciones de cualquier shell en las plataformas UNIX/Linux.
Si retomamos una de las definiciones clásicas de lo que es un Shell:


"El Shell lee las ordenes y las interpreta como peticiones de ejecución de un programa o programas, por esta característica al shell se le denomina interprete de comandos, aquí el Shell es un lenguaje de programación."

tomado del libro UNIX System V Versión 4, Kenneth H. Rosen & Richard R. Rosinski.


Uno de los objetivos de Power Shell es llenar el vacío que siempre ha caracterizado a los sistemas Windows en cuanto a tener una consola de comandos medianamente funcional y poderosa ya que en este aspecto el Shell en los sistemas UNIX/Linux nunca han tenido ni cercanamente una competencia en el MS-DOS.
Dentro de las características de Power Shell tenemos las siguientes:


  • Esta basado en el Korn Shell por lo que hasta cierto la funcionalidad de este Shell es compatible con Power Shell.

  • Cumple con el estándar POSIX IEEE 1003.2

  • Es un scripting language que se agrega a los lenguajes de programación de Microsoft.

  • Utiliza el modelo de objetos de .NET para la representación de datos.


Pues bien en la página http://pash.sourceforge.net/ hay una versión Open Source de Power Shell la cual puede usarse con Mono.
Una vez que se han descargado los binarios desde la pagina se ejecuta el comando:

$ mono Pash.exe

Enseguida aparecerá la consola de Power Shell como en la siguiente imagen:


sábado, 23 de junio de 2012

Manuales acerca de PostgreSQL

Uno de los aspectos importantes para el desarrollo de aplicaciones corporativas en .NET o Mono es conocer una sistema manejador de base de datos (DBMS) a un buen nivel, en el caso de los ambientes Windows la opción predeterminada para los desarrolladores .NET es SQL Server,aunque también existen opciones open source para esa plataforma, una buena parte de las herramientas de base de datos de .NET es concebida en inicio para ese producto.
Para los ambientes Linux existen DBMS comerciales y open source igualmente buenas, pero hay un DBMS en particular que la mayoría de las ocasiones debemos de tener en cuenta sobretodo por sus características y este sin duda es PostgreSQL, ya por algo su lema es: "The world's most advanced open source database" (la base de datos open source más avanzada del mundo).
Pues bien, aquí pongo unos documentos que nos apoyarán en el conocimiento de este DBMS.

  1. Beginning Databases with PostgreSQL
  2. PostgreSQL: The comprehensive guide to building, programming, and administering
  3. PostgreSQL Up and running
  4. Practical PostgreSQL
  5. Guía del programador de PostgreSQL
  6. El lenguaje de procedimientos PL/pgsql
  7. Beginning PHP and PostgreSQL 8
  8. PHP and PostgreSQL: Advanced Web Programming
  9. PostgreSQL Introduction and Concepts

lunes, 18 de junio de 2012

Envio de e-mails vía SMTP con GTK# y Monodevelop.

Uno de los requerimientos más comunes para las aplicaciones .NET es el envío de E-mails o correos electrónicos, entre los ejemplos mas usuales para este tipo de requerimiento se encuentran el envío automático automático de boletines electrónicos, notificaciones de eventos, bitácora del sistema, solicitudes de reunión, envío de archivos adjuntos entre otros. .NET nos proporciona los ensamblados System.Net.Mail y System.Net.Mime, los cuales contienen todas las clases e interfaces necesarias para habilitar este tipo de requerimiento en cualquier aplicación .NET, a continuación describimos los elementos más importantes de estos ensamblados:

  • MailMessage:
  • Representa un mensaje de correo electrónico, esta clase tiene todas las propiedades del mensaje por ejemplo: tema del mensaje, destinatario, destinatarios, remitente,cuerpo entre otras.
  • MailAdress:
  • Representa una dirección de correo electrónico, esta clase ya implenta la lógica para validar que el formato sea correcto.
  • ContentType:
  • Representa la cabecera del protocolo MIME
  • AlternateView:
  • Representa una vista alternativa del mensaje en un formato diferente al predeterminado, por ejemplo HTML ó Calendar.
  • SmtpClient:
  • Esta clase se encarga de enviar el mensaje, aquí se establecen los parámetros de configuración del servidor SMTP, como: numero de puerto, usuario, password, SSL entre otros.

Como ejemplo de la utilización de estas clases, mostramos un formulario GTK# en Monodevelop que recibe los parámetros de configuración de un servidor SMTP, crea un mensaje de correo electrónico y lo envía hacia el o los destinatarios, utilizando dos clases: EMailMessage y SendMail.

El formulario en vista de diseño de MonoDevelop.


El código fuente de la clase EmailMessage


El código fuente de la clase Sendmail
<--Code Sendmail-->

<--Code Sendmail-->
El código fuente del formulario GTK#.
using System;
using Gtk;
using TestMail;
using System.Collections.Generic;

public partial class MainWindow : Gtk.Window
{
public MainWindow () : base(Gtk.WindowType.Toplevel)
{
Build ();
}

protected void OnDeleteEvent (object sender, DeleteEventArgs a)
{
Application.Quit ();
a.RetVal = true;
}
protected virtual void OnBtnSubmitClicked (object sender, System.EventArgs e)
{
try{
SendMail sendMail = null;
var email = new EMailMessage(txtSubject.Text,
                                  txtFrom.Text,
                                  GetAddresses(),
                                  txtDescription.Buffer.Text,
                         chkIsHtml.Active);
if(chkCredentials.Active)
sendMail = new SendMail(txtHost.Text,Convert.ToInt32(txtPort.Text),chkEnableSSL.Active);
else
sendMail = new SendMail(txtHost.Text,Convert.ToInt32(txtPort.Text),chkEnableSSL.Active
                            ,txtUserName.Text,txtPassword.Text);
sendMail.Send(email);
ShowMessageBox("Email Sent");
}catch(Exception ex){
ShowMessageBox(ex.Message);
}
}

void ShowMessageBox(string msg){
using (Dialog dialog = new MessageDialog (this,
      DialogFlags.Modal | DialogFlags.DestroyWithParent,
      MessageType.Info,
      ButtonsType.Ok,
      msg)) {
dialog.Run ();
dialog.Hide ();
}
}

List<string> GetAddresses() {
var resp = new List<string>();
foreach (string s in txtTo.Text.Split(','))
resp.Add(s);
return resp;
} 
protected virtual void OnBtnQuitClicked (object sender, System.EventArgs e)
{
Application.Quit();
} 

protected virtual void OnChkCredentialsToggled (object sender, System.EventArgs e)
{
tblCredentials.Visible = !chkCredentials.Active;
}
}

Básicamente el envió de correos electrónicos consiste de dos pasos: Primero la creación del mensaje con sus adjuntos si es que los hubiese, de esta responsabilidad se encarga la clase EMailMessage, la cuál es una clase derivada de MailMessage y se establecen todos sus parámetros en el constructor.

public EMailMessage (string subject,string fromField,List to,string body,
                       bool isBodyHtml)
 {
 Subject = subject;
 From = new MailAddress(fromField);
 foreach(string item in to) To.Add(new MailAddress(item));
 IsBodyHtml = isBodyHtml;
 if(IsBodyHtml)
  Body = GetHTMLContent(body);
 else
  Body = body;
 }

Como segundo paso, el envió del mensaje mediante un servidor SMTP. La clase Sendmail se ocupa de esta responsabilidad solicitando los parámetros de configuración del Server.

public SendMail(string server,int port,bool enableSSL){
 Server = server; 
 Port = port;
 EnableSSL = enableSSL;
 }
 public SendMail(string server,int port,bool enableSSL,string username,string password): 
 this(server,port,enableSSL){
 UserName = username;
 Password = password;
 Credentials = true;
 }

Y después envía el mensaje con el siguiente método:

public void Send(MailMessage msg){
 SmtpClient = new SmtpClient(Server,Port);
 SmtpClient.EnableSsl = EnableSSL;
 //DO NOT use: this property throws a Exception
 //SmtpClient.UseDefaultCredentials = true;
 if(Credentials){
 SmtpClient.UseDefaultCredentials = false;
 SmtpClient.Credentials = new NetworkCredential(UserName,Password);
 }
 ServicePointManager.ServerCertificateValidationCallback = 
     delegate(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) 
     { return true; };
 SmtpClient.Send(msg);
 }

En este método primeramente establecemos la configuración del servidor, indicamos si se usa o no una conexión segura, después en caso de requerir identificación establecemos el usuario y la contraseña, después utilizamos el delegado ServerCertificateValidationCallback de la clase estática ServicePointManager para la validación del certificado del servidor.
Luego de compilar, ejecutamos y probamos la aplicación utilizando el servidor de correo Gmail en cuyo caso establecemos la configuración como: Host: smtp.gmail.com
Port: 587
Username: [user name]@gmail.com
EnableSSL: true


Si el envío resulta exitoso la aplicación nos mostrará el siguiente mensaje:


De forma predeterminada el mensaje se envia en texto plano, para enviar el mensaje en HTML, habilitamos el checkbox para activar la propiedad IsBodyHtml y recibir el mensaje en este formato.


Tambien podemos utilizar un servidor local SMTP en caso de que nuestra distribución OpenSuse tenga instalados Postfix o Sendmail.


En el caso de no usar autentificación existe la propiedad UseDefaultCredentials que funciona en el Framework .NET de Microsoft, no así en el Framework Mono, si la utilizamos, Mono lanzará una excepción como se muestra en la siguiente imagen:


Descarga el código fuente en un proyecto para MonoDevelop o Visual Studio