Programación .NET y Cisco en la consola.

Subnetting en redes IPV4 parte II, IPv4 de los números de hosts

2012-01-30T00:58:00.000-08:00

Para sacar los números de host en una red con subneteo utilizamos los bits del último octeto, aquellos que no hayan sido utilizados para la subnet, por lo tanto estos bits serán utilizados para el número total de hosts.

Por ejemplo de la subred 130.3.12.128 necesitamos encontrar la IP número 20 o bien la vigésima IP de esa subred, bien la configuración de los octetos para esta subred se encuentran de la siguiente forma:

Bien en el último octeto entonces buscaremos el número 20 de acuerdo con los valores en decimal de los bits. Por lo que la configuración en el último octeto quedaría con los siguientes bits encendidos de acuerdo a su representación numérica.

Se realiza la suma decimal de los tres bits encendidos en el último octeto, dos de ellos representando el número de IP más el bit encendido del campo de subred.

128 + 16 + 4 = 148

Por lo que la vigésima IP de la subred 130.3.12.128 sería entonces la

130.3.12.148

Veamos ahora un segundo ejemplo, buscamos la última IP de host en la subred 400 de la red 130.3.0.0/25, por lo que la configuración de los octetos de esta subred queda de la siguiente forma:

Sumando la representación decimal de los bits encendidos del tercer octeto tenemos entonces:

128 + 64 + 8 = 200

Por lo que la IP para subred 400 es: 130.3.200.0.

Ahora vamos a utilizar el último octeto para obtener la última IP de esta subred, sabemos bien que la configuración para todos los hosts de esta subred es poniendo todos los bits encendidos excepto el del último octeto el cual representaría la IP del Gateway.
Por lo que la configuración del último host de esta subred en el último octeto queda de la siguiente forma:

Sumando su representación decimal

64 + 32 + 16 + 8 + 4 + 2 = 126

Por lo que la IP para el último host de la subred 400 es: 130.3.200.126

Subnetting en redes IP v4 Parte I

2011-12-31T17:52:00.000-08:00

Una dirección IPv4 (IPv4 address) tiene una longitud de 32 bits que se considera única para cada host, esta dirección se escribe en formato binario de izquierda a derecha donde se considera que el bit más significativo es el bit más hacia la izquierda, una IPv4 tiene dos partes, la parte de red (netid) y la parte de host (hostid), originalmente el espacio de direcciones IP fue dividido en tres clases diferentes clase A, clase B y clase C, cada clase se distingue por los primeros bits iniciales o bits de prefijo, como en la siguiente tabla:

La clase A tiene bit de prefijo en 0 y es seguido por 7 bits para la parte de red y 24 bits restantes para la parte de host, la clase B tiene dos bits de prefijo el primero en 1 y el segundo en 0 seguido de 14 bits para la parte de red y de 16 bits para la parte de host, la clase C tiene tres bits de prefijo el primero y el segundo en 1 y el tercero en 0 por lo que tiene 21 bits para la parte de red y 8 bits para la parte de host, existen también las clases D y E las cuales se usa para multicasting y para experimentación respectivamente.

En un principio este esquema pareció ser suficiente para el tamaño de las redes, pero conforme la Internet fue creciendo en número de redes y hosts, este esquema presento deficiencias, una de ellas fue el desperdicio y el agotamiento de direcciones, por lo que una de las soluciones a este problema fue el concepto de subneteo (subnetting) el cual nos permite tomar una dirección de red y crear subconjuntos de esa red o bien subredes esto se logra mediante los siguientes pasos:

Por ejemplo si se nos pide subneteo en una red clase B y se nos da un mascara de 27 bits, la clase B tiene 16 bits para el campo de red y 16 bits para el campo de host.
Se resta el número de mascara menos el número de bits del campo de red y el resultado es el número de bits que debemos de tomar de los octetos del campo de host.
En este caso:

Se utilizan los 11 bits para el subneteo y los 5 bits restantes se utilizan para el campo de host. Por lo que quedaría de la siguiente forma:

Bien ahora que ya tenemos identificados los bits de subred, vamos a poner en práctica como lo obtenemos las subredes en forma decimal.

Supongamos que tenemos una red 130.3.0.0 con una subnet mask de 25 o 130.3.0.0/25

Si necesitamos encontrar los números de subredes: 25 y 400 respectivamente por lo que en principio calculamos el número de bits que necesitaremos para la subred por lo que hacemos la resta:

25-16 = 9 bits para subneteo

Esquematizamos los octetos de la red 130.3.0.0/25, para una mejor comprensión:

En la parte inferior entre el tercero y el cuarto octeto vemos en color verde el número de subredes correspondientes a cada bit de la parte de subred, para la representación del valor en decimal utilizamos los valores de la parte superior, por lo que la suma de cada bit encedido en la parte inferior nos proporcione como resultado el número de subred y la suma de sus valores en la parte superior nos proporcione la representación decimal , así por ejemplo la subred número 25 será:

Hay que distinguir que para el número de subred sumamos los valores que nos den como resultado el número de subred que buscamos, sin importar que se encuentren en diferentes octetos y que para la parte decimal su representación es únicamente la suma de los valores de los bits que componen ese octeto.

Encendemos los valores de subred del tercer octeto en 16 y 8 y el valor de 1 del cuarto octeto para que la suma de sus valores de subred tengamos el número de 25.

16 + 8 + 1 = 25
Ahora entonces sumamos la parte superior del tercer octeto para obtener su representación decimal en este caso:

8 + 4 = 12
Y para el último octeto la representación decimal del bit encendido nos da 128, por lo que juntando todos los octetos obtenemos que la subred 25 se represente por la dirección Ipv4:

130.3.12.128 / 25
Ahora buscamos la representación decimal de la subred 400 utilizando el mismo método

En este caso como es un número par de subred, inferimos que el último octeto no tendrá valor por lo que nos concentramos en los bits del tercer octeto, prendemos el bit de subred 256, el bit 128 y por último el bit 16 de la suma obtenemos los bits de la subred 400.

256 + 128 + 16 = 400
Ahora obtenemos la representación decimal de los bits prendidos en el tercer octeto.

128 + 64 + 8 = 200
La subred 400 queda representada en formato decimal como:

130.3.200.0/25

Entendiendo Satellite Assemblies usando MonoDevelop - (parte 2)

2011-12-27T20:19:00.000-08:00

En la primera parte de este tutorial, se mostró como crear Satellite Assemblies, ahora en este segunda parte se mostrará un listado donde se muestra el código que nos mostrará los pasos de como consumir los ensamblados satélite o ensamblados de recursos desde una aplicación GTK#.


using System;
using Gtk;
using System.IO;
using System.Resources;
using Gdk;
using System.Reflection;

namespace TestResource
{
class MainClass : Gtk.Window
{
DrawingArea darea = null;
Label label1 = null;
Button btnLoad = null;
Pixmap pixmap;
Pixbuf pngbuf;
public MainClass():base("Test Resources"){
BorderWidth = 8;
this.DeleteEvent += new DeleteEventHandler(OnWindowDelete);
Frame frame = new Frame("Load");
Add(frame);
VBox MainPanel = new VBox (false, 8);
label1 = new Label("Query is: ");
darea = new DrawingArea();
btnLoad = new Button("Load resources");
btnLoad.Clicked += AddResource_Clicked;
darea.SetSizeRequest (200, 200);
darea.ExposeEvent += Expose_Event;
darea.ConfigureEvent += Configure_Event;
MainPanel.Add(label1);
MainPanel.PackStart(darea);
MainPanel.Add(btnLoad);
frame.Add (MainPanel);
SetDefaultSize (320, 233);
Resizable = false;
ShowAll();
}
public void OnWindowDelete(object o, DeleteEventArgs args) {
Application.Quit(); }
  
public static void Main (string[] args)
{
Application.Init();
new MainClass();
Application.Run();
}
  
void PlacePixbuf (Gdk.Pixbuf buf)
{
pixmap.DrawPixbuf (darea.Style.BlackGC,buf, 0, 0, 0, 0,buf.Width,
buf.Height,RgbDither.None, 0, 0);
darea.QueueDrawArea (0, 0, buf.Width, buf.Height);
}
  
void LoadResources(){
try{
//find the assembly
string assem = "demo.resources.dll";
Assembly assembly = Assembly.LoadFrom(assem);
if(File.Exists(assem))
{
 //Instance for resourcemanager
ResourceManager rm = new ResourceManager("demo",assembly);
 //get the string for the resource
label1.Text += rm.GetString("query1"); 
 //get the image for the resource
System.Drawing.Bitmap bitmap = (System.Drawing.Bitmap)rm.GetObject("pugme");
bitmap.Save("pugme.png",System.Drawing.Imaging.ImageFormat.Png);
pngbuf = new Pixbuf("pugme.png");
}
}catch(Exception e){
Console.WriteLine(e.Message);
}
}
  
void Configure_Event (object obj, ConfigureEventArgs args)
{
Gdk.EventConfigure ev = args.Event;
Gdk.Window window = ev.Window;
Gdk.Rectangle allocation = darea.Allocation;
pixmap = new Gdk.Pixmap (window, allocation.Width,allocation.Height, -1);
pixmap.DrawRectangle (darea.Style.WhiteGC, true, 0, 0,allocation.Width,
allocation.Height);
}

void Expose_Event (object obj, ExposeEventArgs args)
{
Gdk.Rectangle area = args.Event.Area;
args.Event.Window.DrawDrawable (darea.Style.WhiteGC, 
pixmap,area.X, area.Y,area.X, area.Y,area.Width, area.Height);
}
  
void AddResource_Clicked (object obj, EventArgs args)
{
LoadResources();
PlacePixbuf (pngbuf);
}
}
}

Toda esta funcionalidad se encuentra en el método LoadResources() , este método comienza primeramente con la carga en tiempo de ejecución del ensamblado que contiene los recursos utilizando las líneas siguientes:


string assem = "demo.resources.dll";
Assembly assembly = Assembly.LoadFrom(assem);

A continuación creamos una instancia de la clase ResourceManager en la cual se encuentran los métodos para obtener los recursos del ensamblado, en este ejemplo obtenemos un recurso de tipo cadena y otro de tipo imagen, con el código de las líneas siguientes


label1.Text += rm.GetString("query1"); 
System.Drawing.Bitmap bitmap = (System.Drawing.Bitmap)rm.GetObject("pugme");

Por último únicamente se guarda la imagen en el directorio de la aplicación para crear un objeto Pixbuf el cual se dibujará en un control DrawingArea, esto ocurre en las siguientes líneas:


bitmap.Save("pugme.png",System.Drawing.Imaging.ImageFormat.Png);
pngbuf = new Pixbuf("pugme.png");

Los métodos presentados por este programa en GTK# aplican para cualquier otra aplicación .NET incluso si el lenguaje de programación utilizado no es C#.

Compilamos la aplicación y ejecutamos la aplicación con los siguientes comandos desde una terminal:


$ mcs –pkg:gtk-sharp-2.0 –r:System.Drawing Main.cs
$ mono Main.exe

Al ejecutar la aplicación se mostrará como en la siguiente imagen:

Al presionar el botón Load resources deberán de cargarse los recursos de cadena e imagen respectivamente, antes de ejecutar la aplicación es importante verificar que el ensamblado demo.resources.dll se encuentre en el mismo directorio de la aplicación.

El resultado final se mostrará como en la siguiente imagen:

Parte del código de este programa se derivo del ejemplo 4-8 del capítulo 4 del libro Mono: A Developer's Notebook de Niel M. Bornstein y Edd Dumbill

Descarga el código fuente

Entendiendo Satellite Assemblies usando MonoDevelop - (parte 1)

2011-12-25T23:30:00.000-08:00

Una de las características más atractivas que .NET ofrece para el desarrollo de software es la capacidad de crear componentes en diferentes lenguajes de programación, esto es posible por que el objetivo de cada compilador existente para .NET es producir un assembly (ensamblado) el cual por definición es: La unidad funcional de distribución, versionamiento y de identidad de la plataforma .NET.

Además de clasificar los assemblies en Strong-Named o privados dependiendo de su instalación o en Single-File y Multi-File si contienen un archivo o varios, pueden también clasificarse en base a su contenido en donde tenemos a los ensamblados que contienen código MSIL y recursos (imágenes, traducciones o archivos de texto, etc) y a los Satellite assemblies (ensamblados satélite) que únicamente contienen recursos.

Para estos últimos ensamblados existen herramientas como Visual Studio o SharpDevelop que nos permiten hacerlo de forma automática, aunque también existe la opción de hacerlo de forma programática con las clases contenidas en el namespace System.Resources.

ResourceManager: Permite tener acceso a los archivos de recursos de forma programática.

ResourceReader: Lee los archivos binarios de recursos.

ResourceWriter: Escribe los archivos binarios de recursos.

ResXResourceReader: Lee los archivos XML de recursos.

ResXResourceWriter: Escribe los archivos XML de recursos.

En el siguiente programa mostramos el uso de la clase ResourceWriter para crear un satellite asembly. Abrimos MonoDevelop y creamos una solución GTK#, utilizando el diseñador de la interfaz gráfica, creamos una GUI similar a como se muestra en la siguiente imagen:

Construimos un manejador de evento para cada uno de los botones de manera que el código de la clase se vea como en el siguiente listado.


using System;
using Gtk;
using System.Resources;
using System.Collections;
using System.Drawing;


public partial class MainWindow: Gtk.Window
{       
//This class as a global variable
ResourceWriter rw = null;
Hashtable _values = new Hashtable();
Hashtable _imgValues = new Hashtable();
public MainWindow (): base (Gtk.WindowType.Toplevel)
{
Build ();
}
        
protected void OnDeleteEvent (object sender, DeleteEventArgs a)
{
Application.Quit ();
a.RetVal = true;
}

protected void OnBtnAddClicked (object sender, System.EventArgs e)
{
//we add values, if they have values
if(!string.IsNullOrEmpty(txtName.Text) &&
!string.IsNullOrEmpty(txtValue.Text))
{
if(chkIsImage.Active)
        _imgValues.Add(txtName.Text,txtValue.Text);
else
        _values.Add (txtName.Text,txtValue.Text);
lbMsg.Text = "Item added";
Clear(false);
}
else
lbError.Text = "Null values";                    
}

protected void OnBtnBuildClicked (object sender, System.EventArgs e)
{
try
{
//Ok, we create the Object
using(rw = new ResourceWriter("demo.resources")){
//iterate for the strings
foreach(DictionaryEntry entry in _values)
rw.AddResource(entry.Key.ToString(),entry.Value.ToString());
//iterate for the images
foreach(DictionaryEntry entry in _imgValues)
rw.AddResource(entry.Key.ToString(),new Bitmap(entry.Value.ToString()));
//Generate
rw.Generate();
Clear(true);
lbError.Text = string.Empty;
lbMsg.Text = "Resources file generated";
}
}catch(Exception ex){
        lbMsg.Text = string.Empty;
        lbError.Text = ex.Message;
}                              
}
        
void Clear(bool clearMsg)
{
txtName.Text = txtValue.Text = string.Empty;
chkIsImage.Active = false;
if(clearMsg)
        lbMsg.Text = string.Empty;
}
}

Al compilar y ejecutar el programa podemos ingresar uno a uno el nombre y el valor de la cadena o del archivo de imagen que contendrá nuestro archivo de recursos, en caso de las imágenes debemos habilitar el checkbox “Is image” además de que el archivo de imagen debe encontrarse físicamente en el mismo directorio que el programa, en las siguientes imágenes introduciremos un par de valores de prueba.

Después de ingresar el par de valores podemos generar físicamente el archivo de recursos con el botón “Build Resource”, como en la siguiente imagen:

La funcionalidad del botón “Build Resource” es crear una instancia de la clase ResourceWriter.


rw = new ResourceWriter("demo.resources")

Para después iterar en los valores de cada Hashtable,primero en el Hashtable de las cadenas en la cual utilizara el siguientel metodo:


rw.AddResource(entry.Key.ToString(),entry.Value.ToString());

A continuación itera en el Hastable de las imágenes en donde utiliza el método anterior salvo con la diferencia de convertir el valor en un objeto Bitmap.


rw.AddResource(entry.Key.ToString(),new Bitmap(entry.Value.ToString()));

Por último se utiliza el siguiente método:


rw.Generate();

Para crear físicamente el archivo “demo.resources” el cuál se creará en el mismo directorio donde se ejecuta el programa, como en la siguiente imagen:

Ahora solo falta crear el Satellite Assembly, esto puede lograrse con el compilador de .NET o bien con el Assembly Linker, para este tutorial utilizaremos el Assembly Linker, la instrucción para crear el ensamblado es la siguiente:


$ al /embed:demo.resources /out:demo.resources.dll

Utilizamos la opción /embed para incrustar el recurso en el ensamblado y la opción /out para nombrar al ensamblado resultado, este comando lo ejecutamos desde una terminal de consola como en la siguiente imagen:

Podemos observar que ahora el archivo mono.resources.dll es un ensamblado .NET válido mediante la herramienta MonoDis mediante el comando:


$ monodis mono.resources.dll

Veremos el contenido del ensamblado, como se muestra en la siguiente imagen:

Ahora ya tenemos listo el Satellite Assembly para que sea consumido por cualquier otra aplicación en .NET en la segunda parte mostraremos una aplicación para acceder al contenido del ensamblado.

Descarga el proyecto para MonoDevelop

Regular Expressions con C#

2011-11-17T20:16:00.000-08:00

Las expresiones regulares (regular expressions) han sido utilizadas con éxito desde hace tiempo como una solución avanzada mucho más compleja y eficiente para el procesamiento y la validación de texto en herramientas como grep, sed, AWK, bash y en lenguajes de programación del tipo scripting como Perl, Python y PHP.

Una expresión regular (regular expression o regexp) es un patrón de cadenas de caracteres formado por una combinación de caracteres especiales llamados metacaracteres o cuantificadores y de caracteres alfanuméricos llamados literales, este patrón representa un lenguaje regular o un conjunto regular de cadenas para tres operaciones básicas: adyacencia, repetición y alteración.

En el sitio http://www.regular-expressions.info/ se da una mayor referencia acerca de los cuantificadores y su significado.

Existen dos implementaciones de expresiones regulares POSIX y PERL, en el caso de .NET el motor de expresiones regulares utiliza la implementación compatible con Perl 5.
Las expresiones regulares en .NET se encuentran integradas como clases dentro del ensamblado System.Text.RegularExpressions estas clases utilizan un motor implementado como un autómata finito no determinístico (NFA) similar al que emplean Perl, Python y Emacs con algunas características propias de .NET.

Para ejemplificar el uso de expresiones regulares en C#, mostraremos un programa sencillo que tenga una funcionalidad similar al comando grep o egrep, como sabemos este comando en su funcionamiento básico recibe como argumentos una expresión regular y uno o varios archivos en donde buscar e imprime las líneas que coincidan con esa expresión regular.
El código del programa es el siguiente:


using System;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;

namespace TestGrep
{
class MainClass
{
public static void Main (string[] args)
{
if(args.Length == 2){
    string pattern = args[0];
 string file = args[1];
 Regex regexp = new Regex(@pattern,RegexOptions.Multiline);
 FileInfo fi = new FileInfo(file);
 if(File.Exists(fi.FullName))
 {
  using(StreamReader sr = new StreamReader(file)){
   string line;
   while((line = sr.ReadLine())!= null){
    Match m = regexp.Match(line);
    if(m.Success)
    Console.WriteLine("{0}",line);
   }
  }
 }
 else
  Console.WriteLine("File not found");
}else
Console.WriteLine("Usage: mono TestGrep [pattern] [file]");
}
}
}

Al ejecutar el programa podemos observar el resultado como se muestra en las siguientes imágenes probando con diferentes patrones con los archivos etc/password y /etc/group respectivamente.

Probando con el archivo /etc/password

Probando con el archivo /etc/group

Utilizando JavaScript desde código ASP.NET

2011-11-12T19:36:00.000-08:00

Actualmente es difícil construir una aplicación ASP.NET que no haga uso de las capacidades de JavaScript para realizar operaciones del lado del cliente o browser, operaciones que si fueran desarrolladas en su totalidad con la arquitectura ASP.NET serian demasiado costosas, basta recordar que ASP.NET es una arquitectura totalmente hecha para su uso del lado del servidor, por lo que hace uso de un mecanismo de Postback o de ida y vuelta entre los datos de la página solicitada por el cliente y por el servidor que proporciono la página, por lo que el mecanismo de Postback hace uso de uno de los recursos más valiosos de una red: el ancho de banda.

Durante ese viaje pueden ocurrir eventos que retarden o interrumpan la respuesta del servidor, causando una pérdida o una retrasmisión de los datos por parte del usuario resultando en una forma ineficiente de comunicación ya que ASP.NET reconstruye la página completa con todo su contenido en cada solicitud.
Para ayudar a no utilizar con frecuencia este mecanismo, hay que utilizar JavaScript en el cliente o browser como un complemento a las operaciones ASP.NET. Para utilizar JavaScript junto a ASP .NET, existe la clase ClientScriptManager la cual se programa mediante la propiedad ClientScript de la clase Page, la cual expone métodos que permiten incrustar código JavaScript dentro de la página ASP.NET.
Los métodos más comunes usados de esta clase son:

RegisterClientScriptBlock: Incrusta el código JavaScript al inicio del formulario después de la etiqueta <form>, genera dinámicamente el código JavaScript desde una cadena.

RegisterStartupScript: Incrusta el código JavaScript en el final de la página, antes del cierre del formulario o sea antes del cierre de la etiqueta </form> , por lo que se recomienda para operaciones con controles HTML o ASP.NET, ya que hace referencia a ellos una vez cargados.

RegisterClientScriptInclude: sirve para ejecutar el código JavaScript que se guarda en un archivo externo (comúnmente con extensión .js) tiene dos cadenas como argumentos un nombre para identificar el script y el archivo que contiene el código JavaScript.

Como ejemplo mostraremos una página ASP.NET que utiliza dos listas de usuarios (ListBox) y dos botones (HTML input) que se utilizan para mover los usuarios de una lista hacia otra.
Los eventos son controlados mediante código JavaScript, esto sin utilizar código JavaScript incrustado en la página HTML, sino que el código JavaScript se genera desde código ASP.NET.
A continuación, el listado Default.aspx:


<%@ Page Language="C#" Inherits="PostJavaScript.Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "
http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head runat="server">
        <title>Default</title>
</head>
<body>
        <form id="form1" runat="server">
                <table>
<tr>
<td>Usuarios aceptados:</td>
<td></td>
<td>Usuarios bloquedos:</td>
</tr>
<tr>
<td>
<asp:ListBox ID="ddlAcceptedContacts" runat="server" SelectionMode="Multiple">
<asp:ListItem Value="1">Marvin Minsky</asp:ListItem>
<asp:ListItem Value="2">John McCarthy</asp:ListItem>
<asp:ListItem Value="3">Edsger Dijkstra</asp:ListItem>
<asp:ListItem Value="4">Donald Knuth</asp:ListItem>
<asp:ListItem Value="5">John Backus</asp:ListItem>
</asp:ListBox>
</td>
<td>
<input id="btnAdd" type="button" value="Agregar" onclick="addContact()"/>
<br />
<input id="btnRemove" type="button" value="Quitar" onclick="removeContact()"/>
</td>
<td>
<asp:ListBox ID="ddlRemovedContacts" runat="server" SelectionMode="Multiple">
<asp:ListItem Value="1">Niklaus Wirth</asp:ListItem>
<asp:ListItem Value="2">Anders Hejlsberg</asp:ListItem>
</asp:ListBox>
</td>
</tr>
</table>
        </form>
</body>
</html>

El código ASPX/HTML de este ejemplo no crea funcionalidad alguna por lo que explicaremos la funcionalidad contenida en el código C#, en el listado Default.aspx.cs.


using System;
using System.Web;
using System.Web.UI;

namespace PostJavaScript
{
public partial class Default : System.Web.UI.Page
{
string FuncCopyItem(string name, string source, string destiny)
{
    string s = "function " + name + "() {" +
" var control = document.getElementById(\"" + source + "\"); " +
" var controlSelected = document.getElementById(\"" + destiny + "\"); " +
"var selectedElements = 0; " +
"if (control.options.selectedIndex == -1)" +
" alert(\"lista vacia\"); " +
" else { " +
" var index = 0; " +
" if (controlSelected.options.length > 0) " +
" selectedElements = controlSelected.options.length;" +
" for (i = 0; i < control.length; i++) { " +
" if (control.options[i].selected == true) { " +
"controlSelected.options[selectedElements + index] = " +
"new Option(control.options[i].text, " +
"control.options[i].value); " +
" control.options[i] = null; " +
" index++;" +
" }" +
" } " +
" }" +
" } ";
    return s;
}
protected void Page_Load(object sender, EventArgs args)
{
    //en este ejemplo los controles ya han sido creados
    //por eso registramos los scripts al final del formulario ya que
    //usamos la propiedad ClientID
    //con el parámetro true ponemos las etiquetas de JavaScript en la página
    string ddl_one = ddlAcceptedContacts.ClientID;
    string ddl_two = ddlRemovedContacts.ClientID;
    string sc1 = FuncCopyItem("addContact", ddl_one,ddl_two );
    string sc2 = FuncCopyItem("removeContact", ddl_two, ddl_one);
    ClientScriptManager cs = Page.ClientScript;
    cs.RegisterStartupScript(this.GetType(), "addContact", sc1, true);
    cs.RegisterStartupScript(this.GetType(), "removeContact", sc2, true);
}
}
}

Primero creamos el código JavaScript que tendra la funcionalidad para agregar los elementos de una lista hacia la otra, esto se logra con la función FuncCopyItem(string name, string source, string destiny) esta función recibe tres argumentos el nombre de la función JavaScript que se creará en el código HTML al solicitar la página y con la cuál se identificaran los eventos de los controles , el control ListBox fuente de donde inicialmente se tomarán los items y por último el control ListBox destino a donde se pondrán los items.
Con la siguiente línea de código:


ClientScriptManager cs = Page.ClientScript;

Obtenemos el objeto ClientScriptManager de la página, con él cual utilizaremos el metódo cs.RegisterStartupScript con sus parámetros correspondientes, algo importante por lo cuál usamos este metódo es por que para construir el código JavaScript utilizamos la propiedad ClientID del control ListBox, es decir el control debe existir obligatoriamente de lo contrario, cuando ASP .NET contruya la página contruirá el código JavaScript con estos parámetros nulos lo que causará un error no en la página ASP.NET sino en el código JavaScript cuando se llame para ejecutarse.

La vista del proyecto en MonoDevelop

Ejecutando el proyecto en Internet Explorer 9.0

Ejecutando el proyecto en Firefox

Mostrado el código JavaScript en la página generada por ASP.NET

Descarga el proyecto para MonoDevelop

Ruteo Inter-VLAN en un Router Cisco utilizando Router-on-a-stick

2011-09-08T14:13:00.000-07:00

Una VLAN es técnicamente un dominio de broadcast diferente, por lo que de forma predeterminada no pueden comunicarse entre sí, salvo se usen diferentes técnicas de ruteo inter-vlan cada una de los cuales tiene sus ventajas y sus desventajas, a continuación mostraré un ejemplo de una técnica llamada "Router-on-a-stick", que en resumen consiste en configurar una interfaz física de un Router para operar como un enlace troncal en el puerto de un switch, el Router efectua el ruteo intervlan de forma interna mediante el uso de subinterfaces, una subinterfaz es una interfaz virtual(vía software) que se crea en una interfaz física, por lo que se asocia cada subinterfaz con un número de VLAN, asi que podemos tener varias subinterfaces creadas en una misma interfaz física, lo cual presenta ventajas y desventajas que enumeramos a continuación.

Ventajas

Fácil de implementar solo se requiere crear una subinterfaz por cada VLAN en el Router.

Mucho más económica que tener un Router por VLAN.

Mucho mejor latencia que tener un Router por VLAN.

Desventajas

Los Routers son más lentos que los switches para ruteo inter-VLAN, lo ideal es tener un switch multicapa.

Si se necesita incrementar el número de puertos, entre más puertos requiera un Router más costoso resulta.

Estamos expuestos al buen funcionamiento de una sola interfaz física en el Router, esto es un único punto de fallo.

A continuación ejemplificaremos esta técnica con una práctica, los dispositivos son:

4 PC's

2 switches

1 router

1 access point

1 laptop

Al colocarlos en el WorkSpace del Packet Tracer debe ver más o menos como en la siguiente imagen:

Para la creación de las VLAN es conveniente el empleo de VTP para no teclear doblemente la configuración,asi que utilizamos el switch 1 (SW1,el que va unido al Router) como servidor y el switch 2 (SW2 el que tiene el access point) como cliente, empezamos la configuración en el SW1, con los siguientes comandos.


/* Creamos las VLAN's*/

Switch> en
Switch# host SW1

/*Configuramos como gateway la IP de la interfaz del Router*/

SW1#ip default-gateway [ip]
SW1# vlan database
SW1 (vlan) # vlan 20 name marketing
SW1 (vlan) # vlan 30 name accounting
SW1 (vlan) # exit

/*Modo servidor VTP*/

SW1# conf t
SW1 (config)# vtp mode server
SW1 (config)# vtp domain [name]

/*Configuramos las interfaces para acceso a las vlan*/

SW1# conf t
SW1 (config)# int fa/[número de interfaz]
SW1 (config-if)#switchport access vlan [número de vlan]

/*para deshabilitar el trunking */
SW1 (config-if)#switchport mode access
SW1 (config-if)#exit

/*para crear los troncales*/
SW1# int fa[0/número de puerto]

/*la hacemos troncal */
SW1 (config-if)# switchport mode trunk
SW1 (config-if)# switchport trunk allowed

En el SW2 tecleamos los mismos comandos para crear las troncales, la variante es la forma en que obtenemos las VLAN's creadas en el SW1 por VTP.


Switch> en
Switch# host SW2
/*Configuramos como gateway la IP de la interfaz del Router*/

SW2#ip default-gateway [ip]
SW2# conf t
SW2 (config)# vtp mode client

/*Aquí el dominio debe ser el mismo que el switch 1*/

SW2 (config)# vtp domain [name] 

/*Para mostrar las VLAN's*/

SW2# show vtp status

/*Se configuran los puertos asociados a las VLAN's con los comandos del SW1, 
cambiando el número de puertos.*/

/*Configurar la interfaz física.*/

Router>en
Router#host RTRA
RTRA# conf t
RTRA (config)# int fa0/0
RTRA (config-if)#ip address [ip] [subnet]

/*Al activar la interfaz física se levantan las subinterfaces*/

RTRA (config-if)# no shutdown
RTRA (config-if)# exit

/*Ahora viene la creación de subinterfaces en el Router.*/

RTRA (config)# interface f0/0.[vlan id]
RTRA (config-subif)# encapsulation dot1q [vlan id]
RTRA (config-subif)# ip address 192.168.[vlan id].1 255.255.255.0
RTRA (config-subif)# exit

En la configuración IP de cada PC, debe de ponerse como gateway la ip de cada subinterfaz asociada a la VLAN dentro de la cual se encuentre configurada la PC.
Por ejemplo si una PC su ip es:192.168.20.2 y se encuentra en la VLAN 20 su gateway sera la IP 192.168.20.1 la cual se asigno a una subinterfaz asociada con la VLAN 20, como se muestra en las siguientes imágenes:

Igualmente si una PC su IP 192.168.30.2 es perteneciendo a la VLAN 30, entonces su gateway es la IP 192.168.30.1 que se asigno a la subinterfaz asociada con la VLAN 30

Aquí se muestra la comunicación inter-VLAN's.

Descarga el archivo para packet tracer 5.3.2

Instalando Cisco Packet Tracer en OpenSuSe x64.

2011-09-07T13:24:00.000-07:00

Cisco packet tracer es un simulador para dispositivos de redes en donde se realizan la prácticas de Cisco Networking Academy.
Este simulador existe para los sistemas operativos Linux Fedora y Ubuntu, en formato .deb y .rpm que se descarga como un archivo ejecutable con extensión .bin.
Como no existe una versión de Packet Tracer de 64 bits,una de las dependencias para la instalación, es la libreria ligpng de 32 bits, aunque la version de 64 bits de esta biblioteca se encuentra instalada de forma predeterminada Packet Tracer solicitara la versión de 32 bits, por lo cual es necesario instalar la bibloteca ligpng[X.X]-32bits, en el caso de los usuarios de Suse, esto se realiza con Yast.

Como se muestra en la siguiente imagen:

En este caso decidí instalarlo en su formato .rpm, una vez descargado procedí a instalarlo con los siguientes comandos:


$chmod +rx [PacketTracer532_i386_no_tutorials_installer-rpm.bin]
$su
#./[PacketTracer532_i386_no_tutorials_installer-rpm.bin]

Un problema que sucede con frecuencia cuando ejecutamos el programa, es la horrible visualización de las fuentes, esto debido a las siguientes razones:

Cisco decidió utilizar sus propias bibliotecas QT para la ejecucción del programa, esto tiene sentido desde el punto de vista de que es un programa multiplaforma, por lo que evita que el usuario instale esa dependencia por separado, por ejemplo en el caso de Windows donde no se provee de forma predeterminada con tal requerimiento.

La fuente predeterminada para los menus del programa es tahoma, la cuál es una fuente no génerica, si no se encuentra disponible la fuente de los menus se ven de una forma ilegible.

Para solucionar el primer punto, hay que instalar el paquete de desarrollo de QT en mí caso fue el libqt4-dev. Con lo cuál se arreglaran las fuentes de todo el workspace en especial la de los dispositivos de red.


sudo zypper in libqt4-dev

Los menús de Packet Tracer de una forma ilegible

Para solucionar el segundo punto hay que cambiar la fuente de los menús, siguiendo los siguientes pasos:

Ir a al submenú preferences en el menú options del menú principal, ahi se abrirá una ventana con una serie de pestañas, elegir entonces la pestaña font, ahi en la sección General Interface ubicamos el valor de File Menu como se muestra en la siguiente imagen.

Cambiamos la fuente de Tahoma por una fuente más génerica, en mí caso elegí Arial

Podemos apreciar el cambio en la legibilidad de la fuente de los menús del menú principal.

Enlaces adicionales donde se encuentra más información al respecto:

Packet Tracer 5.2 font problem

Fixing fugly fonts on Ubuntu version of Packet Tracer

Entendiendo Logging en Aplicaciones .NET con Log4net

2011-07-30T14:03:00.000-07:00

Esta entrada se relaciona con esta entrada anterior, que trata también sobre el tema de Logging.
Log4net es opción altamente recomendable para la implementación del logging en las aplicaciones desarrolladas para .NET. Sobre todo cuando se necesita una solución más configurable y robusta que la proporcionada por las clases del ensamblado System.Diagnostics, que en comparación con log4net están en un nivel elemental, si necesitamos una herramienta que soporte diferentes fuentes de persistencia, que no afecte el desempeño de las aplicaciones y que sea transportable entre la implementación .NET de Microsoft y la del proyecto Mono.

Log4net es un Framework open source creado por la fundación Apache basado en la implementación de los servicios de logging existentes en log4j, un componente de logging usado durante años en los ecosistemas Java.
La arquitectura de Log4net puede resumirse en tres clases principales cada una encargada de una responsabilidad dentro del Framework y que se detalla a continuación:

Logger Captura la información para la bitácora.

Appender Publica la información hacia diversas fuentes de logging configuradas en la aplicación. Al menos debe definirse un Appender, el Appender predeterminado es el ConsoleAppender cual dirige su salida hacia una terminal de Consola.

Layout Se utiliza para darle formato haciendo legible cada salida de los distintos Appenders.

Para más información consultar http://logging.apache.org/log4j/1.2/manual.html aunque es para log4j la arquitectura es idéntica a log4net.

Como ejemplo del uso de log4net vamos a crear dos programas un cliente y un servidor los cuales se comunicarán entre sí, la clase ServerProgram es un servidor TCP que escucha en el puerto 6060 y la clase Program que es el cliente que al conectarse con el servidor, le solicita al usuario el nombre de un archivo de texto el cuál sera leído y cada línea de texto será enviada hacia el servidor. El programa cliente implementa todo el código básico para el manejo del logging con log4net.

Listado de la clase ServerProgram


using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
using System;

namespace Samples
{
public class ServerProgram
{
public ServerProgram()
{
try
{
    TcpListener listener = new TcpListener(IPAddress.Loopback, 6060);
    listener.Start();
    Console.WriteLine("Waiting....");
    TcpClient tcpClient = listener.AcceptTcpClient();
    NetworkStream stream = tcpClient.GetStream();
    Console.WriteLine("Recibiendo....");
    using (StreamReader sr = new StreamReader(stream))
    {
        Console.WriteLine(sr.ReadToEnd());
    }
    tcpClient.Close();
    listener.Stop();
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}
}

public static void Main(string[] args)
{
new ServerProgram();
}

}
}

Listado de la clase Program (cliente)


using System;
using System.Net.Sockets;
using System.IO;
using System.Net;
using log4net;
using log4net.Config;
using log4net.Appender;
using System.Configuration;

namespace Samples
{
class Program
{
static readonly log4net.ILog log = 
log4net.LogManager.GetLogger(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
public Program()
{
try
{
Console.Write("Puerto > ");
int thePort = Convert.ToInt32(Console.ReadLine());
Console.Write("File Name >");
string FileName = Console.ReadLine();
string s = null;
TcpClient c = new TcpClient("127.0.0.1", thePort);
NetworkStream stream = c.GetStream();
using (StreamWriter writer = new StreamWriter(stream))
{
    Console.WriteLine("Leyendo archivo");

    using (FileStream fs = new FileStream(FileName, FileMode.Open))
    {

        using (StreamReader sr = new StreamReader(fs))
        {
            while ((s = sr.ReadLine()) != null)
            {
                writer.WriteLine(s);
            }
        }
    }
}
stream.Close();
c.Close();
}
catch (FormatException ex)
{
    log.Error(ex.Message, ex);
    throw ex;
}
catch (SocketException ex)
{
    log.Error(ex.Message, ex);
    throw ex;
}
catch (IOException ex)
{
    log.Error(ex.Message, ex);
    throw ex;
}
catch (Exception ex)
{
    log.Error(ex.Message, ex);
    throw ex;
}}
public static void Main(string[] args) {
    try
    {
log.Info("Ejecutando la aplicación en " + DateTime.Now.ToLongTimeString());
        XmlConfigurator.Configure();
        new Program();
log.Info("Cerrando aplicación en " + DateTime.Now.ToLongTimeString());
    }
    catch (ConfigurationException ex)
    {
        Console.WriteLine("No se pudo cargar el logger",ex);
    }
    catch (Exception) {
        Console.WriteLine("Hubo un error, ver el log");
    }
}
}
}

El archivo de configuración App.config en donde van las opciones de configuración de Log4net


<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net"/>
</configSections>
<log4net debug="false">
<appender name="FileAppender" type="log4net.Appender.FileAppender">
<file value="log.txt"/>
<appendToFile value="true"/>
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="[%date{dd-MM-yyyy HH:mm:ss}] [%level] %message %newline"/>
</layout>
</appender>
<root>
<priority value="ALL"/>
<appender-ref ref="FileAppender"/>
</root>
</log4net>
</configuration>

En el archivo de configuración utilizamos el declarado en la siguiente sección


<appender name="FileAppender" type="log4net.Appender.FileAppender">
<file value="log.txt"/>
<appendToFile value="true"/>
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="[%date{dd-MM-yyyy HH:mm:ss}] [%level] %message %newline"/>
</layout>
</appender>

Declaración del componente principal para implementar los métodos del Logger.


static readonly log4net.ILog log = log4net.LogManager.GetLogger(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

carga la configuración del archivo de configuración para Log4net.


XmlConfigurator.Configure();

Escribir una excepción al log.


log.Error(ex.Message, ex);

Escribir información al log


log.Info("Ejecutando la aplicación en " + DateTime.Now.ToLongTimeString());

Compilando los programas:

Ejecutando el servidor

Ejecutando el cliente

Generando excepción de formato

Generando excepción de comunicación

Revisando el archivo de log, creado por log4net

File Upload con ASP.NET en Linux y Apache con HtmlInputFile (Html Control) y en IIS y Windows con FileUpload (Web Control).

2011-06-29T14:51:00.000-07:00

Una de las operaciones más frecuentes de las aplicaciones web (Web applications) es la carga de archivos (file upload), que es la acción donde el usuario puede seleccionar un archivo de su computadora y mediante el uso de un formulario en una página web puede transferir el archivo desde el sistema de archivos local hacia el sistema de archivos del servidor donde se encuentre la página web.
ASP .NET tiene dos formas de hacer esta funcionalidad, una mediante un control HtmlInputFile la cual se ha soportado desde el Framework 1.1 y la otra mediante un control FileUpload la cual se soporta a partir del Framework 2.0.

A continuación mostramos el listado de un programa en ASP.NET como ejemplo de la implementación de publicación de documentos utilizando el control HtmlInputFile.

Listado 1.0 ASP.NET upload con un control HtmlInputFile


<%@ Page Language="C#" AutoEventWireup="true"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script runat="server">

protected void Page_Load(object sender, EventArgs e)
{
}
//Version 1.1
protected void btnPublish_click(object sender, EventArgs args) {
try
{
string publishPath = ConfigurationSettings.AppSettings["publishPath"];
if(publishPath == null)
  sspublishPath = "/home/martin/public_html/Downloads/";
if ((htmlinputFile.PostedFile != null) && (htmlinputFile.PostedFile.ContentLength > 0))
{
    publish(htmlinputFile, publishPath);
    lblmsg.ForeColor = System.Drawing.Color.Black;
    lblmsg.Text = "Archivo públicado con éxito";
}
else
{
    lblmsg.ForeColor = System.Drawing.Color.Red;
    lblmsg.Text = "Falta archivo para publicar";
}
}
catch (Exception ex) {
lblmsg.ForeColor = System.Drawing.Color.Red;
lblmsg.Text = ex.Message;
}
}

public void publish(System.Web.UI.HtmlControls.HtmlInputFile inputFile,
string publishPath)
{
System.IO.FileInfo fi = new System.IO.FileInfo(inputFile.PostedFile.FileName);
string theFile = publishPath + fi.Name;
inputFile.PostedFile.SaveAs(theFile);
}
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server" enctype="multipart/form-data">
<div>
<table width="33%">
<tr>
    <td>
        1-. Seleccione el archivo</td>
</tr>
<tr>
    <td>
        <input id="htmlinputFile" maxlength="5120" name="htmlinputFile" size="48" 
            type="file" runat="server" /></td>
</tr>
<tr>
    <td>
        2-. Pulse el botón publicar</td>
</tr>
<tr>
    <td>
        <asp:Button ID="btnPublish" runat="server" Text="Publicar" 
OnClick="btnPublish_click"/>
    </td>
</tr>
</table>
<br />
<asp:Label ID="lblmsg" runat="server"></asp:Label>
</div>
</form>
</body>
</html>

Como muestra de la implementación ASP.NET con el control FileUpload, presentamos el siguiente listado.

Listado 2.0 ASP.NET Upload con un control FileUpload


<%@ Page Language="C#" AutoEventWireup="true"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">
protected void Page_Load(object sender, EventArgs e)
{
}
//Version 2.0 or above
public void btnPublish_Click(object sender,EventArgs args) {
try
{
string publishPath = System.Configuration.ConfigurationManager.AppSettings["publishPath"];
if (fupInputFile.HasFile && (fupInputFile.PostedFile.ContentLength > 0))
{
    Publish(fupInputFile, publishPath);
    lblmsg.ForeColor = System.Drawing.Color.Black;
    lblmsg.Text = "Archivo públicado con éxito";
}
else
{
    lblmsg.ForeColor = System.Drawing.Color.Red;
    lblmsg.Text = "Falta archivo para publicar";
}
}
catch (Exception ex) {
lblmsg.ForeColor = System.Drawing.Color.Red;
lblmsg.Text = ex.Message;
}
}
public void Publish(FileUpload inputFile,
string publishPath) {
System.IO.FileInfo fi = new System.IO.FileInfo(inputFile.PostedFile.FileName);
string theFile = publishPath + fi.Name;
inputFile.PostedFile.SaveAs(theFile);
}
</script>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server">
<div>
<table style="width:100%;">
<tr>
    <td>
        1-. Seleccione el archivo</td>
</tr>
<tr>
    <td>
        <asp:FileUpload ID="fupInputFile" runat="server" Width="522" />
    </td>
</tr>
<tr>
    <td>
        2-. Pulse el botón publicar</td>
</tr>
<tr>
    <td>
        <asp:Button ID="btnPublish" runat="server" Text="Publicar" 
OnClick="btnPublish_Click"/>
    </td>
</tr>
</table>
<br />
<asp:Label ID="lblmsg" runat="server"></asp:Label>
</div>
</form>
</body>
</html>

Para ambos casos el archivo de configuración web.config es el mismo, lo que cambia en ambos casos es el valor de la llave publishPath dentro de las etiquetas

<appSettings>

, ya que para el listado 1.0 que lo ejecutaremos en Linux utilizando Apache y Mono.
Por lo que el valor se establece en /home/martin/public_html/Downloads como se muestra en el web.config a continuación:


<?xml version="1.0"?>
<configuration>
  <appSettings>
    <add key="publishPath" value="/home/martin/public_html/Downloads/"/>
  </appSettings>
        <connectionStrings/>
        <system.web>
                <compilation debug="true">
                </compilation>
                <authentication mode="Windows"/>
        </system.web>
</configuration>

En el caso del listado 2.0 lo ejecutaremos en IIS 7.0 y Windows. Por lo que el valor se establece como se muestra en el web.config a continuación:


<?xml version="1.0"?>
<configuration>
  <appSettings>
    <add key="publishPath" value="C:\inetpub\Downloads\"/>
  </appSettings>
        <connectionStrings/>
        <system.web>
                <compilation debug="true">
                </compilation>
                <authentication mode="Windows"/>
        </system.web>
</configuration>

Para asignar el valor de la variable publishPath en el listado 1.0 con la siguiente línea:


string publishPath = ConfigurationSettings.AppSettings["publishPath"];

y para el listado 2.0 se asigna con la siguiente línea:


string publishPath = System.Configuration.ConfigurationManager.AppSettings["publishPath"];

Antes de ejecutar la página en Linux debemos habilitar con los permisos de escritura al directorio donde se guardaran los archivos, para hacerlo en Linux siga los siguientes pasos:

El directorio donde se subiran los archivos debe tener los permisos de escritura para el grupo www.

Si estamos como usuarios normales, cambiamos a una cuenta con privilegios de superusuario y establecemos y establecemos el grupo del directorio (en este ejemplo /home/martin/public_html/Downloads) como www con el siguiente comando:
```
# chgrp www Downloads
```

Ponemos permisos de escritura para el grupo con el siguiente comando:
```
# chmod 775 Downloads
```

Estos comandos se muestran a continuación en la siguiente imagen.

Ahora configuramos la Web Application dentro del archivo httpd.conf del servidor Apache como se muestra en la siguiente imagen:

Para consultar como crear una aplicación Web en Apache revisar el siguiente documento: ASP.NET con Mono

Igualmente antes de ejecutar la página en Windows debemos de habilitar con los permisos necesarios el directorio del servidor donde vamos a guardar los documentos, en este ejemplo la ruta configurada como directorio de publicación es C:\inetpub\wwwroot\dowloads, por lo que debemos seguir los siguientes pasos:

Hacer click derecho sobre el directorio, en la ventana Properties seleccionar al usuario IIS_IUSRS (el cuál es el usuario anónimo de IIS), presionar el botón “Edit” para abrir la ventana Permissions.

En la ventana de Permissions en la lista inferior Permissions for IIS_IUSRS seleccionar la casilla con el permiso Write

Creamos la Web Application de forma que se muestre en IIS 7.0 como en la siguiente imagen:

Al ejecutar la página ASP.NET desde FireFox en Linux se mostrará como en las siguientes imágenes:

Al ejecutar la página ASP.NET desde Internet Explorer en Windows se verá como en las siguientes imágenes:

Un error frecuente tanto para la implementación con HtmlInputFile y FileUpload, es tratar de subir un archivo que tenga un tamaño mayor al máximo permitido por la petición al servidor Web (Request)

Para solucionar este error solo hay que agregar la siguiente línea al archivo de configuración, donde definimos el tamaño máximo en Kb del archivo que necesitamos publicar. Por ejemplo en el siguiente web.config se definió un tamaño máximo aproximado a 5 mbs (5120 kb).


<?xml version="1.0"?>
<configuration>
  <appSettings>
    <add key="publishPath" value="C:\inetpub\Downloads\"/>
  </appSettings>
        <connectionStrings/>
        <system.web>
                <compilation debug="true">
                </compilation>
                <authentication mode="Windows"/>
                <httpRuntime maxRequestLength="5120"/>
        </system.web>
</configuration>

Para más información sobre este error consultar este enlace: HttpException Maximum Request Length.

Descarga el código fuente del ASP.NET con HtmlInputFile (Framework 1.1)

Descarga el código fuente del ASP.NET con FileUpload (Framework 2.0)

Utilizando Windows Management Instrumentation (WMI) con Microsoft .NET

2011-06-25T19:46:00.001-07:00

Para las aplicaciones que necesiten implementar una solución de un inventario total o parcial del hardware de la computadora, existe una interfaz de programación llamada WMI (Windows Management Instrumentation) a la cual puede accederse mediante lenguajes scripting como VBScript, Perl,Power Shell o cualquier lenguaje diseñado para el .NET Framework que haga uso de los ensamblados System.Management y System.Management.Instrumentation respectivamente.

Windows Management Instrumentation (WMI) es un conjunto de extensiones del Modelo de drivers de Windows WDM (Windows Driver Model) que es un modelo uniforme de clases que representan los valores del hardware y sistema operativo de la computadora,WMI es además la implementación Microsoft de Web-Based Enterprise Management (WBEM) un estándar de la industria que agrupa tecnologías desarrolladas para unificar la administración de los ambientes de computo, por lo que WMI es compatible con WBEM y provee el soporte para el Common Information Model (CIM) que es el modelo que describe los objetos de administración.

Un inventario de hardware con WMI se realiza mediante búsquedas en el repositorio o base de datos de WMI utilizando un lenguaje de consultas conocido como WQL (WMI Query Language) para encontrar los valores de ciertas propiedades del Hardware. WQL es un subconjunto de SQL.

WMI trabaja dentro del contexto de un ensamblado, siendo el predeterminado root\cli que controla las propiedades y métodos que están disponibles en WMI, la seguridad para el WMI se configura a través del control WMI (wmimgmt.msc), de forma predeterminada los usuarios tienen permisos para consultar el proveedor WMI en una computadora local mediante el comando WMIC, desde la línea de comandos del command prompt.

A continuación el listado de un programa de consola que imprime información del hardware del equipo.

1-.Una clase PC que será el objeto de transporte


using System;
using System.Collections.Generic;
using System.Text;

namespace PCProperties.Lib
{
public class PC
{
    public string RamMemory { set; get; }
    public string Processor { set; get; }
    public string IPAddress { set; get; }
    public string MacAddress { set; get; }
    public string OperatingSystem { set; get; }
    public string OperatingSystemVersion { set; get; }
    public string OperatingArch { set; get; }
    public string HardDisk { set; get; }
    public string Monitor { set; get; }
    public string MonitorType { set; get; }
    public string CdRom { set; get; }
    public string ProcessorSpeed { set; get; }
    
}
}

2-.Una clase PCManager que obtendrá algunos de los valores del Hardware para este ejemplo, mediante consultas WQL del repositorio WMI similar a las consultas SQL para en base de datos.


using System;
using System.Collections;
using System.Text;
using System.Management;
using System.Management.Instrumentation;
using System.Runtime.InteropServices;


namespace PCProperties.Lib
{
public class PCManager
{
static ManagementObjectSearcher searcher = null;
PC pcomputer = null;

public PCManager() {
searcher = new ManagementObjectSearcher();
}

public PC Select() {
pcomputer = new PC();
searcher.Query = new ObjectQuery("Select * from Win32_DesktopMonitor");
ManagementObjectCollection coll = searcher.Get();

foreach (ManagementObject objmng in coll)
{
pcomputer.Monitor = objmng["MonitorManufacturer"].ToString();
pcomputer.MonitorType = objmng["Name"].ToString();
}            
searcher.Query = new ObjectQuery("Select * from Win32_OperatingSystem");
coll = searcher.Get();
foreach (ManagementObject objmng in coll)
{
pcomputer.RamMemory = objmng["TotalVisibleMemorySize"].ToString() + "Mb";
pcomputer.OperatingSystem = objmng["Name"].ToString();
pcomputer.OperatingSystemVersion = objmng["Version"].ToString();
}
searcher.Query = new ObjectQuery("Select * from Win32_DiskDrive");
coll = searcher.Get();
foreach (ManagementObject objmng in coll)
pcomputer.HardDisk = (Convert.ToDouble(objmng["Size"]) 
    / 1024000).ToString() + "Mb";
searcher.Query = new ObjectQuery("Select * from Win32_CDROMDrive");
coll = searcher.Get();
foreach (ManagementObject objmng in coll)
pcomputer.CdRom = objmng["Name"].ToString();
searcher.Query = new ObjectQuery("Select * from Win32_Processor");
coll = searcher.Get();
foreach (ManagementObject objmng in coll)
{
pcomputer.ProcessorSpeed = objmng["MaxClockSpeed"].ToString();
pcomputer.Processor = objmng["Name"].ToString();
}

searcher.Query = new ObjectQuery("Select * from Win32_NetworkAdapterConfiguration");
coll = searcher.Get();
foreach (ManagementObject objmng in coll)
{
if (string.IsNullOrEmpty(pcomputer.MacAddress) &&
string.IsNullOrEmpty(pcomputer.IPAddress))
{
pcomputer.MacAddress = objmng["MacAddress"].ToString();
pcomputer.IPAddress = ((string[])(objmng["IPAddress"]))[0];
}
}
return pcomputer;
}
}
}

3-.Finalmente el programa de consola principal que despliega información del equipo.


using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using PCProperties.Lib;

namespace PCProperties
{
class Program
{
static void Main(string[] args)
{
PC pc = new PCManager().Select();
Console.WriteLine("\n Propiedades del equipo");
Console.WriteLine("===============================\n");
Console.WriteLine(" Memoria RAM\t[ {0} ]", pc.RamMemory);
Console.WriteLine(" Procesador\t[ {0} ]", pc.Processor);
Console.WriteLine(" IP:\t[ {0} ]", pc.IPAddress);
Console.WriteLine(" SO:\t[ {0} ]\n", pc.OperatingSystem);
Console.WriteLine(" Disco:\t[ {0} ]", pc.HardDisk);
Console.WriteLine(" Monitor:\t[ {0} ]", pc.Monitor);
Console.WriteLine(" Tipo Monitor:\t[ {0} ]", pc.MonitorType);
Console.WriteLine(" Cdrom:\t[ {0} ]", pc.CdRom);
Console.WriteLine(" Velocidad del procesador:\t[ {0} ]", pc.ProcessorSpeed);

Console.ReadLine();
}
}
}

El resultado de la ejecución del programa se muestra en la siguiente imagen:

Los puntos claves del programa utilizados por la clase PCManager son

Utilizar los ensamblados System.Management y System.Management.Instrumentation.

Crear una instancia de la clase ManagementObjectSearcher

Encapsular cada consulta dentro de la clase ObjectQuery

Obtener los resultados de la búsqueda en una colección de ManagementObject representada por la clase ManagementObjectCollection, para iterar dentro de la colección e imprimir los valores.

También se puede mostrar información desde una página ASP.NET como en el siguiente listado:

<%@ Page Language="C#" AutoEventWireup="true" %>

<%@ Import Namespace="PCProperties.Lib"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">

    protected PC pc = null;

protected void Page_Load(object sender, EventArgs e)

{



    try

    {

        pc = new PCManager().Select();

    }

    catch (Exception ex) {

        lblStatus.Text = ex.Message;

    }

}

</script>

<html xmlns="http://www.w3.org/1999/xhtml">

<head runat="server">

<title></title>

</head>

<body>

<form id="form1" runat="server">

<div>

    <table width="66%">

        <tr>

            <td width="28%">

                Memoria Ram</td>

            <td>

                 <%=pc.RamMemory%></td>

        </tr>

        <tr>

            <td>

                Procesador</td>

            <td>

                 <%=pc.Processor%></td>

        </tr>

        <tr>

            <td>

                IP</td>

            <td>

                 <%=pc.IPAddress%></td>

        </tr>

        <tr>

            <td>

                SO</td>

            <td>

                 <%=pc.OperatingSystem%></td>

        </tr>

        <tr>

            <td>

                Disco duro</td>

            <td>

                 <%=pc.HardDisk%></td>

        </tr>

        <tr>

            <td>

                Monitor</td>

            <td>

                 <%=pc.Monitor %></td>

        </tr>

        <tr>

            <td>

                Tipo de Monitor</td>

            <td>

                 <%=pc.MonitorType%></td>

        </tr>

        <tr>

            <td>

                Cdrom</td>

            <td>

                 <%=pc.CdRom%></td>

        </tr>

        <tr>

            <td>

                Velocidad del procesador</td>

            <td>

                 <%=pc.ProcessorSpeed %></td>

        </tr>

    </table>

</div>

<asp:Label ID="lblStatus" runat="server"></asp:Label>

</form>

</body>

</html>

El resultado de la ejecucción de la página:

Descarga el código fuente

Entendiendo Logging en Aplicaciones para .NET Framework

2011-05-31T17:23:00.000-07:00

El logging es un proceso recomendado durante la etapa de pruebas e indispensable durante la etapa de liberación o puesta en producción de aplicaciones de software, logging se refiere a la utilización de una bitácora, registro o log, donde guardemos la información de los diferentes eventos que genero la aplicación entre el tiempo de arranque y durante el tiempo de ejecución.
El registro o log debe proporcionarnos toda información necesaria para realizar con la aplicación las siguientes actividades:

Mantener el rastro de todos sus estados (recording)

Depurar (debugging)

Auditar (audit)

Diagnosticar su estado actual (tracing)

Un factor importante a considerar durante el logging es el performance de la aplicación ya que es un hecho que se incrementará el tiempo de las operaciones de escritura, sobre todo si el logging es requerido para una auditoría, este incremento en el performance se explica de la siguiente manera:

Si una operación del proceso de negocio emplea 5 segundos para ejecutarse y producir un resultado, con el logging necesitará 2 o 3 segundos adicionales para registrarse en el log, por lo que ahora el tiempo es de 7 u 8 segundos para el total de la operación.

El siguiente fragmento de código ilustra este factor:


try
{
//operación de negocio 5 segs.
var output = BussinessObject.ExecuteOperation();
//registro en el log 3 segs.
Logger.WriteLine(output);
//El tiempo  total de la transacción es de 8 segs.

}catch(Exception e){

//No está incluído dentro de la transacción.
Logger.WriteLine(e.Message);

}

Hay muchas formas de implementar logging en las aplicaciones, esto varía dependiendo del tipo de aplicación y del requerimiento a satisfacer la forma más sencilla es mediante el uso de las clases contenidas en el ensamblado System.Diagnostics. específicamente con las implementaciones derivadas de la clase TraceListener las cuales son responsables de desplegar o de guardar los mensajes generados por las clases Trace y Debug, hay tres implementaciones de esta clase:

TextWriterTraceListener escribe mensajes a cualquier clase que se derive de Stream

EventLogTraceListener escribe los mensajes a el Event Viewer de Windows.

DefaultTraceListener escribe los mensajes a la ventana de salida (Output window).

El siguiente listado muestra el uso de TextWriterTraceListener y EventLogTraceListener, la lógica del programa es simple, si el programa tiene permisos administrativos usará el event viewer como log, de lo contrario usará un archivo de texto, realizando un intercambio entre los Tracelisteners: EventLogTraceListener y TextWriterTraceListener respectivamente.


using System;
using System.Diagnostics;
using System.Threading;
using System.Security.Principal;
using System.IO;
using System.Text;

namespace ELtraceApp
{
class Program
{
public static void Main(string[] args)
{
try{

WindowsPrincipal winprincipal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
//Válidamos que sea Administrator
if (winprincipal.IsInRole(WindowsBuiltInRole.Administrator))
{
string logSource = "EventLogtraceApp";
string logName = "Event Log Test App";
if (!EventLog.SourceExists("EventLogtraceApp"))
EventLog.CreateEventSource(logSource, logName);
//quitamos el log de texto
Trace.Listeners.Remove("myTextLogListener");
Trace.Listeners.Add(new EventLogTraceListener("myEventLogListener"));
}
else{
//quitamos el log eventviewer
Trace.Listeners.Remove("myEventLogListener"); 
string fname = "log.txt";
FileStream stream = new FileStream(fname,FileMode.OpenOrCreate 
| FileMode.Append,FileAccess.Write);                
Trace.Listeners.Add(new TextWriterTraceListener(stream,"myTextLogListener"));
}
Console.WriteLine("Iniciar la aplicación...");
PrintfLog("Iniciar la aplicación...");
Console.WriteLine("Ejecutando la aplicación");
PrintfLog("Ejecutando la aplicación....");
Thread.Sleep(1000);
Console.Write("Presione cualquier tecla para continuar. . . ");
Console.ReadKey(true);
PrintfLog("Saliendo de la aplicación...");
Thread.Sleep(500);
}catch(Exception e){
Console.WriteLine(e.Message);
}

}

static void PrintfLog(string msg){
Trace.WriteLine(msg);
Trace.Flush();
}
}
}

Al compilar el listado se debe de incluir la opción /d:TRACE como se muestra en la siguiente imagen:

Al ejecutar el programa mostrará un resultado como en la siguiente imagen:

Con el siguiente código el programa intercambia entre Listeners dependiendo si pertenece al grupo con permisos de administración o no.


WindowsPrincipal winprincipal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
//Válidamos que sea Administrator
if (winprincipal.IsInRole(WindowsBuiltInRole.Administrator))
{
string logSource = "EventLogtraceApp";
string logName = "Event Log Test App";
if (!EventLog.SourceExists("EventLogtraceApp"))
EventLog.CreateEventSource(logSource, logName);
//quitamos el log de texto
Trace.Listeners.Remove("myTextLogListener");
Trace.Listeners.Add(new EventLogTraceListener("myEventLogListener"));
}
else{
//quitamos el log eventviewer
Trace.Listeners.Remove("myEventLogListener"); 
string fname = "log.txt";
FileStream stream = new FileStream(fname,FileMode.OpenOrCreate 
| FileMode.Append,FileAccess.Write);                
Trace.Listeners.Add(new TextWriterTraceListener(stream,"myTextLogListener"));
}

Si no pertenece al grupo de administradores utiliza como log un archivo de texto log.txt caso contrario utiliza el Event Viewer (visor de eventos de Windows) como se muestra en la siguiente imagen:

Lo más recomendable para el logging es la utilización de componentes como el Logging Application Block de Microsoft o el Log4net de la fundación Apache.

Nuevo número de la revista de software libre Atix

2011-05-31T15:00:00.000-07:00

Ha salido publicado un nuevo número de la revista de Software Libre Atix. Este es el número 19 de la publicación, el sitio de descarga con mirrors de varios países se encuentra en la siguiente dirección:

Ir al sitio de la Revista de Software Libre Atix

Uso de custom exceptions en aplicaciones GTK# con Monodevelop

2011-04-24T13:57:00.000-07:00

Hace unos días publiqué una entrada que mostraba el uso de excepciones personalizadas y como ejemplo de esa técnica un proyecto de consola de MonoDevelop que obtenía registros de una tabla en una base de datos PostgreSQL, derivado de ese ejemplo hice una aplicación en GTK# la cual muestra los mismos conceptos pero ahora con un formulario gráfico, por lo que hice algunas modificaciones con respecto al proyecto de consola de manera que pueda entenderse de una mejor manera.
Los pasos son:

Ejecutamos MonoDevelop y creamos un proyecto GTK# llamado GtkPostException

Descargamos y descomprimimos el código del ejemplo de excepciones de este enlace.

Con el botón derecho encima del icono de la solución agregamos las siguientes clases a la solución.


Book.cs
BooksDataManager.cs
DataBaseException.cs
Logger.cs
RuntimeException.cs

Una vez agregadas las clases a la solución verificamos y en su caso editamos para que cada clase se agrupe dentro del namespace GtkPostException.

Creamos un formulario con dos controles label, un control TextView (en donde teclearemos la Connection String), un control Treeviewdonde mostramos el resultado de la consulta y un botón de manera que el formulario tenga el aspecto visual de la siguiente imagen:

Cambiamos el código de la clase BooksDataManager en el método SelectAll para que reciba un parámetro string con el valor de la Connection String recibida desde la interfaz de usuario. Aquí el listado completo de la clase:


using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.Common;
using Npgsql;
using System.Configuration;

namespace GtkPostException
{
public static class BooksDataManager
{
static string connStr = null;
static List books = null;

public static List SelectAll(string connstr) {
try
{
connStr = connstr;
books = new List();
string CommandText = "SELECT title,pubyear,numpages,authors FROM books";
using (NpgsqlConnection conn = new NpgsqlConnection(connStr))
{
conn.Open();
using (NpgsqlCommand cmd = new NpgsqlCommand(CommandText, conn))
{
using (NpgsqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
while (reader.Read())
{
books.Add(new Book
{
    Title = reader["title"].ToString(),
    PubYear = Convert.ToInt32(reader["pubyear"]),
    NumPages = Convert.ToInt32(reader["numpages"]),
    Authors = reader["authors"].ToString()
});
}
}
}
}
return books;
}
catch (NpgsqlException ex)
{
var dbex = new DataBaseException("Error en base de datos", ex);
Logger.WriteLog(dbex);
throw dbex;
}
catch (Exception ex)
{
var rex = new RuntimeException("Error grave consulte al administrador", ex);
Logger.WriteLog(rex);
throw rex;
}
}
}
}

Agregamos al evento Clicked del Botón el metodo ExecuteQuery, cuyo código se muestra a continuación:


protected virtual void ExecuteQuery (object sender, System.EventArgs e)
{
try{
AddColumns(GridOutput);
GridOutput.Model = CreateModel();
lbmsg.Text += "Consulta ejecutada";

}catch(GtkPostException.DataBaseException ex){
MessageBox(ex.Message);

}
catch(GtkPostException.RuntimeException ex){
MessageBox(ex.Message); 

}
}

El listado completo de la clase MainWindow se muestra a continuación:


using System;
using Gtk;
using GtkPostException;

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 ExecuteQuery (object sender, System.EventArgs e)
{
try{
AddColumns(GridOutput);
GridOutput.Model = CreateModel();
lbmsg.Text += "Consulta ejecutada";

}catch(GtkPostException.DataBaseException ex){
MessageBox(ex.Message);

}
catch(GtkPostException.RuntimeException ex){
MessageBox(ex.Message); 

}
}

void MessageBox(string messageText){
using(Dialog dialog = new MessageDialog(this,
DialogFlags.Modal | DialogFlags.DestroyWithParent,
    MessageType.Error,
    ButtonsType.Ok,
    messageText,"")){
dialog.Run();
dialog.Hide();
}
}
//Creamos los encabezados de las columnas
void AddColumns (TreeView treeView) {
CellRendererText rendererText = new CellRendererText ();
string[] s = {"Titulo","Año","Páginas","Autores"};
TreeViewColumn column;
for(int i = 0;i < s.Length;i++){
 column =  new TreeViewColumn (s[i], rendererText, "text", i);
 column.Resizable = true;
 column.MinWidth = 128;
 treeView.AppendColumn (column);  
}
}
//Creamos el modelo de datos
ListStore CreateModel(){
ListStore store = new ListStore(typeof(string),
    typeof(int),
    typeof(int),
    typeof(string));

foreach(Book b in BooksDataManager.SelectAll(txtConnStr.Buffer.Text)){
store.AppendValues(b.Title,b.PubYear,b.NumPages,b.Authors);
}

return store;
}
}

Si se compila correctamente al ejecutar la aplicación veremos una pantalla como la siguiente imagen:

Al presionar el botón OK mostrará los registros de la tabla conforme a la consulta, como en la siguiente imagen.

Hasta aquí el flujo normal de la aplicación o happy path,ahora vamos a ocasionar una excepción reemplazando el usuario postgres por el usuario sa el cual no existe en la base de datos hecho esto presionamos el botón para que se muestre la excepción personalizada en un cuadro de dialogo, esta excepción queda a nivel base de datos de ahí que lance una DataBaseException.

Este tipo de excepciones son registradas por PostgreSQL si el proceso del servidor se ejecutó desde una terminal como en la siguiente imagen:

Para generar la excepción a nivel aplicación en vez del valor de la Connection String tecleamos cualquier cadena no válida con lo que al presionar el botón nos mostrará el mensaje referente a la clase RuntimeException como en la siguiente imagen:

El detalle a nivel técnico de las excepciones originales se podrá consultar en el archivo log.txt el cual por lo general no es accesible al usuario final sino únicamente al personal técnico.
A continuación el enlace para descargar el ejercicio completo.

Descarga el código fuente

Uso de Custom Exceptions (excepciones personalizadas) en .NET parte II

2011-04-23T13:52:00.001-07:00

En la entrada anterior del blog, me olvide de publicar el archivo App.config donde se encuentra la cadena de conexión (ConnectionString) y se accede a su valor mediante la siguiente línea en la aplicación y se asigna a la variable connStr.


connStr = ConfigurationManager.ConnectionStrings["curry"].ConnectionString;

El archivo es el siguiente:


<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<connectionStrings>
<add connectionString="Server=127.0.0.1;Port=5432;User Id=postgres;
Password=Pa$$w0rd;DataBase=curry" name="curry" providerName="Npgsql"/>
</connectionStrings>
</configuration>

En caso de ser necesario y de tener algún incoveniente en construir la solución aqui dejo el enlace para descargar el código fuente.

Descarga el código fuente

Uso de Custom Exceptions (excepciones personalizadas) en .NET

2011-04-19T18:34:00.000-07:00

Las excepciones (exceptions) son un mecanismo incorporado en .NET que ayuda a la detección de condiciones excepcionales en nuestras aplicaciones, entiéndase por condiciones excepcionales aquellas situaciones que están fuera de nuestro control y que no podemos prever como programadores, esto es distinto de los errores de código y de los errores de aplicación ya que estos si son prevenibles y manejables dentro del ciclo de desarrollo.
Como ejemplos de condiciones excepcionales tenemos:

Conectarse a una base de datos que se encuentra offline.

Conectarse a una base de datos y tratar de ejecutar un store procedure que no existe.

Leer de un archivo en disco que no se encuentra en una determinada ruta.

Convertir una cadena de caracteres o alfanumérica hacia un tipo numérico.

Ejecutar una acción cuando ya no hay memoria disponible en el sistema operativo.

Cuando se hace referencia a un elemento no creado o que se encuentra fuera de los límites de un arreglo.

En .NET la técnica para el manejo de estas condiciones se conoce como structured exception handling (SEH) (la traducción sería más o menos manejo estructurado de excepciones) esta técnica a base de bloques es parte integral de .NET y aplicable a cualquier lenguaje que se ejecute en .NET, en esencia parte de dos clases ApplicationException y SystemException que heredan de la clase System.Exception y que agrupan las excepciones en dos categorías, la primera representa excepciones lanzadas por las aplicaciones y la segunda las del CLR, las clases para excepciones incluidas en .NET son derivadas de estas clases que cubren los casos más comunes y para su empleo se usa la combinación de cuatro palabras reservadas: try,catch throw, finally como se detalla a continuación en los pasos siguientes:

1-. Se pone dentro de un bloque try aquel código que podría tener un evento inesperado.


try
{
 Paso1();
 Paso2();
 Paso3();
}

2-.Al final del bloque try puede ir acompañado o no de varios bloques catch, típicamente aparece la palabra catch con la clase que manejará el error si la palabra catch no especifica una clase entonces atrapara todas las posibles excepciones, cuando se enumeran una a una las posibles condiciones de excepción es MUY IMPORTANTE la jerarquía de clases ya que cada bloque debe ir de la clase más específica a la clase más general, por ejemplo:


catch(NpgsqlException ex){  //derivada de DbExeption

}
catch(DbException ex){  //derivada de ExternalException

}
catch(ExternalException ex){ //derivada de SystemException

}
catch(SystemException ex){ //derivada de Exception

}
catch(Exception ex){ //derivada de Exception

}

3-. Dentro de cada uno de los bloques catch se coloca el código para el manejo de la excepción como agregar nueva información a la excepción, establecer valores predeterminados de variables o lo más común aquí es tener un Log o bitácora para registrar la excepción, después hay que reenviar o arrojar la excepción a la clase que ejecuto ese código, hay dos alternativas a esto enviar la excepción tal cuál o bien enviar una excepción personalizada que sea de valor para las capas que llamaron la ejecución del código.


catch(NpgsqlException ex){  //derivada de DbExeption
 EscribeBitacora(ex.Message); 
}

4-. En el bloque finally se coloca el código que siempre será ejecutado haya ocurrido o no una excepción, por lo general en este bloque se coloca código de limpieza (cleanup) por ejemplo se cierran conexiones de red o a bases de datos, se liberan recursos utilizados o se cierran archivos abiertos entre otros usos.


finally{
 CloseConnectionDB();
 CloseNetWorkConnection();
 CloseFileOpenToWrite();
}

Las excepciones no deben ocasionar que la aplicación se colapse por completo por lo que una buena estrategia de desarrollo es manejar las excepciones y responder al evento que las ocasiono. Aunque el uso clases predeterminadas dentro del Framework es adecuado presenta una desventaja por el tipo de mensaje predeterminado ya que para el usuario esa información no debe ser de su conocimiento y en la mayoría de los casos no le encuentra utilidad, por lo que es necesario envolver la excepción dentro una técnica para personalizar excepciones.

La técnica para el uso personalizado de Excepciones

.NET permite crear excepciones personalizadas que envuelven las excepciones originales por excepciones que tengan nuevas características como por ejemplo: mensajes más significativos para el usuario, traducciones o que pueden tener información adicional.
Los pasos para crear una excepción personalizada son:

1-. Crear una nueva clase con el sufijo Exception como una buena práctica y recomendación las clases derivadas de Exception utilizan el este sufijo.


class RuntimeException
{
}

2-. Derivar esta clase de ApplicationException, aunque se podría derivar directamente de Exception, no se considera una buena práctica.


class RuntimeException : ApplicationException
{
}

3-. La clase debe de tener tres constructores dos adicionales al constructor predeterminado o vacio, como se muestra en el siguiente código:


public class RuntimeException : ApplicationException
 {
 public RuntimeException(string message): base(message){ }
 public RuntimeException(string message, Exception inner): base(message, inner){}
 }

Como ejemplo de estos conceptos vamos a crear una aplicación que se conecta a una base de datos PostgreSQL, lee y muestra los registros de una tabla llamada Books y donde hace uso de dos excepciones personalizadas: DataBaseException y RuntimeException.
En Monodevelop o en Visual Studio creamos una aplicación de consola, como en las siguientes imágenes.

Creamos una base de datos en PostgreSQL llamada curry y una tabla llamada Books que tendrá los campos como en la siguiente imagen:

Aquí el Script de creación de la tabla


CREATE TABLE books
(
  book_id serial NOT NULL,
  title character varying(512) NOT NULL,
  pubyear smallint,
  numpages smallint,
  created timestamp without time zone DEFAULT now(),
  authors character varying(256) NOT NULL,
  CONSTRAINT books_pkey PRIMARY KEY (book_id),
  CONSTRAINT books_title_key UNIQUE (title)
)
WITH (
  OIDS=FALSE
);
ALTER TABLE books OWNER TO postgres;

Una vez creada la base de datos y el proyecto, creamos la siguiente clase de entidad.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PostException
{
    public class Book
    {
        public string Title { set; get; }
        public int PubYear { set; get; }
        public int NumPages { set; get; }
        public string Authors { set; get; }
    }
}

Las clases derivadas y personalizadas que muestran con los constructores básicos del manejo de excepción.
La clase que maneja las excepciones en base de datos


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Common;
using Npgsql;

namespace PostException
{
public class DataBaseException : ApplicationException
{
public DataBaseException(string message) : base(message) { }
public DataBaseException(string message, NpgsqlException inner):base(message,inner) { }
public DataBaseException(string message, Exception inner):base(message,inner) { }
}
}

La clase que maneja las excepciones de la aplicación.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PostException
{
public class RuntimeException : ApplicationException
{
public RuntimeException(string message): base(message){ }
public RuntimeException(string message, Exception inner): base(message, inner){}
}
}

La clase de acceso a datos


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.Common;
using Npgsql;
using System.Configuration;

namespace PostException
{
public static class BooksDataManager
{
static string connStr = null;
static List books = null;

public static List SelectAll() {
try
{
connStr = ConfigurationManager.ConnectionStrings["curry"].ConnectionString;
books = new List();
string CommandText = "SELECT title,pubyear,numpages,authors FROM books";
using (NpgsqlConnection conn = new NpgsqlConnection(connStr))
{
conn.Open();
using (NpgsqlCommand cmd = new NpgsqlCommand(CommandText, conn))
{
using (NpgsqlDataReader reader = 
cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
while (reader.Read())
{
books.Add(new Book
{
    Title = reader["title"].ToString(),
    PubYear = Convert.ToInt32(reader["pubyear"]),
    NumPages = Convert.ToInt32(reader["numpages"]),
    Authors = reader["authors"].ToString()
});
}
}
}
}
return books;
}
catch (NpgsqlException ex)
{
var dbex = new DataBaseException("Error en base de datos", ex);
Logger.WriteLog(dbex);
throw dbex;
}
catch (Exception ex)
{
var rex = new RuntimeException("Error grave consulte al administrador", ex);
Logger.WriteLog(rex);
throw rex;
}
}
}
}

La clase logger que se encargara de registrar las excepciones.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data.Common;
using Npgsql;

namespace PostException
{
public class Logger
{

public static void WriteLog(DataBaseException e)
{
Log(e.InnerException);
}

public static void WriteLog(RuntimeException e)
{
Log(e.InnerException);
}

static void Log(Exception e) {
try{
using (StreamWriter writer = new StreamWriter(
new FileStream("log.txt", FileMode.Append, FileAccess.Write, FileShare.ReadWrite)))
{
writer.WriteLine(string.Format("{0} | {1} | {2}", DateTime.Now,e.Source,e.Message));
writer.Flush();
writer.Close();
}
}catch(Exception ex){
throw new RuntimeException("No se pudo cargar el log",ex);
}
}
}
}

Por último la clase principal en donde usamos las excepciones personalizadas.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PostException
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Obteniendo la lista de libros");
try {
foreach (Book b in BooksDataManager.SelectAll()) {
Console.WriteLine("{0}",b.Title);
Console.WriteLine("{0}",b.Authors);
Console.WriteLine("{0}",b.NumPages);
Console.WriteLine("{0}",b.PubYear);
Console.WriteLine("+-----------------------------------------+");

}
}
catch (DataBaseException dbex)
{
Console.WriteLine(dbex.Message);
}
catch (RuntimeException ex)
{
Console.WriteLine(ex.Message);
}
}
}
}

Una vez creadas estas clases dentro del proyecto la estructura se verá más o menos así en MonoDevelop

Para ejecutar este programa siendo una aplicación de consola debemos de habilitar la salida en una terminal independiente en el menú Project del menú principal elegimos la opción Project properties donde nos aparece la siguiente ventana.

Ahí seleccionamos la opción Run on external console, ahora al ejecutar el programa el resultado se verá en una ventana terminal independiente como en la siguiente imagen que muestra el resultado sin ninguna excepción.

Sin embargo si ocurre una excepción relacionada con la base de datos se mostrará la salida como en la siguiente imagen.

Si hay una excepción en la aplicación se mostrará el resultado como en la siguiente imagen.

La técnica de custom exceptions permite la separación entre el código de flujo de la aplicación y el código de manejo de excepciones lo que hace la aplicación cumpla con un mecanismo mínimo de calidad y sea mucho más manejable, robusta y escalable.

Referencias acerca del uso del Garbage Collector en .NET

2011-03-21T12:21:00.000-07:00

Buscando referencias en cuanto al uso de los destructores en C# me encontré estos fragmentos del libro Advanced C# Programming de Paul Kimmel donde en el capítulo 1 pag 18 habla acerca de la destrucción no determinística y Garbage Collector, fragmento que copio tal cuál se encuentra en el libro:

C# uses non-deterministic destruction. The CLR implements a garbage collector that cleans up memory when objects are no longer used. This means that you don’t have to worry as much about destructors in C# as you do in C++ or Delphi.
The garbage collector will call the destructor for your objects when they are no longer needed. The destructor will call any Finalize method. You can force garbage collection by calling GC.Collect, but this is not a recommended process. The garbage collector suspends any running threads, which can cause performance problems. Besides, the garbage collector will do a good job of determining when to run.

De nuevo en el en el capítulo 3 pag 76, recalca la importancia de que no es una buena práctica, fragmento que copio tal cuál se encuentra en el libro

Control Dispose Methods C# is a .NET language. I state the obvious as a way to segue into a subject that may not be obvios. Languages like Object Pascal or C++ use deterministic construction and destruction. This means that the programmer is responsible for both creating and destroying objects.
.NET employs non-deterministic destruction.This means that the programmer is not responsible for destroying objects.The gargabe collector will clean up objects for you. As a result, you will write code that invokes the new operator, but there is no equivalent free operator.
NOTE: You can invoke the garbage collector explicitly by calling GC.Collect, but this is not a recommended practice.

Aunque la biblioteca de la universidad tiene la edición 2002 y no sé si en las ediciones actuales haya cambiado, considero que es interesante lo que menciona además que un amigo y compañero de trabajo me pregunto hace algunos años si era posible invocar a voluntad el Garbage Collector a lo cual respondí por lógica que sí porque ya había visto la clase System.GC y algo había leído algo al respecto pero en ese momento no sabía bien acerca de sus implicaciones y no había recordado la fuente.

Uso de Destructores en C#

2011-03-20T20:33:00.000-07:00

En lenguajes orientados a objetos como C#,C++ o Java los objetos tienen un ciclo de vida el cual inicia cuando se crea el objeto mediante un constructor y acaba cuando se termina el objeto mediante un destructor.
Por ejemplo con la palabra reservada new, llamamos al constructor de un
objeto del tipo router:


Router router = new Router();

El uso de constructores es igual en C# como lo es en C++ y Java, donde sino especificamos el constructor, el compilador se encarga de crearlo ya que una de sus responsabilidades es la llamada a un constructor el cual como un estándar tomado de C++ el constructor tiene el mismo nombre que la clase.
De igual forma la clase puede tener el constructor predeterminado sin argumentos, como un constructor personalizado, por ejemplo en el siguiente código:


Router router = new Router("Contabilidad");
Router router = new Router("Contabilidad",new byte[]{192,168,1,4});

En C# a diferencia de C++ existe el Garbage Collector (recolector de basura) que se encarga de destruir los objetos que fueron creados y ya no son utilizados, por lo que el programador no es responsable de liberar recursos asignando un destructor a cada objeto.

Sin embargo hay casos en C# donde los destructores son necesarios para objetos que hacen uso de recursos no administrados (unmanaged resources) como las conexiones hacia las bases de datos o el uso de archivos.
Los destructores a diferencia de los constructores no se heredan, no pueden recibir parámetros y no pueden sobrescribirse.
La sintaxis de un destructor es con el mismo nombre que el constructor solo se agrega una ~ como prefijo, como se muestra en el siguiente código:


public class Router{
~Router(){
}
}

Veamos un ejemplo del uso de destructores en una clase Router que implementa un método destructor


using System;
using System.IO;

namespace Samples{
 public class Router
 {
  public string Name{private set;get;}
  public byte[] IPNetwork{private set;get;}
  public Router(string name){
   Name = name;
   Console.WriteLine("{0} Creado {1}",Name,DateTime.Now);
   }
 public Router(string name,byte[] ipnet){
 Name = name;
 IPNetwork = ipnet;
 Console.WriteLine("{0} Creado {1}",Name,DateTime.Now);
 }

 ~Router(){
  Console.WriteLine("{0} Destruido {1}",Name,DateTime.Now);
 }

 }
}

A continuación el programa principal para ejemplificar los destructores


using System;
using System.Threading;

namespace Samples{
 public class DestructorSample{
 public static void Main(string[] args){

  Router router = new Router("Cordoba");
  Router router2 = new Router("Monterrey",new  
byte[]{10,3,0,0});
  Console.WriteLine("\n");
  //simulamos un proceso en ejecucción
  Console.WriteLine("Primer router {0}", router.Name);
  Working();
  Console.WriteLine("Segundo router {0}", router2.Name);
  Working();
 }

 public static void Working(){
  Console.Write("trabajando");
  for(int i = 1;i <= 10;i++){
   Console.Write(".");
  Thread.Sleep(500);
  }
  Console.WriteLine("\n");
 }
 }
}

En este ejemplo el código dentro del destructor imprime un mensaje en la consola lo cual es algo trivial, esto es importante ya que en la mayoría de la documentación que hablan acerca de destructores en C# señalan que deben usarse con extremo cuidado.Hay ciertas reglas acerca de su uso:

Se debe tener presente es nunca utilizar destructores en managed code (código manejado) ya que representa un problema de desempeño para el garbage collector, ya que a diferencia de C++ el objeto no es destruido inmediatamente cuando es ejecutado el destructor.

En lugar de destructores utilizar Close() o Dispose().

NUNCA poner código en el destructor que realice cambios críticos al ambiente o bien código que utilice recursos, es decir los destructores se usaron para liberar no para utilizar.

No se debe hacer referencia a otros objetos dentro del destructor.

Nunca llames a un constructor de forma directa, el garbage collector
lo invoca de forma automática, si se requiere liberar recursos de forma
determinística lo recomendable es usar la interfaz IDisposable.

Es posible invocar y controlar el Garbage Collector vía los métodos estáticos de la clase System.GC, pero no es recomendable ya que se activa para todas las aplicaciones que utilicen recursos en ese momento no únicamente para la aplicación que lo invoco, además que debemos de conocer los métodos no determinísticos para la liberación de memoria.
A continuación la salida del programa

Cambiando la resolución de pantalla de forma permanente en OpenSuse 11.3

2011-02-27T12:40:00.000-08:00

Pues teniendo desde hace un par de meses OpenSuse 11.3 en mí nueva portátil (Dell Inspiron 14), algo que ya había leído pero no había hecho era cambiar la resolución de la pantalla de forma permanente.
Ya que de forma predeterminada el sistema establecía la resolución 1366x768 resolución que para mostrar ciertas gráficas en proyectores no era apropiada, por lo que siempre cambiaba la resolución de forma manual a una resolución estándar de 1024x768, algo que en versiones anteriores de OpenSuse se realizaba con Sax2 y se conservaba después de reiniciar o apagar el equipo cosa que en esta versión no ocurre.

Leyendo en la documentación de OpenSuse encuentro que esta versión no incluye Sax2 ni sus derivados como (Sax2-vesa), por lo que ese cambio debe hacerse de forma programática.

El procedimiento se describe en este enlace .
A continuación pongo algunas anotaciones con imágnes en caso de que el enlace/post cambie y para que tenga manera de recordarlo.

Como root cambiamos al directorio /etc/X11/xorg.conf.d/
# cd /etc/X11/xorg.conf.d/

Sacamos una copia de seguridad del archivo 50-screen.conf
# cp 50-screen.conf 50-screen.conf.bak

Vemos las resoluciones soportadas en el menú "Preferencias del sistema" del inicio de KDE.

Editamos el archivo, agregando las siguientes líneas y colocando en primer lugar la resolución que necesitamos de forma permanente.
# vi 50-screen.conf
Section "Screen"
Identifier "Default Screen"
Device "Default Device"

##Doesn't help for radeon/radeonhd drivers;use magic in
##50-device.conf instead
Monitor "Default Monitor"

SubSection "Display"
modes "1024x768" "800x600" "640x480"
EndSubSection

EndSection

Reiniciamos el equipo para probar el cambio.

Diferencias entre C# DateTime.Now y DateTime.Today

2011-02-27T11:17:00.000-08:00

Hoy por la tarde haciendo un programa para enviar mensajes hacia un servidor me salió un error simple que después de cierto tiempo pude resolverlo y se debió más a un bloqueo de mi memoria que ha otro factor.
Resulta que uno de los requisitos en el programa era enviar como título del mensaje fecha, hora, minutos y segundos en los que cada mensaje se había generado.
Básicamente existía una clase mensaje con una propiedad DateCreated como en el siguiente código:


using System;

namespace Messages
{
 public class Message
 {
  public string Title{
   private set;get;
  }
  public DateTime DateCreated{
   get{ return DateTime.Today;}
  }
  public string Description{
   set;get;
  }
  private Message(){}
  public Message(string title)
  {
   Title = title;
  }
 }
}

Al crear el mensaje, el programa debía notificar con un aviso, indicando fecha, hora, minutos y segundos, algo así como lo siguiente:

“Mensaje recibido 24-02-2011 a las 22:04:12”

Sin embargo el mensaje lo notificaba de la siguiente forma:

“Mensaje recibido 24-02-2011 a las 22:04:00 ”

El código principal era más o menos asi


using System;
using Messages;

namespace Messages {
class Program {
public static void Main(string[] args) {
 Message msg = new Message("Sistemas de control");
 msg.Description = "Los sistemas de control son de lazo abierto ó lazo cerrado.";
 Console.WriteLine("Mensaje creado en {0:dd-MM-yyyy hh:mm:ss}",msg.DateCreated);
 Console.ReadLine();
} 
 }
}

Al revisar el código descubrí que al usar la estructura DateTime utilice la propiedad Today en lugar de la propiedadNow .
Ambas propiedades obtienen el valor de la fecha actual, la diferencia es que en Today la parte correspondiente al tiempo se establece en 00:00:00.

al cambiar la propiedad DateCreated como en la siguiente línea:


public DateTime DateCreated
{
   get{ return DateTime.Now;}
}

El problema se soluciono y aquí el resultado.

Liberación del número 18 de la revista ATIX

2011-02-03T15:24:00.000-08:00

El día 31 de Enero se público en línea un nuevo ejemplar de la revista ATIX, el sitio para la descarga es http://atix.opentelematics.org/, este número contiene un tutorial introductorio al uso de expresiones Lambda con C# usando mono.

El enlace del tutorial en PDF para descarga aquí.

El código fuente en un proyecto de consola de MonoDevelop para descarga se encuentra aquí

Operadores a nivel de bits en C# (bitwise operators)

2011-01-14T06:52:00.000-08:00

Además de los operadores condicionales lógicos y de relación C# cuenta con operadores a nivel de bits (bitwise operators o logical operators) que permiten realizar operaciones con las representaciones binarias de las variables que internamente utiliza la computadora, esto es útil en ciertos casos donde se requiere interactuar directamente con el hardware o utilizar una variable entera como un arreglo de bits donde por ejemplo un tipo short representaría un arreglo de bits con una longitud de 16 valores y cada bit podría ser utilizado como si fuera un valor booleano 1 igual true y 0 igual a false.
Los tipos de datos donde usualmente aplican estos operadores son: los numéricos y las enumeraciones.
La siguiente tabla muestra los tipos numéricos, su longitud en bytes y su valor en decimal.

Así por ejemplo si tenemos valores decimales representados en variables byte (8 bits hasta 255 en decimal)

byte a = 22;
byte b = 33;

Internamente su representación en binario es:

22 = 00010110
33 = 00100001

si utilizamos variables de tipo short (16 bits hasta 65,535)

short c = 666;
short d = 6666;

su representación en binario es:

666 = 00000010 10011010
6666 = 00011010 00001010

Así con cada tipo numérico siempre agrupando las cadenas de bits de 8 en 8.
La siguiente tabla muestra los operadores bitwise, su significado y su resultado.

+----------+-------------+-----------
| Operador | Significado | Resultado
+----------+-------------+--------------------------
& AND Si ambos bits son 1 el resultado es 1
Si cualquiera de ambos bits es 0 el resultado es 0
----------------------------------------------------
| OR Si ambos bits son 0 el resultado es 0
Si cualquiera o ambos bits son 1,el resultado es 1
----------------------------------------------------------------------
^ Exclusive OR Si ambos bits son iguales el resultado es 0
Si un bit es 0 y el otro es 1,el resultado es 1.
--------------------------------------------------------------------------
~ NOT Si un bit es 1 es resultado es 0 o viceversa.
--------------------------------------------------------------------------
<< shift left Cada bit es recorrido n posiciones a la izquierda
----------------------------------
>> shift right Cada bit es recorrido n posiciones a la derecha
--------------------------------------------------------------------------

Un ejemplo de la utilización de estos operadores con enteros:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BitwiseCalc
{
class BitwiseCalc
{
delegate int DelBinOp(int a,int b);
delegate int DelUriOp(int a);
static void Main(string[] args)
{
    ushort option = 0;
    do {
    option = Menu();
    switch(option){
    case 1:
        Console.WriteLine("\t\t[ & AND ]\n\n");
        BinaryOp((a, b) =>a & b);
        break;
    case 2:
        Console.WriteLine("\t\t[ | OR ]\n\n");
        BinaryOp((a,b) => a | b);
        break;
    case 3:
        Console.WriteLine("\t\t[ ^ Exclusive OR ]\n\n");
        BinaryOp((a,b) => a ^ b);
        break;
    case 4:
        Console.WriteLine("\t\t[ ~ NOT ]\n\n");
        UnaryOp(a => ~a);
        break;
    case 5:
        Console.WriteLine("\t\t[ << Shift Left ]\n\n");
        ShiftOp((a,b) => a << b);
        break;
    case 6:
        Console.WriteLine("\t\t[ >> Shift right ]\n\n");
        ShiftOp((a,b) => a >> b);
        break;
                
        }
    } while (option > 0);

}

static ushort Menu() {
ushort option = 0;
Console.WriteLine("\t\tOPERADORES BITWISE\n\n");
Console.WriteLine("1. & AND");
Console.WriteLine("2. | OR");
Console.WriteLine("3. ^ Exclusive OR");
Console.WriteLine("4. ~ NOT");
Console.WriteLine("5. << Shift Left");
Console.WriteLine("6. >> Shift right");
Console.WriteLine();
Console.WriteLine("0. Salir\n\n");
Console.Write("Elija opción: ");
try
{
    option = Convert.ToUInt16(Console.ReadLine());
}
catch (FormatException) {
    Console.WriteLine("Opción no válida");
    option = 0;
}
return option;
}

static void BinaryOp(DelBinOp del) {
int op1,op2,resp;
Console.Write("Teclee el primer operador: ");
op1 = Convert.ToInt32(Console.ReadLine());
Console.Write("Teclee el segundo operador: ");
op2 = Convert.ToInt32(Console.ReadLine());
resp = del(op1,op2);
Console.WriteLine();
DisplayBinary(op1);
DisplayBinary(op2);
Console.WriteLine("----------------------------");
DisplayBinary(resp);
Pause();
}

static void ShiftOp(DelBinOp del)
{
int op1, op2,resp;
Console.Write("Teclee el primer operador: ");
op1 = Convert.ToInt32(Console.ReadLine());
Console.Write("Teclee las posiciones: ");
op2 = Convert.ToInt32(Console.ReadLine());
resp = del(op1, op2);
Console.WriteLine();
DisplayBinary(op1);
Console.WriteLine("-----------------------");
DisplayBinary(resp);
Pause();
}

static void UnaryOp(DelUriOp del) {
int op1,resp;
Console.Write("Teclee el primer operador: ");
op1 = Convert.ToInt32(Console.ReadLine());
resp = del(op1);
DisplayBinary(op1);
Console.WriteLine("-----------------------");
DisplayBinary(resp);
Pause();
}

static void DisplayBinary(int i) {
Console.WriteLine("{0} = {1}",i, Convert.ToString(i, 2).PadLeft(32,'0'));
}

static void Pause() {
Console.Write("\n\nPresiona cualquier tecla para continuar.");
Console.Read();
}

}
}

Compilamos y ejecutamos el programa

mcs BitwiseCalc.cs

mono BitwiseCalc.exe

Al ejecutarlo veremos los siguientes resultados:

Otro uso común de estos operadores esta en las enumeraciones como en el caso de los valores de las enumeraciones FileMode y FileAccess del siguiente código.


FileStream outStream = new FileStream("log.txt",FileMode.Append | FileMode.Create,
FileAccess.Read | FileAccess.Write,FileShare.Read);
StreamWriter sw = new StreamWriter(outStream);
sw.WriteLine("Archivo de log");
sw.Close();

Descarga el código fuente

Notas acerca de los elementos de la comunicación en redes de datos

2011-01-04T11:39:00.000-08:00

La comunicación comienza con un mensaje o información que debe enviarse de un individuo o de un dispositivo a otro. Aunque hay muchos métodos de comunicación la comunicación tiene básicamente tres partes, que son:

La fuente del mensaje o el emisor que pueden ser personas o dispositivos.

El destino del mensaje o el receptor quien recibe el mensaje y lo interpreta.

El canal que consiste del medio en el cual se transmite el mensaje.

En el caso de las redes de datos en vez de enviar todo el mensaje por el canal y esperar hasta que el receptor lo interprete de principio a fin, se realiza una estrategia llamada segmentación donde el mensaje se divide en pequeñas partes y cada una de esas partes es enviada al emisor hasta completar el mensaje, esto trae dos ventajas, la primera es que se pueden enviar diferentes mensajes por el mismo canal ya que se pueden intercalar las partes de diferentes mensajes dentro del canal evitando la saturación por un mensaje de tamaño considerable y la segunda es que no todos los mensajes van desde la misma fuente al mismo destino si una vía dentro del canal se congestiona o se cae, las partes pueden tomar vías alternas y además si algunas partes del mensaje no llegan a su destino esas partes pueden ser retransmitidas.

Aunque la segmentación le agrega mayor complejidad y consumo de tiempo al proceso de la comunicación en las redes de datos esto asegura el correcto envió y recepción de mensajes. Varios tipos de dispositivos a través de la red participan en este proceso, los componentes visibles y los componentes no visibles. Los componentes visibles de la red de datos son los elementos de hardware que participan en la red como laptops, PC's, el cableado y los switches y los elementos no visibles se refiere al software como los procesos de servicios de los programas de comunicación que se ejecutan en los dispositivos de red, estos servicios responden a una petición como los servicios de emaill o de web, aunque son menos evidentes son críticos para la operación de las redes ya que se encargan de la respuesta a las solicitudes de los mensajes.

Los dispositivos de red que están cerca del usuario se conocen como dispositivos finales estos dispositivos son la interfaz entre la red humana y la red de comunicación de datos. En el contexto de las redes de datos un dispositivo final está referido como un host, ya que es tanto como el emisor o el receptor de los mensajes transmitidos a través de la red, un host se distingue de otro dentro de la red mediante su dirección. En las redes modernas un host actúa tanto como cliente, como servidor o como ambas cosas esto lo determina el tipo de software que tenga instalado.

Por ejemplo si una PC tiene instalado un servidor de correo electrónico (como postfix) y de hosteo de páginas Web (como apache) entonces está habilitada como servidor tanto de correo electrónico como de páginas web y sí tiene además instalado software de cliente de correo (como thunderbird) y de navegador web (como firefox) entonces también está habilitada como cliente de correo electrónico y de páginas web.

Además de los dispositivos finales en la red de datos existen los dispositivos intermediarios que proporcionan la conectividad y todo el trabajo para asegurarse que los datos fluyan dentro de la red. Estos dispositivos conectan los hosts a la red y la red o redes de hosts para formar una interred o internetwork como es el caso de Internet, ejemplos de dispositivos intermediarios son:

Dispositivos de acceso a la red (Hubs,switches, wireless access point)

Dispositivos interred (routers)

Servidores de comunicación y los modems

Dispositivos de seguridad (firewalls)

Estos dispositivos usan la dirección de host (host address) en conjunción con la información de las redes interconectadas para determinar la trayectoria de los mensajes dentro de la red, los procesos que se ejecutan en estos dispositivos realizan las siguientes funciones:

Generan y retransmiten las señales de datos.

Mantienen la información acerca de las rutas existentes en la red.

Notifican a otros dispositivos de los errores o de las fallas de comunicación.

Si hay un error de enlace enviar la señal en rutas alternas.

Clasifican los mensajes acorde a las prioridades de QoS.

Permite o rechazan el flujo de datos basados en la configuración de seguridad.

Las redes modernas usan principalmente tres tipos de medio para la interconexión de dispositivos, esos medios son:

Cables metálicos

Cables de fibra óptica

La transmisión por ondas (wireless)

La codificación de la señal es diferente en cada tipo de medio, en los medios metálicos la señal es codificada mediante impulsos eléctricos, en los medios de fibra óptica es codificada como impulsos de luz infrarroja o blanca y en la transmisión wireless es codificada como patrones de ondas electromagnéticas.

Notas acerca de direcciones IP y la dirección IP en .NET

2010-11-30T19:57:00.000-08:00

Las direcciones IP se dividen en tres clases generales (A, B, C) y dos especializadas que son utilizadas para propósitos experimentales (D, E). Las direcciones IP se representan por cuatro octetos u ocho bits, separados por puntos, así como la dirección MAC nos proporciona identificación, la dirección IP nos da ubicación.

Cada dirección IP se compone de dos campos un campo de red y un campo de host. El tamaño de cada uno de esos campos varía según la clase:
Para la clase A tenemos el primer octeto para identificar la red y los restantes tres para identificar al host.
Para la clase B tenemos los dos primeros octetos para identificar la red y los dos restantes para identificar al host.
Para la clase C tenemos los tres primeros octetos para identificar al host y el último octeto para identificar al host.
El primer octeto en decimal siempre nos indica la clase a la que pertenece una red, dependiendo de su valor en decimal dentro de los siguientes rangos:

0 a 127 es clase A

128 a 191 es clase B

192 a 223 es clase C

Aquí si observamos el inicio del rango es par y el final es impar.
En la clase A, la dirección IP 127.0.0.1 se reserva como dirección de loopback.
Existen además tipos reservados de IP como por ejemplo si los octetos de host son puestos en 0 (cero) esa dirección IP identifica a la red o si todos los octetos de host son puestos en 1 o 255 en decimal esa dirección IP es una dirección IP de Broadcast.

Una manera de identificar los tipos de red es buscar la posición del bit 0 (cero) dentro del primer octeto, la reglas son:
Si el primer bit es 0 (cero) la dirección es clase A, si el segundo bit es 0 (cero) la dirección es clase B, si el tercer bit es 0 (cero) entonces es clase C. Como en el siguiente esquema:


clase A  | 0 1 1 1 1 1 1 1
---------+-----------------
clase B  | 1 0 1 1 1 1 1 1 
---------+----------------
clase C  | 1 1 0 1 1 1 1 1

IP local en .NET

.Net tiene diversas clases dentro del ensamblado System.Net para el manejo de direcciones IP mostraremos el uso básico de esas clases para obtener la dirección o las direcciones IP de la máquina en donde se ejecute el siguiente listado.


using System;
using System.Net;
using System.Net.Sockets;

namespace Samples {
class Program {
public static void Main(string[] args)  {
 try {
    IPHostEntry ipinfo = Dns.GetHostByName(Dns.GetHostName());
    int i = 0;
    if(ipinfo.AddressList.Length > -1)    {
 foreach(IPAddress ip in  ipinfo.AddressList){
 byte[] b = ip.GetAddressBytes();
Console.WriteLine("IP[{0}] = {1}.{2}.{3}.{4}",i,b[0],b[1],b[2],b[3]);
i++;
     }
Console.WriteLine("LoopBack =\t{0} ",IPAddress.Loopback);
Console.WriteLine("Broadcast =\t{0} ",IPAddress.Broadcast);
 } 
else
 Console.WriteLine("Sin IP");
  }
 catch(SocketException se){
 Console.WriteLine(se.Message);
  }
 catch(ArgumentException sa){
 Console.WriteLine(sa.Message);
  }
 catch(Exception e){
 Console.WriteLine(e.Message);
  }
  }
    }
}

Para acceder a las clases de red, primeramente hacemos referencia a los ensamblados


using System.Net;
using System.Net.Sockets;

En la siguiente línea


IPHostEntry ipinfo = Dns.GetHostByName(Dns.GetHostName());

Utilizamos el método GetHostByName de la clase Dns el cual nos devuelve un objeto IPHostEntry del cual utilizamos la propiedad AddressList que es una lista de objetos del tipo IPAddress que representa cada IP de la máquina en caso de tener más de una interface de red y que recorremos con un ciclo utilizando el método GetAddressBytes() para obtener los octetos como un arreglo.


foreach(IPAddress ip in  ipinfo.AddressList){
byte[] b = ip.GetAddressBytes();
}

Por último utilizamos las propiedades estáticas IPAddress.Loopback y IPAddress.Broadcast para imprimir la dirección Loopback y de Broadcast respectivamente.
Al compilar y ejecutar el programa obtendremos algo similar a lo que se muestra en la siguiente imagen:

Descarga el código fuente

Notas de la certificación CCNA de Cisco

2010-11-25T17:45:00.000-08:00

Notas de las primeras clases del módulo Aspectos básicos de Networking de CCNA Exploration 4.0.

La problemática básica de toda red está dividida en 3 aspectos:

La interconexión

La colisión de paquetes

El ancho de banda

Debido a la distancia en la conexión física la señal se debilita por lo que es necesario poner un dispositivo en la capa física que ayude a propagar la señal, este dispositivo en capa física se conoce como Hub.
El hub resuelve el problema de la interconexión en cuanto a la propagación de la señal, pero no logra evitar las colisiones debido a que también propaga el residuo de la trama y las colisiones se producen cuando chocan dos tramas. El hub solo reproduce bit a bit y no es capaz de ver la longitud de trama que son 64 bits por lo que no distingue cuando es una trama completa y cuando un residuo de trama.
El tamaño del dominio de colisión es el número de computadoras conectadas a un medio físico y es todo aquel dispositivo que puede verse afectado por una colisión.
A nivel de capa 1 el segmento de red es el cable físico y el dispositivo para segmentar es el hub, si se extiende el cable se extiende también la colisión.

El switch es un dispositivo de capa 2 y hace lo mismo que el hub pero tiene una tabla de conmutación y además es capaz de revisar la longitud de la trama de 64 bits y si es menor a 64 bits elimina la trama por lo que elimina el dominio de colisión.
Todo dispositivo que des encapsule de capa 1 a capa 2 detiene el dominio de colisión y todo dispositivo de capa 2 que des encapsule a capa tres detiene el dominio de broadcast.
La diferencia entre un brigde y un switch es que hacen lo mismo pero el switch lo hace en base a hardware y el brigde lo hace en base a software.
La segmentación en capa 2(a nivel de switches) incluye los dispositivos de capa 1(a nivel de hubs), esta segmentación hace más pequeño el dominio de colisión.
Lo único que no puede detener el switch es el dominio de broadcast, un dominio de broadcast es hasta a donde puede llegar el broadcast.

El dominio de broadcast solo se puede detener en capa tres y a ese nivel trabajan los routers que tienen capacidades para detener el dominio de broadcast y las capacidades de los dispositivos en capas inferiores.
Es decir un router detiene las colisiones y destruye los paquetes de broadcast, además puede diferenciar si es una red WAN o una red LAN.
La segmentación en capa 3 incluye dispositivos de capa 2 (switches) y de capa 1 (hubs) y esta segmentación hace más pequeño el dominio de broadcast.
El switch trabaja con dirección MAC y el router con dirección IP, para sacar el ancho de banda de cada PC la formula es el ancho de banda del medio por el tamaño del dominio de colisión.

Ancho de banda = capacidad del medio (mbps)/tdc

Cada puerto del switch o cada interface del switch es un dominio de colisión.
En resumen:

El hub manipula bits

El switch manipula tramas

El router manipula paquetes

La dirección MAC son de 48 bits que representan en Hexadecimal.

La dirección MAC nos proporciona identificación.

Lecturas de ingeniería de software

2010-11-18T15:34:00.000-08:00

El día 19 de noviembre de 2010 dentro del grupo de procesos y estándares para el desarrollo de software se tendrá una lectura acerca de cada una de las posturas de cada autor o empresa que están publicadas en este sitio http://www.semat.org dedicado a la ingeniería de software.

Las posturas se encuentran en el enlace de http://www.semat.org/bin/view/Main/WorkshopPositions

En mí caso me toca leer las posturas de las empresas Ericsson y Fujitsu.

En ese sitio también hacen mención de la muerte de Watts Humphrey un personaje importante en la ingeniería de software, sin duda una lamentable perdida.

Uso de unchecked en C#

2010-10-31T15:17:00.000-07:00

En este post mencione sobre algunos ejemplos que tome del libroJava Puzzlers: Traps, Pitfalls, and Corner Cases de Joshua Bloch y Neal Gafter publicado por Addison Wesley Professional en el año 2005 donde vienen curiosidades y trucos acerca de la programación con Java, Los siguientes ejemplos se encuentran en el libro y requieren el uso en C# de los operadores checked y unchecked para controlar la comprobación de overflow en operaciones aritméticas y conversiones.

Siempre que trabajemos con operaciones numéricas o con conversiones en nuestros programas hay posibilidades de que suceda un overflow (desbordamiento) cuando el resultado de dicha operación sobrepase la capacidad mínima o máxima de la variable que usemos para contener ese resultado.
Siempre que trabajemos con operaciones numéricas o con conversiones en nuestros programas hay posibilidades de que suceda un overflow (desbordamiento) cuando el resultado de dicha operación sobrepase la capacidad mínima o máxima de la variable que usemos para contener ese resultado.
Los siguientes listados ejemplifican el uso de estos operadores.

Listado 1


using System;
namespace Samples
{
public class Puzzle4
{
public static int Main(string[] args)
{
    long resp = 0;
    try
    {
     
 const long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000;
 const long MILIS_PER_DAY = 24 * 60 * 60 * 1000;   
 resp = (MICROS_PER_DAY / MILIS_PER_DAY);   
     
    }
catch (OverflowException e)
{
    Console.WriteLine(e.Message);
}
Console.WriteLine("{0}", resp);
return 0;
}
}
}

Listado 2


using System;

namespace Samples{
public class Puzzle6{
public static int Main(string[] args){
    try
    {
Console.WriteLine((int)(char)(byte)-1); 
}
catch (OverflowException e)
{
    Console.WriteLine(e.Message);
}
 return 0;
}
}
}

En el primer caso el compilador envía el siguiente error:Puzzle4.cs(12,50): error CS0220: The operation overflows at compile time in checked mode

Para el segundo caso el mensaje es similar
Puzzle6.cs(10,30): error CS0221: Constant value `-1' cannot be converted to a `byte' (use `unchecked' syntax to override) Compilation failed: 1 error(s), 0 warnings

Debido a que en los dos listados el overflow puede ser comprobado en tiempo de compilación, en C# de forma predeterminada todo el código asignado a constantes es comprobado aunque este dentro de un bloque unchecked, y para las variables si el overflow ocurre en tiempo de ejecución el programa lanza una OverflowException excepto que sea suprimida usando unchecked.

Por lo tanto para compilar los listados, debemos de usar un bloque unchecked en la asignación de las siguientes variables en el primer listado:


 unchecked{
 const long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000;
 const long MILIS_PER_DAY = 24 * 60 * 60 * 1000;   
 resp = (MICROS_PER_DAY / MILIS_PER_DAY);   
     }

Y un bloque similar en el segundo listado.


unchecked
        {
Console.WriteLine((int)(char)(byte)-1);
    }

El uso de unchecked en el primer listado ocasiona que no se produzca una excepción aunque ocurra el overflow esto siempre ocasiona que los valores sean truncados, por lo que el resultado de la ejecucción de este programa no es lo esperado.

Para solucionar por completo el código del listado 1 debemos agregar el caracter L al final del primer término (en este ejemplo el número 24), así toda las subsecuentes expresiones seran de tipo long.
El bloque de código se muestra a continuación.


const long MICROS_PER_DAY = 24L * 60 * 60 * 1000 * 1000;
 const long MILIS_PER_DAY = 24L * 60 * 60 * 1000;   
 resp = (MICROS_PER_DAY / MILIS_PER_DAY);

El código final del listado 1 es


using System;
namespace Samples
{
public class Puzzle4
{
public static int Main(string[] args)
{
    long resp = 0;
    try
    {
     unchecked{
 const long MICROS_PER_DAY = 24L * 60 * 60 * 1000 * 1000;
 const long MILIS_PER_DAY = 24L * 60 * 60 * 1000;   
 resp = (MICROS_PER_DAY / MILIS_PER_DAY);   
     }
    }
catch (OverflowException e)
{
    Console.WriteLine(e.Message);
}
Console.WriteLine("{0}", resp);
return 0;
}
}
}

El código final del listado 2 es


using System;

namespace Samples{
public class Puzzle6{
public static int Main(string[] args){
    try
    {
        unchecked
        {
Console.WriteLine((int)(char)(byte)-1);
    }
}
catch (OverflowException e)
{
    Console.WriteLine(e.Message);
}
 return 0;
}
}
}

La salida al ejecutar el listado 1 es

y la salida al ejecutar el listado 2 es

Descarga el código fuente

Expresiones Lambda (Lambda Expressions) con C#

2010-10-25T23:20:00.000-07:00

Las expresiones lambda provienen del cálculo lambda (lambda calculus) desarrollado por Alonzo Church en los años 1930’s como una notación para representar todas las funciones computables equivalentes a una máquina de Turing, todos los lenguajes funcionales pueden ser vistos como una variante sintáctica del cálculo lambda.
Las expresiones Lambda son útiles para sintetizar funciones con pocos parámetros que regresan algún valor, esta expresión consiste básicamente en una regla de sustitución que expresa tal cual una función o sea un mapeo de los elementos del conjunto dominio a los elementos de un codominio por ejemplo en la siguiente expresión:

cuadrado : integer → integer donde cuadrado(n) = n²

Aunque C# no utiliza los símbolos de la notación matemática lambda, el operador lambda es => que significa “tiende a” o “va hacia a”, la estructura de una expresión lambda en C# es:

(Argumentos de entrada) => (salida al procesarlos)

Veamos algunos ejemplos:


using System;
namespace Samples{
public class Lambda
{
delegate int a(int b, int c);
public static int Main(string[] args)
{
    Print(5, 5, (a, b) => a + b);
    Print(4, 2, (x, y) => x * y);
    Print(6, 6, (a, b) => a + b);
    Print(144, 666, (x, y) => x * y);
    return 0;
}

static void Print(int a, int b, a del)
{
    Console.WriteLine("Imprimiendo: {0}",del(a, b));
}
}
}

La salida del programa es la siguiente imagen

Ahora un ejemplo con funciones estadísticas:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Samples
{
class Program
{
delegate double DelegateToApply(double[] data);
static void Main(string[] args)
{
    double[] data = {
147.8,137.4,125.2,141.1,145.7,
119.9,133.3,142.3,138.7,125.7,
142.0,130.8,129.8,141.2,134.9,
125.0,128.9,142.0,118.6,133.0,
151.1,125.7,126.3,140.9,138.9
    };
Console.WriteLine("\n CONJUNTO DE DATOS");
Printf(data, 5);
Console.WriteLine("\n Reporte:\n");
Console.WriteLine(" Media = {0}", GetOperation(data, d =>
{
    double sum = 0.0;
    for (int i = 0; i < data.Length; i++)
        sum += data[i];
    return sum / data.Length;
}));
Console.WriteLine(" Máximo = {0}", GetOperation(data, d =>
{
    double min = data[0];
    for (int i = 1; i < data.Length; i++)
        if (data[i] < min)
            min = data[i];
    return min;
}));
Console.WriteLine(" Mínimo = {0}", GetOperation(data, d =>
{
    double max = data[0];
    for (int i = 1; i < data.Length; i++)
        if (data[i] > max)
            max = data[i];
    return max;
}));
Console.WriteLine("Presione cualquier tecla");
Console.Read();
}


static double GetOperation(double[] data, DelegateToApply del)
{
    return del(data);
}

static void Printf(double[] entries, int entrywidth)
{
    int size = entrywidth;
    for (int i = 0; i < entries.Length; i++)
    {
        Console.Write(" " + PadString(entries[i].ToString(), size));
        if ((i + 1) % entrywidth == 0)
            Console.WriteLine();
    }
}

static string PadString(string entry, int size)
{
    StringBuilder buf = new StringBuilder(entry);
    int extra = size - entry.Length;
    for (int i = 0; i < extra; i++)
        buf.Append(" ");
    return buf.ToString();
}
}
}

la salida de este ejemplo es la siguiente imagen

Es importante saber que es el tipo delegate que dicta el tipo de los parámetros de entrada y de salida.

Descarga el código fuente

Conversiones y curiosidades acerca de C#

2010-10-03T23:36:00.000-07:00

En el libro Java Puzzlers: Traps, Pitfalls, and Corner Cases de Joshua Bloch y Neal Gafter publicado por Addison Wesley Professional en el año 2005 encontré ciertas curiosidades y trucos acerca de la programación en Java que me llamaron la atención, los autores explican la razón de tales escollos por lo que tome algunos ejemplos del libro para programarlos con C# y ver si obtendría los mismos resultados que sus contrapartes en Java.

Aquí algunos ejemplos del libro con las mismas preguntas, la diferencia únicamente es la implementación de Java a C#.

1-. En el siguiente programa ¿Es en todos los casos seguro que el método IsOdd determine correctamente si el número entero es par o no?


using System;

namespace Samples
{
public class Puzzles
{
public static int Main(string[] args)
{
    var i = 0;
    if (args.Length == 1)
    {
      if (IsNumber(args[0]))
      {
      i = Convert.ToInt32(args[0]);
      Console.WriteLine("{0} {1}", i, (IsOdd(i) ? "Es impar" : "Es par"));
      }
      else Console.WriteLine("No es un número");
    }
    else
        Console.WriteLine("usar: Puzzle1 [number]");
    return 0;
}

static bool IsOdd(int i)
{
    return i % 2 == 1;
}
static bool IsNumber(string s)
{
    if (s.IndexOf("1") != -1 ||
    s.IndexOf("2") != -1 ||
    s.IndexOf("3") != -1 ||
    s.IndexOf("4") != -1 ||
    s.IndexOf("5") != -1 ||
    s.IndexOf("6") != -1 ||
    s.IndexOf("7") != -1 ||
    s.IndexOf("8") != -1 ||
    s.IndexOf("9") != -1 ||
    s.IndexOf("0") != -1)
    return true;
    return false;
}
}
}

2-.¿Qué valor imprime el siguiente programa?


using System;

namespace Samples
{
public class Puzzle2
{
 public static int Main(string[] args)
 {
    Console.WriteLine(12345 + 5432l);
    return 0;
 }
}
}

3-. ¿Cuál es el resultado del siguiente programa?


using System;

public class Puzzle3
{
public static int Main(string[] args)
{
    char x = 'X';
    int i = 0;
    Console.Write(true ? x : 0);
    Console.Write(false ? i : x);
    return 0;
}
}

Analicemos cada uno de los ejemplos.

Ejemplo 1

Observaciones Al ejecutar el programa y pasarle un número entero como argumento desde la línea de comandos al parecer el programa determina si ese número es par o no, como en las siguientes imagen.

Pero el método que determina si el número es par o impar falla al pasarle un número negativo par o impar, esto siendo que toma como parámetro un entero y la mitad de los valores del tipo entero son negativos, el método supone que los residuos son únicamente positivos siendo que cuando la operación del residuo regresa un número que no es cero conserva el signo del dividendo.

La solución entonces es cambiar el método para que la comparación en vez de quedar igual a uno cambie a diferente a cero


static bool IsOdd(int i)
{
    return i % 2 != 0;
}

La siguiente imagen nos muestra el resultado:

Ejemplo 2

Observaciones Este ejemplo se refiere a una mala práctica de programación, si examinamos el código puede que no nos percatemos que el último digito del segundo sumando en lugar de ser el número uno (1) es la letra l (ele) minúscula, por lo que una de las buenas prácticas de programación señaladas en el libro es no utilizar la letra l (ele) minúscula para indicar un valor numérico de tipo long o como variable.


Console.WriteLine(12345 + 5432l);

En todo caso el compilador de C# nos lanza la advertencia al compilar el programa,


Puzzle2.cs(9,34): warning CS0078: The 'l' suffix is easily 
confused with the digit '1' (use 'L' for clarity)
Compilation succeeded - 1 warning(s)

que nos recomienda usar siempre la letra mayúscula para evitar confusiones, como se muestra en la siguiente imagen.

Ejemplo 3

Observaciones si examinamos el código del programa, al ejecutarlo debería de imprimir XX o sea dos veces el carácter ‘X’, un carácter por cada expresión por expresión, sin embargo al ejecutar el programa imprime 8888 como en la siguiente imagen:

Esto se debe a ciertas reglas del operador ternario u operador condicional (condicional operator) donde el primer operando debe ser de tipo bool que se cumple en el caso de ambas expresiones, la diferencia está en el segundo y tercer operador donde las reglas son:

Si los dos operadores son del mismo tipo la expresión devuelve ese tipo.

Si hay una conversión implícita del segundo al tercero pero no del tercero al segundo entonces la expresión devuelve el tipo del tercer operador.

Si hay una conversión implícita del tercero al segundo pero no del segundo al tercero entonces la expresión devuelve el tipo del segundo operador.

En el ejemplo 3 en la primera expresión existe la conversión implícita de char a int por lo que valor de la expresión es de tipo int y a imprimir es de tipo carácter se cumple la primera regla y en la segunda expresión no existe conversión implícita de int a char por lo se cumple la tercera regla.

En ambos casos es el equivalente de


Console.Write((int)x);

Para eliminar la confusión cambiemos el código a una conversión explicita:


using System;

public class Puzzle3_cast{
 public static int Main(string[] args){
  char x = 'X';
  int i = 0;
  Console.Write(true ? x : (char)0);
  Console.Write(false ? (char)i : x);
  Console.Write(Environment.NewLine);
  return 0;
 }
}

El resultado es el esperado como se muestra en la siguiente imagen:

Descarga el código fuente

Libros Gratis sobre Bases de Datos

2010-09-30T22:14:00.000-07:00

Buscando bibliografía en Internet acerca de PostgreSQL, encontré esta página con enlaces para descargar libros electrónicos de sobre PostgreSQL y otras bases de datos.

http://www.database-books.us/
El enlace directo hacia los libros de PostgreSQL es
http://www.database-books.us/postgresql.php

Trabajando con Store Procedures PL/pgSQL en PostgreSQL

2010-09-19T21:23:00.000-07:00

Los lenguajes de procedimientos (procedural languages) han extendido la funcionalidad de las bases de datos proporcionando al lenguaje SQL cierto flujo de control similar al de un lenguaje de programación.
Cada fabricante tiene su propia implementación de un lenguaje de procedimiento basado en SQL, así Microsoft SQL Server tiene Transact-SQL, Oracle tiene PL/SQL y así sucesivamente una lista de bases de datos con su correspondiente lenguaje de procedimiento.
En el caso de PostgreSQL se tienen varios lenguajes que pueden usarse como lenguajes de procedimiento entre ellos tenemos a PL/Tcl, PL/Perl, PL/Python,C y como opción predeterminada PL/pgSQL.

Las ventajas de ejecutar funciones del lado del servidor o Store Procedures con PL/pgSQL son las siguientes:

Extensibilidad PL/pgsql es como un lenguaje de programación incluye la asignación y evaluación de variables y la posibilidad de hacer iteraciones y cálculos más complejos que con SQL.

Seguridad Ayuda a evitar ciertos ataques con SQL Injection ya que al utilizar parámetros evita la construcción de comandos SQL utilizando la concatenación de cadenas.

Rapidez Son ejecutados más rápidamente que las consultas SQL individuales ya que después de la primera ejecución el plan de ejecución se mantiene en memoria y el código no tiene que ser analizado ni optimizado nuevamente.

Programación modular similar a los procedimientos y funciones en los lenguajes de programación, lo que evita que se tengan planas de sentencias SQL.
Reutilización de código una función puede ejecutarse dentro de distintos Store Procedures.

Rendimiento un Store Procedure puede contener decenas de sentencias SQL que son ejecutadas como una sola unidad de golpe, a diferencia de las sentencias SQL individuales donde hay que esperar a que cada una sea procesada.

Mediante los siguientes ejemplos mostraremos el uso de Store Procedures utilizando PL/pgSQL.

Creamos una base de datos de ejemplo llamada Catalogs con el siguiente comando desde el Shell.


$ createdb Catalogs

Revisamos los lenguajes de procedimiento instalados en la base de datos, revisamos que PL/pgSQL se encuentre instalado con el siguiente comando.


$ createlang -l Catalogs

Si no se encuentra, entonces ejecutamos el siguiente comando para instalarlo, esto siempre como administrador del servidor:


$ createlang –U postgres plpgsql Catalogs

Si está instalado entonces abrimos un editor de texto y creamos un archivo llamado catalogs.sql donde escribiremos los comandos para crear las tablas de ejemplo y los Store Procedures para administrar los registros de cada una de las tablas.

Para la creación de las tablas escribimos lo siguiente:


CREATE TABLE Countries(
idcountry char(3) NOT NULL PRIMARY KEY
,name varchar(250) NOT NULL
,created timestamp DEFAULT NOW() NOT NULL
);

CREATE TABLE States(
idstate serial NOT NULL PRIMARY KEY
,name varchar(250) NOT NULL
,idcountry varchar(3) NOT NULL REFERENCES Countries(idcountry)
,created timestamp DEFAULT NOW() NOT NULL
);

CREATE TABLE Cities(
idcity serial NOT NULL PRIMARY KEY
,name varchar(250) NOT NULL
,idstate int NOT NULL REFERENCES States(idstate)
,created timestamp DEFAULT NOW() NOT NULL
);

En acuerdo con la llave foránea definida en cada tabla, debe existir un país para poder crear un estado, así mismo debe de existir un estado para poder crear una ciudad, entonces creamos unos registros en la tabla países


INSERT INTO Countries(idcountry,name)VALUES('arg','argentina');
INSERT INTO Countries(idcountry,name)VALUES('bra','brasil');
INSERT INTO Countries(idcountry,name)VALUES('ury','uruguay');
INSERT INTO Countries(idcountry,name)VALUES('mex','méxico');

Supongamos que estas tablas van a utilizarse en un sistema donde sea obligatorio que los nombres de país, estado y ciudad, se almacenen teniendo la primera letra mayúscula o en notación Camel Case,(en este caso los países quedaron guardados con letras minúsculas de manera intencional, con el fin de mostrar un Store Procedure).

Creamos entonces una función para aplicar esta regla a los datos de la tabla countries.

La función se define con el siguiente código:


CREATE FUNCTION UpperCamelCase(varchar) RETURNS varchar AS
'DECLARE
        res varchar;
BEGIN
        SELECT INTO  res UPPER(SUBSTRING($1,1,1)) || LOWER(SUBSTRING($1,2));
        return res;
END;'
LANGUAGE 'plpgsql';

Lo aplicamos de la siguiente manera para actualizar los registros.

Una vez creada en el servidor se encuentra disponible para cualquier transformación que queramos aplicar sobre cualquier cadena.

Ahora escribiremos las funciones para insertar registros en cada una de las tablas.


CREATE FUNCTION InsertState(varchar,varchar) RETURNS int AS
'DECLARE
        regs record;
        res numeric;
BEGIN
        SELECT INTO regs count(name) FROM States WHERE name = UpperCamelCase($1);
        IF regs.count = 0
                THEN
                INSERT INTO States(name,idcountry)VALUES(UPPER($1,$2));
                SELECT INTO res idstate FROM States WHERE name = UpperCamelCase($1);
                RETURN res;
        END IF;
        IF regs.count > 0
                THEN
                SELECT INTO res idstate FROM States WHERE name = UpperCamelCase($1);
        RETURN res;
        END IF;
END;
' LANGUAGE  'plpgsql';

CREATE FUNCTIONInsertCity (varchar,numeric) RETURNS int AS
'DECLARE
        regs record;
        res numeric;
BEGIN
        SELECT INTO regs count(name) FROM Cities WHERE name = UpperCamelCase($1);
        IF regs.count = 0
                THEN
                INSERT INTO Cities(name,idstate)VALUES(UPPER($1,$2));
                SELECT INTO res idcity FROM Cities WHERE name = UpperCamelCase($1);
                RETURN res;
        END IF;
        IF regs.count > 0
                THEN
                SELECT INTO res idcity FROM Cities WHERE name = UpperCamelCase($1);
        RETURN res;
        END IF;
END;
' LANGUAGE  'plpgsql';

Básicamente la estructura de un Store Procedure es la siguiente:


CREATE FUNCTION [nombre de la función] ([parámetros separados por comas]) RETURNS [el tipo de dato que regresa] AS
'DECLARE aquí se definen las variables que se usarán.
BEGIN indica el inicio de la función.
SELECT INTO este comando permite que los resultados de las consultas sean asignados a variables. (no debe de confundirse con SELECT [columnas] INTO)
RETURN Sale de la función y regresa el tipo de dato que se declaro después de la palabra RETURNS del CREATE FUNCTION
END indica el fin de la función
' LANGUAGE indica con que lenguaje esta escrita la función, puede ser un lenguaje de procedimiento (plpgsql) o de consulta (SQL).

Vemos que en cada Store Procedure, reutiliza la función UpperCamelCase(varchar) que habíamos previamente creado.
Esto porque un Store Procedure puede llamar a otro Store Procedure que se encuentre disponible.
En las siguientes imágenes los resultados de la ejecución de cada Store Procedure.

Descarga el código fuente para PostgreSQL

Utilizando los objetos NpgsqlConnection y NpgConnectionStringBuilder para PostgreSQL con MonoDevelop

2010-09-07T17:27:00.000-07:00

Hoy día es difícil imaginarse un sistema informático que no haga uso de fuente de datos para persistir información.
Entre estas fuentes de datos se encuentran:

Sin estructura: Archivos que no tienen un orden lógico. (Cartas, memos)

Estructurado, sin jerarquía: Contienen datos agrupados por separadores o indicadores de inicio y fin (archivos de acceso secuencial, archivos separados por tabuladores ó comas)

Jerárquica: tienen una estructura de nodos anidados. (XML)

Bases de datos relacionales:

Objetos: Los datos están organizados como objetos.

Debido a esta variedad, las clases de ADO para acceder y extraer cuentan con un diseño independiente y portable de la implementación de la fuente de datos que se utilice.
Desde luego, primeramente debemos tener acceso a la fuente de datos antes de ejecutar operaciones de consulta o modificación.
Para lograr este propósito usamos un objeto proveedor de conexión especifico según la fuente de datos a utilizar, cada uno de estos objetos son equivalentes en funcionalidades generales por derivar de la clase DBConnection.
Aunque estos objetos son equivalentes en la funcionalidad general, cada uno tiene código específico para su fuente de datos, como se muestra en la tabla siguiente.


+-----------------+-------------------+
| Fuente de datos |Objeto de conexión |
+-----------------+-------------------+
| SQL Server      | SqlConnection     |
+-----------------+-------------------+
| Suportan OLE DB | OleDbConnection   |
+-----------------+-------------------+
| Oracle          | Oracleconnection* |
+-----------------+-------------------+
| PostgreSQL      | NpgsqlConnection  |
+-----------------+-------------------+
*Depende de que el cliente de Oracle se encuentre instalado.

El objeto NpgsqlConnection

Un objeto conexión representa una conexión física a una fuente de datos, por lo que una de las mejores recomendaciones es conectarse y cerrar las conexiones abiertas en cuanto dejen de utilizarse.
ConnectionStrings (Cadenas de conexión)
Antes de trabajar con cualquiera de los objetos de conexión es indispensable proporcionarle la Connection String (cadena de conexión) , esta Connection String es propia de cada objeto Connection y cada objeto Connection es propio de cada fuente de datos con la que trabajemos.
La cadena de conexión es una serie de parámetros y valores separados por (;) y aunque cada Connection String cambie según el proveedor de Base de datos, hay ciertos parámetros que son siempre requeridos, como:


+---------------------------+-------------------------------------------------+
|Data Source o Server       | El lugar donde se encuentra la fuente de datos: |
                            | servidor, máquina, lugar de red, IP, directorio,|
                            | archivo.                                        |
+---------------------------+-------------------------------------------------+
DataBase o Initial Catalog  | El nombre de la base de datos a usar.           |
+---------------------------+-------------------------------------------------+
|User ID                    | El usuario para acceder.                        |
+---------------------------+-------------------------------------------------+
 Password                   | El password del usuario para aceder             |
+---------------------------+-------------------------------------------------+
Integrated Security         | Si es true se utiliza la seguridad de Windows 
                            | para acceder, si es false se debe de proporcionar 
                            | el user y password para acceder.
+---------------------------+-------------------------------------------------+
Timeout o Connection Timeout| El tiempo que debe esperar la aplicación para   |
                            | que el servidor le asigne una conexión.         |
                            | El valor predeterminado es de 15 segundos       |
+---------------------------+-------------------------------------------------+
Pooling                     | Crea un pool de conexiones para la cadena de    |
                            | conexión si no existe, caso contrario           |
                            | asigna una conexión de un pool existente.       |
+---------------------------+-------------------------------------------------+
MinPoolSize                 | Número mínimo de conexiones por pool, valor     |
                            | predeterminado 1                                |
+---------------------------+-------------------------------------------------+
MaxPoolSize                 | Número máximo de conexiones por pool, valor     |
                            | máximo permitido 100                            |
+---------------------------+-------------------------------------------------+

El sitio Connection Strings.com contiene ejemplos y una amplia referencia a cada uno de los parámetros y valores según la fuente de datos.

El objeto NpgsqlConnectionStringBuilder

Hay una clase que nos ayuda a evitar errores de sintaxis al momento de construir cadenas de conexión, esto para no tener recordar cada una de las opciones en el caso de trabajar con diferentes bases de datos. Esta clase es similar a las clases Connection, hay una clase DbConnectionStringBuilder de donde surgen las objetos ConnectionStringBuilder específicos para cada cadena de conexión de cada objeto Connection.
Derivados de la clase DbConnectionStringBuilder, existe la clases NpgsqlConnectionStringBuilder la cual encapsula una ConnectionString (cadena de conexión) para PostgreSQL, la cual demostraremos en el siguiente programa junto con el uso de la clase NpgsqlConnection respectivamente.

Abrimos MonoDevelop, creamos una nueva solución GTK# y agregamos unos controles al formulario para que su aspecto luzca como en la siguiente imagen.

Como utilizaremos el proveedor de datos de PostgreSQL para .NET debemos agregarlo a la solución, hacemos click derecho en la solución(recomiendo la versión 2.x).

Aparecerá la ventana para agregar/quitar las referencias a los ensamblados instalados en el GAC o para buscarlos en el sistema de archivos.

Una vez agregado correctamente, se mostrará el ensamblado en la solución.

Dentro del método para dar funcionalidad al botón de aceptar, mostramos la utilización de la clase NpgsqlConnectionStringBuilder como ayuda para crear la cadena de conexión.


NpgsqlConnectionStringBuilder connString = new NpgsqlConnectionStringBuilder();
connString.Host = txtServer.Text;
connString.Database = @txtDataBase.Text;
connString.UserName = @txtUserID.Text;
connString.Password = @txtPassWord.Text;
connString.Timeout = (string.IsNullOrEmpty(txtTimeOut.Text) ? 0 : Convert.ToInt32(txtTimeOut.Text));
connString.Pooling = this.chkPooling.Active;
connString.MinPoolSize = (String.IsNullOrEmpty(txtMinPool.Text) ? 0 : Convert.ToInt32(txtMinPool.Text));
connString.MaxPoolSize = (String.IsNullOrEmpty(txtMaxPool.Text) ? 0 : Convert.ToInt32(txtMaxPool.Text));

También dentro de este método tenemos el código para la creación de la conexión al servidor.


using(NpgsqlConnection conn = new NpgsqlConnection(connString.ToString())){
conn.Open();
if(conn.State ==  System.Data.ConnectionState.Open)
  MessageBox("Conexión exitosa",MessageType.Info);
}

Si descargamos el código completo del proyecto, al compilarlo correctamente y ejecutarlo,nos pedirá teclear los parámetros para una conexión hacia un servidor PostgreSQL.

Si los parámetros son correctos y el servidor se encuentra disponible entonces la aplicación mostrará el mensaje siguiente:

En caso de un parámetro incorrecto nos mostrará los mensajes de la excepción recibida.

Descarga el código fuente del proyecto para MonoDevelop

Utilizando la clase FtpWebRequest para un cliente básico FTP con MonoDevelop

2010-08-21T20:22:00.000-07:00

Una de las tareas más habituales que existen en el tema de interacción entre sistemas es la copia de archivos de una máquina a otra, existen distintos mecanismos según el tipo de sistema operativo que se disponga entre la máquina destino y la máquina fuente, por ejemplo si se trata de sistemas UNIX/Gnu/Linux podemos utilizar el comando rcp o scp si se trata del servicio SSH.
Para el caso de copiar archivos entre sistemas operativos distintos la opción más común es utilizar el protocolo FTP (File Transfer Protocol) que es un protocolo orientado al usuario que hace uso de comandos para realizar operaciones con archivos en el servidor donde se establece la comunicación y para el cual .NET nos ofrece la clase FtpWebRequest que encapsula toda la funcionalidad de un cliente FTP y de los comandos propios del protocolo mediante los campos de la clase WebRequestMethods.Ftp.


+====================+========+==========================================+
| OPERACIÓN          |COMANDO | DESCRIPCIÓN                              |
+====================+========+==========================================+
|AppendFile          |APPE    | Anexa un archivo a un archivo existente. |
+--------------------+--------+------------------------------------------+
|DeleteFile          | DELE   | Elimina un archivo existente.            |
+--------------------+--------+------------------------------------------+
|DownloadFile        | RETR   | Descarga un archivo existente.           |
+--------------------+--------+------------------------------------------+
|GetDateTimestamp    | MDTM   | Obtiene el date-time stamp de un archivo.|
+--------------------+--------+------------------------------------------+
|GetFileSize         | SIZE   | Obtiene el tamaño de un archivo.         |
+--------------------+--------+------------------------------------------+
|ListDirectory       | NLIST  | obtiene un listado corto de los archivos |
|                               de un directorio en el servidor.         |
+--------------------+---------------------------------------------------+
|ListDirectoryDetails| LIST   | Obtiene un listado detallado de los      |
                                archivos de un directorio en el servidor.|  
+--------------------+--------+------------------------------------------+
|MakeDirectory       | MKD    | Crea un directorio en el servidor.      |    
+----------------------+------+-----------------------------------------+
|PrintWorkingDirectory | PWD  | Imprime el nombre del directorio        |
                                 de trabajo.                            |
+----------------------+------+-----------------------------------------+
|RemoveDirectory       | RMD  | Elimina un directorio.                  |
+----------------------+------+-----------------------------------------+
|Rename                | RENAME| Renombra un directorio.                |
+----------------------+-------+----------------------------------------+
|UploadFile            | STOR  | Envia un archivo al servidor.          |
+------------------------+-----+----------------------------------------+
|UploadFileWithUniqueName|STOU |Envia un archivo con                    |
                                un nombre unico al servidor.            |
+------------------------+-----+----------------------------------------+

Y que ejemplificaremos a continuación programando un cliente FTP básico con MonoDevelop.
Ejecutamos MonoDevelop y diseñamos un formulario GTK# como se muestra en la siguiente imagen:

Agregamos una nueva clase a nuestro proyecto con el nombre de FtpDAO, que es donde se encontrarán los métodos que darán la funcionalidad a nuestro formulario.
En esta clase hacemos referencia a los siguientes ensamblados:


using System.IO;
using System.Net;

Y completamos la funcionalidad de la clase con los siguientes métodos.
Para listar los archivos del directorio en el servidor, escribimos el siguiente método:


public ListStore ObtenerListado(Uri serverUri,bool lsl){
_ftprequest = (FtpWebRequest)WebRequest.Create(serverUri);
_ftprequest.Credentials = creden;
_ftprequest.KeepAlive = true;
ListStore ls_l = new ListStore(typeof(string));
if(lsl)
_ftprequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
else
_ftprequest.Method = WebRequestMethods.Ftp.ListDirectory;
_ftprequest.UseBinary = true;
_ftprequest.UsePassive = true;
_ftprequest.Timeout = 20000;
using(FtpWebResponse response = (FtpWebResponse)_ftprequest.GetResponse()){
using(StreamReader reader = new StreamReader(response.GetResponseStream())){
string ln = "";
do
{
ln = reader.ReadLine();
if(ln != null){
ls_l.AppendValues(ln); 
}
}while(ln != null);
}
}
return ls_l;
}

Que nos regresa la lista de los archivos en un objeto ListStore que servirá de modelo para nuestra interfaz gráfica.
Con el siguiente código establecemos un Uri con la dirección IP o Host y con el directorio al cuál accedemos.


string.Format("ftp://{0}/{1}/",txtServer.Text,txtDir.Text);

La clase Uri sirve para encapsular un URI (Uniform Resource Identifier) que es una manera de identificar
Sin ambigüedades un recurso en Internet, puede ser un archivo, una dirección email o una dirección IP con su protocolo. Hay dos tipos de URIs: URL (Universal Resource Location) o URN (Universal Resource Names), en C# la clase Uri nos brinda todos los métodos y propiedades para el manejo de URI's.
En nuestro ejemplo será la URL del servidor de FTP, como se utiliza con la línea.


Uri serverUri = new Uri(string.Format("ftp://{0}/{1}/",txtServer.Text,txtDir.Text));

Donde concatenamos el protocolo con la IP o nombre del servidor y el directorio donde mostramos el listado, para después seleccionar el archivo a descargar.

C# WebRequest y WebResponse

La clase System.Net.WebRequest representa una petición al servidor y la clase System.Net.WebResponse representa la respuesta del servidor como un flujo de datos o StreamReader.
Usamos el método estático Create de WebRequest para solicitar el recurso del servidor dependiendo del URI que le pasemos como parámetro.


_ftprequest = (FtpWebRequest)WebRequest.Create(serverUri);

Usamos el método GetResponse para obtener la respuesta como un flujo de datos y asociándola a un objeto StreamReader.


using(FtpWebResponse listResponse = (FtpWebResponse)_ftprequest.GetResponse()){
using(StreamReader reader = new StreamReader(listResponse.GetResponseStream())){

Podemos establecer el timeout de la respuesta en milisegundos con la propiedad timeout que tiene un valor predeterminado de 10000.
La funcionalidad de descargar un archivo se la damos con el siguiente método.


public void DescargarArchivo(Uri serverUri,string destino,bool modobin)
{
_ftprequest = (FtpWebRequest)WebRequest.Create(serverUri);
_ftprequest.Credentials = creden;
_ftprequest.KeepAlive = true;
_ftprequest.Method = WebRequestMethods.Ftp.DownloadFile;
_ftprequest.UseBinary = modobin;
_ftprequest.UsePassive = true;
string contenido = "";
char[] charbuffer = null;
byte[] bytebuffer = new byte[2048];
int tbytes = 0;
using(FtpWebResponse response = (FtpWebResponse)_ftprequest.GetResponse())
{
using(Stream stream = response.GetResponseStream())
{
using (FileStream fileout = new FileStream(destino, FileMode.Create, FileAccess.ReadWrite))
{
if (modobin)
{
do
{
tbytes = stream.Read(bytebuffer, 0, 2048);
fileout.Write(bytebuffer,0,bytebuffer.Length);
} while (tbytes != 0);
}
else
{
using(StreamReader reader = new StreamReader(stream)){
contenido = reader.ReadToEnd();
charbuffer = contenido.ToCharArray();
}
using(StreamWriter text = new StreamWriter(fileout)){
text.Write(charbuffer,0,charbuffer.Length);
}}}}} 
}

Al construir y ejecutar la aplicación veremos los resultados como en las siguientes imágenes.

Al oprimir el botón Aceptar después de teclear la IP, el directorio, el usuario y el password, si son válidos para el servidor se muestra el listado de los archivos.

Si activamos la casilla de Listado detallado mostrará el listado detallado de los archivos.

En caso de que ocurra un error en la conexión con el servidor, se mostrará un mensaje con la excepción correspondiente.

Si seleccionamos un archivo de la lista de archivos y pulsamos el botón guardar se solicitará el archivo del servidor y se guardará en el disco duro en el directorio donde se ejecute la aplicación.

En la siguiente imagen la aplicación se conecta a un sitio público habilitando la casilla de autenticación anónima.

Descarga el código fuente del proyecto para MonoDevelop

Utilizando la clase WindowsPrincipal con MonoDevelop

2010-08-05T22:44:00.000-07:00

En este post Conceptos Básicos de seguridad en .NET (parte II) muestro un par de programas ejemplificando acerca de la utilización de la clase WindowsPrincipal. Esta clase representa la información de autenticación y de autorización de una entidad dentro del sistema.
Estos ejemplos pueden compilarse y ejecutarse en Linux, en este caso lo hice en un sistema operativo OpenSuse versión 11.1, con el compilador 2.6.7 y el runtime de mono versión 2.6.7, como se muestra en la siguiente imagen:

El primero de los dos ejemplos lo compilamos y lo ejecutamos mostrando el resultado como en la siguiente imagen:

En la siguiente imagen mostramos el resultado si lo ejecutamos como el superusuario root.

En el caso del segundo ejemplo modificamos el código y cambiamos la interfaz de consola por una interfaz gráfica utilizando el diseñador GTK# de MonoDevelop, siguiendo los siguientes pasos:

Creamos una solución con un proyecto GTK# 2.0 en Monodevelop como en la siguiente imagen:
Modificamos la apariencia del formulario, agregamos dos botones btnEnter, btnClose y un textview nombrado txtInfo para que el formulario se vea como en la siguiente imagen:

Agregamos el método para el evento Clicked del botón btnEnterutilizando la pestaña señales en la ventana de propiedades, seleccionamos el evento y hacemos doble click para que MonoDevelop genere el código del método, como se muestra en las siguientes imagenes:

Agregamos las siguientes líneas al inicio del código de la clase MainWindow.cs , para utilizar los miembros de los ensamblados System.Security.Principal y System.Threading respectivamente.
```
using System.Security.Principal;
using System.Threading;
```

Dentro del método OnBtnEnterClicked del código generado por MonoDevelop para el evento del botón btnEnter, escribimos el siguiente código, el cual contiene toda la funcionalidad de nuestro programa:


protected virtual void OnBtnEnterClicked (object sender, System.EventArgs e)
{
System.Text.StringBuilder buf = new System.Text.StringBuilder();
Gtk.TextBuffer textbuf = txtInfo.Buffer;
textbuf.Clear();
try{
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
WindowsPrincipal wp = (WindowsPrincipal)Thread.CurrentPrincipal;
buf.AppendFormat("Login: {0}\n",wp.Identity.Name);
buf.AppendFormat("Esta autentificado: {0}\n",wp.Identity.IsAuthenticated);
buf.AppendFormat("Tipo de autentificación: {0}\n",wp.Identity.AuthenticationType);
}catch(FormatException fe)
{
 buf.AppendFormat("Error al asignar el rid.\n");
 buf.AppendFormat("Mensaje: {0}",fe.Message);
}
catch(System.Security.SecurityException se)
{
 buf.AppendFormat("No tiene permisos para establecer el principal.\n");
 buf.AppendFormat("Mensaje: {0}\n",se.Message);
}
catch(InvalidCastException ie){
 buf.AppendFormat("Error al obtener el principal.\n");
 buf.AppendFormat("Mensaje: {0}",ie.Message);
 }
finally{
textbuf.Text = buf.ToString(); 
}
}

Nuestro programa entonces se vera como en la siguiente imagen:

Ahora creamos el código del evento Clicked para el botón btnClose de la misma forma que lo hicimos para el botón btnEnter, cuya acción será terminar el programa, por lo que escribimos el siguiente código dentro del método generado.
```
protected virtual void OnBtnCloseClicked (object sender, System.EventArgs e)
{
Application.Quit();
}
```

Para compilar el programa hacemos click en el submenú Construir todo debajo del la opción Construir en el menú principal. En caso de ejecutar el programa hacemos click en cualquiera de las opciones Ejecutar o Depurar bajo el menú Ejecutar en el menú principal.

Si el programa se compila correctamente al ejecutarse mostrará el resultado como en la siguiente imagen:

Si ejecutamos el programa desde la terminal como superusuario nos mostrará el resultado como en la siguiente imagen:

Vemos en el resultado de la ejecucción que el metódo de autenticación es POSIX.

Descarga el código fuente del proyecto para MonoDevelop

Conceptos Básicos de seguridad en .NET (parte II)

2010-07-25T01:29:00.000-07:00

Autorización

La autorización ocurre inmediatamente después de la autenticación y es como el sistema determina que recursos pueden utilizarse de acuerdo con la autenticación, regresando a la analogía del edificio la autorización ocurre después que nos identificamos (autenticación) ante el guardia y le decimos a que piso vamos, entonces nos da un gafete con el número de piso y que nos autoriza movernos únicamente en ese piso mientras nos encontremos dentro el edificio.

La interfaz IPrincipal

El modelo de seguridad basado en roles (roled-based security o RBS) permite controlar el acceso de los usuarios a los recursos en base a su identidad y su pertenencia a un grupo o membership, este modelo esta diseñado para ser independiente de la plataforma donde se implemente por lo que .NET utiliza el concepto de principal (representado por la interfaz IPrincipal) como una forma de abstraer este modelo y encapsular la información acerca del contexto de seguridad (security context) de la entidad (usuario o objeto) que ejecuta el código.

Hay diferentes tipos de objetos Principal cada uno para cada tipo de identidad y de membership, .NET proporciona los siguientes tipos de principales.

Windows Principal: Si utilizamos la seguridad Integrada de Windows este objeto representa la identidad, la autenticación y los roles de Windows.

Generic Principal: Representa una seguridad a nivel aplicación, independiente de la seguridad de Windows, los roles y los usuarios utilizan un método personalizado de autenticación como por ejemplo una tabla en una base de datos.

Hay dos técnicas para crear objetos Principal dependiendo de si una aplicación requiere hacer la validación algunas veces o durante toda su ejecución. Vamos a mostrar estas formas utilizando como ejemplo el objeto WindowsPrincipal.

La primera técnica se recomienda si requerimos hacer la validación de cierto código algunas veces durante la ejecución, la sintaxis es:


WindowsIdentity wi = WindowsIdentity.GetCurrent();
WindowsPrincipal wp = new WindowsPrincipal(wi);

En esas lineas, primero obtenemos una instancia de WindowsIdentity al consultar la cuenta de Windows que ejecuta el código con el método GetCurrent y después la usamos como parámetro para construir un objeto WindowsPrincipal.

La segunda técnica se utiliza si requerimos hacer la validación durante toda la ejecución de la aplicación entonces en este caso debemos establecer la seguridad de Windows a nuestro hilo principal de ejecución ya que .NET de forma predeterminada no estable esa propiedad, entonces la sintaxis es la siguiente:


AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
WindowsPrincipal wp = (WindowsPrincipal)Thread.CurrentPrincipal;

En esas líneas primeramente establecemos la política de autorización al dominio de la aplicación con el valor de la enumeración PrincipalPolicy , después obtenemos el Principal del hilo de ejecución y hacemos un casting a un objeto WindowsPrincipal, si no establecemos la política no podremos hacer el casting de Thread.CurrentPrincipal a WindowsPrincipal ya que como mencionamos anteriormente .NET no establece esta propiedad.

Una vez teniendo el objeto WindowsPrincipal además de las propiedades y métodos de la clase WindowsIdentity podemos determinar su pertenencia a un grupo o rol, con el método IsInRole.
El método IsInRole de WindowsPrincipal tiene tres sobrecargas la primera recibe como argumento una cadena conteniendo el nombre del grupo o rol que debe escribirse para grupos basados en dominios de la siguiente forma:

[NombreDelDominio]\[Grupo]

O de la siguiente forma si es para grupos de la computadora local.

[NombreDeLaMaquina]\[Grupo]

La segunda sobrecarga recibe un RID (Role Identifier) y la tercera recibe una enumeración WindowsBuiltInRole
La tabla siguiente lista los identificadores del rol con su correspondiente valor en la enumeración WindowsBuiltInRole


+----------------+------+
|AccountOperator |0x224 |
|Administrator   |0x220 |
|BackupOperator  |0x227 |
|Guest           |0x222 |
|PowerUser       |0x223 |
|PrintOperator   |0x226 |
|Replicator      |0x228 |
|SystemOperator  |0x225 |
|User            |0x221 |
+----------------+------+

El siguiente programa demuestra el uso de la primera técnica de validación para conocer la autorización de una entidad.


using System;
using System.Security.Principal;

namespace Samples{
public class SimplePrincipal{
public static int Main(string[] args){
string[] roles = {
@"BUILTIN\Account Operators",
@"BUILTIN\Administrators",
@"BUILTIN\Backup Operators",
@"BUILTIN\Guests",
@"BUILTIN\Power Users",
@"BUILTIN\Print Operators",
@"BUILTIN\Replicators",
@"BUILTIN\Server Operators",
@"BUILTIN\Users"
};
WindowsIdentity wi = WindowsIdentity.GetCurrent();
WindowsPrincipal wp = new WindowsPrincipal(wi);
Console.WriteLine("\n Información  ");
Console.WriteLine("=====================\n");
Console.WriteLine(" Login: {0}",wp.Identity.Name);
Console.WriteLine(" Esta autentificado: {0}",wp.Identity.IsAuthenticated);
Console.WriteLine(" Tipo de autentificación: {0}",wp.Identity.AuthenticationType); 
for(int i = 0;i < roles.Length;i++){
 if(wp.IsInRole(roles[i]))
 Console.WriteLine(" Es miembro de {0}",roles[i]); 
}
Console.Write("\nPresione una tecla para continuar...");
Console.Read();
return 0;
 }
}
}

Al compilar y ejecutar el programa con una cuenta de administrador mostrará el siguiente resultado:

Ahora bien, si ejecutamos el programa con el comando

runas /user:[Usuario] [Programa]

en este caso con la cuenta del usuario postgres,como se muestra en la imagen:

El programa mostrará el siguiente resultado:

Y ahora demostramos la segunda técnica utilizando la política del dominio de la aplicación, algo más elaborado que el ejemplo anterior, lo ejemplificamos con el código de clase Roles.cs y la clase SimplePrincipalThread.cs que listamos a continuación.

El listado Roles.cs


using System;
namespace Samples{
public class Roles{
//roles de Windows
string[,] roles = {
 {"0x224",@"BUILTIN\Account Operators"},
 {"0x220",@"BUILTIN\Administrators"},
 {"0x227",@"BUILTIN\Backup Operators"},
 {"0x222",@"BUILTIN\Guests"},
 {"0x223",@"BUILTIN\Power Users"},
 {"0x226",@"BUILTIN\Print Operators"},
 {"0x228",@"BUILTIN\Replicators"},
 {"0x225",@"BUILTIN\Server Operators"},
 {"0x221",@"BUILTIN\Users"}
};
public string this[string rid]{
get{
 for(int i = 0;i < (roles.Length/2);i++)
 {
 if(roles[i,0].Equals(rid))
 return  roles[i,1];
 }
 return "Sin rol";
}
}
}
}

El listado SimplePrincipalThread.cs


using System;
using System.Security.Principal;
using System.Security;
using System.Threading;

namespace Samples{
public class SimplePrincipalThread{
public  static int Main(string[] args)
{
Console.WriteLine("\n");
Console.WriteLine("===================");
if(args.Length > 0 && args.Length < 3){
try{
if(args[0].ToLower().Equals("true"))
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
WindowsPrincipal wp = (WindowsPrincipal)Thread.CurrentPrincipal;
Console.WriteLine("Login: {0}",wp.Identity.Name);
Console.WriteLine("Esta autentificado: {0}",wp.Identity.IsAuthenticated);
Console.WriteLine("Tipo de autentificación: {0}",wp.Identity.AuthenticationType); 
Roles roles = new Roles();
string rid = args[1];
if(wp.IsInRole(rid))
Console.WriteLine("Es miembro de {0}",roles[rid]);
else
Console.WriteLine("No es miembro de {0}",roles[rid]);
}
catch(FormatException fe)
{
Console.WriteLine("Error al asignar el rid.");
Console.WriteLine("Mensaje: {0}",fe.Message);
}
catch(SecurityException se)
{
Console.WriteLine("No tiene permisos para establecer el principal.");
Console.WriteLine("Mensaje: {0}",se.Message);
}
catch(InvalidCastException ie){
Console.WriteLine("Error al obtener el principal.");
Console.WriteLine("Mensaje: {0}",ie.Message);
}
}else
Usage();
return 0;
} //fin de main

 static void Usage(){
Console.WriteLine("Usar:");
Console.WriteLine("SimplePrincipalThread [true|false] [rid(hex)]");
Console.WriteLine("ejemplo: SimplePrincipalThread true 0x222");
}
}
}

Al compilar las clases y ejecutar el programa con la opción false nos mostrará la excepción de que no hemos establecido una política de autorización.

Si ejecutamos el programa sin argumentos nos mostrará las instrucciones de uso.

Si ejecutamos el programa correctamente,nos mostrará la información como en la siguiente imagen

Descarga el código fuente

Libros de programación en C# para descargar

2010-07-19T21:52:00.000-07:00

Buscando bibliografía en Internet de C#, encontre esta página con enlaces para descargar libros electrónicos de programación en C#.

http://www.computer-books.us/csharp.php

Conceptos Básicos de seguridad en .NET (parte I)

2010-07-14T12:45:00.001-07:00

La seguridad es un tema que debe estar presente desde el comienzo del diseño de todo sistema de información, más aún si este sistema será utilizado por usuarios desde Internet.
Dos conceptos básicos para entender la seguridad de los sistemas es la autenticación y la autorización.

Autenticación

La autenticación es el proceso mediante el cual el sistema identifica y válida que el usuario pruebe quién dice ser, es similar a cuando hacemos una visita a un edificio y un guardia de seguridad en la entrada nos solicita una credencial para que nos identifiquemos, el mecanismo de credenciales más usadas en los sistemas de información es el login y el password.
Entonces en definición la autenticación es el mecanismo que se refiere a probar y validar quiénes somos dentro del sistema, esta identidad consiste generalmente del login de usuario y del rol asociado con ese login, NET proporciona los siguientes mecanismos de autenticación:

Windows Authentication Utiliza la seguridad del sistema operativo windows y compara las credenciales (login y password) con las credenciales de Windows una vez identificado, windows utiliza un número de 96 bits llamado SID (security identifier) para identificarlo.

Passport Authentication En este tipo los usuarios utilizan sus cuentas de Hotmail o de Windows Messenger para autenticarse y por ende su servicio de registro en caso de no tener una cuenta passport, para utilizar esta autenticación es necesario descargar e instalar Passport SDK desde Microsoft Passport Network.

Forms Authentication (ASP.NET) Aquí se realiza mediante un formulario solicitando el login y el password al usuario, cuando ASP.NET válida las credenciales como correctas crea una cookie encriptada que se adjunta a cada respuesta de petición, por eso se dice que esta autenticación es basada en token (token-based), si el runtime de ASP .NET no encuentra la cookie entonces redirige al usuario a la pantalla del login, este tipo de autenticación es la más personalizable y portable que las anteriores.

Estos mecanismos se utilizan en conjunto con la seguridad basada en roles de .NET (role-based security) que se fundamenta en dos conceptos importantes: identidades y principales.
La identidad de un usuario está representada en .NET por los siguientes tipos de identidades que se encuentran representadas en el Framework por clases que implementan la interfaz IIdentity.

Windows identity Se basa en los métodos de autenticación soportados por el sistema operativo Windows, esta identidad tiene la propiedad de hacerse pasar por otro usuario con la característica de impersonation(suplantación) además de ser una forma muy segura de autenticar usuarios.

Generic identity Se basa en un método personalizado de autenticación que se define a nivel aplicación, al ser un método personalizado por lo tanto no depende de las características del sistema de seguridad de Windows.

Passport identity Utiliza la autenticación del modulo de Passport de Microsoft donde los usuarios utilizan las credenciales de Hotmail o Windows Live para acceder a cualquier sistema que implemente el servicio Passport (single sign-inservice).

Si bien se recomienda utilizar los mecanismos proporcionados por el framework, .NET permite también crear mecanismos personalizados de autenticación implementando la interfaz IIdentity.

Código de ejemplo con la clase WindowsIdentity:


using System;
using System.Security.Principal;

namespace Samples{
 public class WindowsIdentitySample{
 public static int Main(string[] args){
 Console.WriteLine("\n| Información de la identidad ");
 Console.WriteLine("+-----------------------------------------------");
 WindowsIdentity wi = WindowsIdentity.GetCurrent();
 Console.WriteLine("Login: {0}",wi.Name);
 Console.WriteLine("Esta autentificado: {0}",wi.IsAuthenticated);
 Console.WriteLine("Tipo de autentificación: {0}",wi.AuthenticationType);
 Console.WriteLine("Es anónimo/invitado/sistema: {0}",
   (wi.IsAnonymous ? "Anónimo" : 
    (wi.IsGuest ? "Invitado" : 
     (wi.IsSystem ? "Sistema" : "Ninguna"))));
 return 0;
 }
 }
}

Al ejecutarse el programa mostrará la siguiente salida en Microsoft Windows:

Y la siguiente salida al ejecutarse en Linux utilizando Mono

A continuación el código de ejemplo utilizando la clase GenericIdentity:


using System;
using System.Security.Principal;

namespace Samples{
 public class GenericIdentitySample{
  public static int Main(string[] args){
   Console.WriteLine("\n| Información de la identidad");
   Console.WriteLine("+-----------------------------------");
   //lo construimos con los parámetros del nombre y del metódo de autenticación
   GenericIdentity gi = new GenericIdentity("SuperUsuario","Autenticado personalizado");
   Console.WriteLine("Nombre: {0}",gi.Name);
   Console.WriteLine("Tipo de autenticación: {0}",gi.AuthenticationType);
   Console.WriteLine("Esta autenticado: {0}",gi.IsAuthenticated);
   return 0;
  }
 }
}

Al ejecutarse el programa mostrará la siguiente salida en Microsoft Windows:

Y la siguiente salida al ejecutarse en Linux utilizando Mono

Descarga el código fuente

Trabajando LINQ para XML con Monodevelop Parte II de II

2010-05-30T09:30:00.000-07:00

Esta es la segunda parte del post anterior Trabajando LINQ para XML con Monodevelop, aunque este tutorial supone que los dos proyectos están dentro la misma solución, los dos proyectos son independientes uno del otro, por lo que pueden crearse en diferentes soluciones.

Consultando XML con LINQ

Ahora agregamos un segundo proyecto a nuestra solución, este proyecto será una aplicación GTK# que llamaremos “SegundoLinqXML” como se muestra en la siguiente imagen y que nos mostrará como consultar el archivo XML con LINQ creado con la aplicación de consola anterior.

Utilizando el diseñador agregamos y acomodamos los siguientes controles GTK# con sus respectivos identificadores al formulario.

Tipo de control:Gtk.Entry NombretxtQuery

Tipo de control:Gtk.Button NombreBtnBuscar

Tipo de control:Gtk.RadioButton NombresRbCodigo,rbIdArticulo,rbNombre

Tipo de control:Gtk.TreeView NombresResultados

Colocando los controles el formulario deberá verse como en la siguiente imagen

El código completo es el siguiente listado


using System;
using Gtk;
using System.Xml.Linq;
using System.Collections.Generic;
using System.Linq;


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

protected void OnDeleteEvent (object sender, DeleteEventArgs a)
{
Application.Quit ();
a.RetVal = true;
}
protected virtual void OnBtnBuscarClicked (object sender, System.EventArgs e)
{
ListStore store = new ListStore(typeof(string));
if(System.IO.File.Exists("articulos.xml")){
string col = "Codigo";
if(rbNombre.Active)col = "Nombre";
if(rbIdArticulo.Active)col = "IdArticulo";
Resultados.EnableGridLines = TreeViewGridLines.Horizontal;
XElement xml = XElement.Load("articulos.xml");
var q = from s in xml.Elements("Table").Elements(col)
where  s.Value.Contains(txtQuery.Text)
select s;
foreach(string r in q){
store.AppendValues(r);
}
Resultados.Model = store;
}else
using(Dialog dia = new MessageDialog(this,DialogFlags.Modal,
MessageType.Error,
ButtonsType.Ok,"No existe el archivo XML",null)){
dia.Run();
dia.Destroy();
}
}

//se crean las columnas del Grid
void AddColumns (TreeView treeView) {
CellRendererText rendererText = new CellRendererText ();
string[] s = {"Resultado"};
TreeViewColumn column;
for(int i = 0;i < s.Length;i++){
column =  new TreeViewColumn (s[i], rendererText, "text", i);
treeView.AppendColumn (column);  }
}
}

El siguiente fragmento de código muestra como realizar la consulta del archivo XML donde la variable col adquiere el valor de cualquier elemento dentro del elemento table y donde el valor contenga el texto escrito dentro de txtQuery, es aquí donde en esencia se utilizan las expresiones de consulta de LINQ una vez que se carga el documento XML en memoria.


XElement xml = XElement.Load("articulos.xml");
var q = from s in xml.Elements("Table").Elements(col)
where s.Value.Contains(txtQuery.Text)
select s;

Construimos la aplicación pulsando el botón F8, seleccionamos el archivo de proyecto y haciendo click con e botón secundario del ratón seleccionamos la aplicación para que se inicie al ejecutar la solución, al ejecutarla teclear un valor y pulsar el botón consultar observaremos cualquiera de los siguientes resultados dependiendo del control radio seleccionado.

Descarga el código fuente

Trabajando LINQ para XML con Monodevelop Parte I de II

2010-05-26T22:02:00.000-07:00

XML se ha convertido en un excelente estándar abierto para el intercambio de información entre aplicaciones de software debido a la manera de representar información estructurada, independiente de la plataforma, lenguaje de programación o sistema operativo, es utilizado extensamente en archivos y protocolos de Internet por ser un formato fácil de leer y suficientemente flexible para adaptarse a muchos propósitos. Debido a estas características XML y sus tecnologías están completamente integradas y soportadas por la plataforma .NET mediante un conjunto de clases que proporcionan lectura y escritura de documentos, validación, navegación, serialización, transformación y búsquedas. Aunque estas clases son suficientes para trabajar con XML su utilización no es sencilla y puede producir código difícil de mantener, por lo que .NET incorpora LINQ para XML (LINQ to XML) como una mejor manera de trabajar con XML.

Creando el archivo XML

Para mostrar de una manera práctica la utilización de LINQ para XML, ejecutamos MonoDevelop y creamos una nueva solución en el menú “Archivo”, del lado derecho de la ventana de nueva solución seleccionamos el icono que dice “Solución en blanco” y en el cuadro de texto nombre escogemos “LinqXML”, esta será la solución que contenga los dos proyectos de este tutorial.

Agregamos a nuestra solución un proyecto de consola, le llamamos CrearXML , como se muestra en la siguiente imagen.

Para que el soporte de LINQ a XML es importante hacer referencia a los siguientes ensamblados:

System.Linq Es el ensamblado principal y básico que contiene todas las clases e interfaces para trabajar con LINQ.

System.Xml.LinqContiene las clases y extensiones para manipular XML con LINQ.

Esto se logra haciendo click derecho sobre el archivo de proyecto y en el menú desplegable escogemos la opción “Editar referencias” (Edit References) como se muestra en la imagen siguiente.

Ahora completamos el código generado por monodevelop, para que el programa completo quede como en el siguiente listado.


using System;
using System.Linq;
using System.Xml.Linq;

namespace CrearXML{
 class MainClass
 {
  public static  void Main (string[] args){
 XDocument doc = new XDocument(new XElement("Articulos",
 new XElement("Articulo",new XElement("IdArticulo","1"),
 new XElement("Codigo","C01-01-C12140"),
 new XElement("Nombre","CATGUT CROMICO 4-0 30CM C1214/2-30")),
 new XElement("Articulo",new XElement("IdArticulo","2"),
 new XElement("Codigo","C01-01-C26109"),
 new XElement("Nombre","ACERO 2 45CM C26109x2")),
 new XElement("Articulo",new XElement("IdArticulo","3"),
 new XElement("Codigo","C01-01-C40590"),
 new XElement("Nombre","POLIESTER 2 75CM C4059"))));
 Console.WriteLine(doc.ToString());
 doc.Save("articulos.xml");
 Console.WriteLine("XML creado");
  }
 }
}

La diferencia de la sintaxis para crear documentos XML con respecto a la sintaxis empleada con las clases del ensamblado System.Xml, es que esta sintaxis se enfoca más en los elementos (representados por la clase XElement) que en el documento (representado en la clase Xdocument ).
En este listado creamos el documento XML de una manera declarativa anidando varias objetos XElement dentro de un objeto Xdocument , al final llamamos al método Save para guardar el XML en el disco.
Construimos la aplicación pulsando la tecla F8 y al ejecutarse veremos el resultado en la ventana de salida de MonoDevelop como se muestra en la imagen siguiente.

Descarga el código fuente

El patrón singleton con Monodevelop y PostgreSQL

2010-05-19T20:51:00.000-07:00

En el post anterior mostré un ejemplo utilizando el patrón Singleton con conexiones a bases de datos SQL Server ejecutándonse bajo Microsoft Windows, ahora mostraré las modificaciones que tuve que realizar a ese ejemplo para que funcione con
PostgreSQL como base de datos y Linux como sistema operativo.
Primeramente abrí el proyecto en Monodevelop, después descargue la última versión de la biblioteca Npgsql para tener actualizado los últimos cambios de esta biblioteca, lo cuál es recomendable ya que además de arreglar los errores el equipo responsable agrega nuevas funcionalidades, una vez descargada la biblioteca comence con las siguientes modificaciones:

1-.Quitar la referencia al ensamblado de Sql Server (System.Data.SqlClient) y reemplazarlo por el de PostgreSQL (Npgsql), esto se hace dentro del explorador de la solución, haciendo click derecho sobre las referencias como se muestra en la imagen.

Nos aparecerá la ventana "edit references", ahí escogemos la pestaña que dice "Ensamblado .Net" para buscar en el sistema de archivos en la ruta donde descargamos y descomprimimos la biblioteca Npgsql,esto para seleccionar el ensamblado Npgsql.dll como se muestra en la siguiente imagen.

2-. Reemplazar en el código de las clases DataBase y DataBase2 respectivamente el namespace System.Data.SqlClient por Npgsql
using System.Data.SqlClient;
por
using Npgsql;

3-. También en el código de esas clases reemplazar las líneas donde se hace la declaración del objeto que representa la conexión y donde se realiza la creación de dicho objeto, reemplazar las siguientes líneas:

SqlConnection _conn = null;
_conn = new SqlConnection();

por

NpgsqlConnection _conn = null;
_conn = new NpgsqlConnection();

4-. En estas mismas clases cambiar el tipo de excepción en el catch del try del metódo GetConnection().
catch(SqlException x)
por
catch(NpgsqlException x)

5-. Reemplazar el evento StateChange del objeto NpgsqlConnection y el delegado asociado al evento, por una propiedad de tipo string
que infome de las características de la conexión, esto debido a que aún el proveedor de datos de postgreSQL no cuenta con esta característica.

StateChange += delegate(object o,StateChangeEventArgs args){
    Info = String.Format(" {1}| {2}| {3}|",args.CurrentState.ToString(),
System.DateTime.Now.ToLocalTime(),_conn.DataSource,_conn.Database);

por

Info = String.Format(" {0}|{1}| {2}| {3}|",GetCurrentState,System.DateTime.Now.ToLocalTime(),_conn.DataSource ,_conn.Database);

Agregando la siguiente propiedad

public string GetCurrentState{ get {return (IsOpen == true ? "Open" : "Closed");}}

Terminando los cambios debemos de configurar MonoDevelop para que al ejecutar la aplicación el programa se ejecute en una terminal propia y no en la ventana de salida (output) de MonoDevelop, esto se hace en el menú principal en la opción "Proyecto" eligiendo el submenú "Opciones", nos mostrará una pantalla como la siguiente imagen.

Después de estos cambios podemos observar el resultado, de forma idéntica al resultado logrado en la plataforma Microsoft.
Ingreso de los parámetros de conexión

Sin el uso del patrón Singleton, cambian los tiempos en la conexión

Usando el patrón Singleton, el tiempo es único.

Descarga el código fuente

El patrón singleton

2010-05-03T16:29:00.000-07:00

Muchos problemas de rendimiento (performance) y de escalabilidad (scalability) ocurren si no manejamos correctamente las conexiones a las bases de datos, hay que tener en presente que las conexiones para acceder a una base de datos son un recurso que consume memoria y tiempo de procesador, por lo que solo se deben crear las conexiones necesarias para el funcionamiento de las aplicaciones y estas deben cerrarse tan pronto hayan sido ocupadas.
Una buena práctica es que todas las clases que acceden a los recursos de la base de datos utilicen siempre una única conexión sin importar el número de instancias que estas clases generen al ser ejecutadas dentro de una aplicación, una solución recomendada a este escenario es utilizar los patrones de diseño de software.

Conectarse a una base de datos con el patrón Singleton

Es un patrón de diseño del tipo creacional que nos asegura la creación de únicamente la instancia de un objeto sin importar el número de veces que se intenten crear más instancias de ese objeto.
citando el clásico libro de the gang of four Design Patterns:Elements of Reusable Object-Oriented Software, 1995, Pearson Addison Wesley "The Singleton design pattern must ensure a class only has one instance, and provide a global point of access to it"

Este patrón se utiliza para representar un objeto de hardware (por ejemplo una impresora), un componente del sistema operativo (un archivo o un directorio) o bien un recurso externo limitado (como una conexión a una base de datos), esta instancia revisará si ya ha sido creada, atenderá las peticiones de los objetos que la utilicen como un punto global de acceso (similar a una variable global) y sera responsable del mantener el seguimiento de su estado.
El esqueleto clásico de un Singleton es el siguiente:


class Singleton {
public static Singleton Instance() {

//Aqui aseguramos que solamente sea creada una sola vez
//si la instancia es null

if(_instance == null) {
 lock(typeof(Singleton)) {
 if(_instance == null) {
 _instance = new Singleton();
     }
}
}
return _instance;
}

//el constructor protected o private evita que se creen instancias
//por fuera del control de la clase

protected Singleton() { }

//garantiza que todos los subprocesos siempre tengan
//la (única) instancia más actual

private static volatile Singleton _instance = null;
}

A continuación voy a mostrar el ejemplo de una clase que representa una conexión a una base de datos sin utilizar el patrón Singleton, para mostrar como se crea una conexión por cada ocasión que nosotros llamamos a la clase lo cual repercute en la escalabilidad y el desempeño de la aplicación si se tuvieran que invocar decenas o cientos las ejecuciones a esta clase.


using System;
using System.Data;
using System.Data.SqlClient;

namespace PostSingleton
{
public class DataBase
{
        SqlConnection _conn = null;
 public DataBase(string conString){
 ConnectionString = conString;
    GetConnection(); 
 }
  public void GetConnection(){
    try{
    _conn = new SqlConnection();
    _conn.StateChange += delegate(object o,StateChangeEventArgs args){
    Info = String.Format(" {1}| {2}| {3}|",args.CurrentState.ToString(),
System.DateTime.Now.ToLocalTime(),_conn.DataSource,_conn.Database);
    };
    _conn.ConnectionString = ConnectionString;
    _conn.Open();
    IsOpen = true;
    }
    catch(SqlException x){
 Close();
    throw x;
    }
    }
 
 public void Close(){
     if (_conn.State == System.Data.ConnectionState.Open){
          _conn.Close();
         IsOpen = false;
  }
 }
    string ConnectionString {set;get;}
    public bool IsOpen {set;get;}
    public string Info {set;get;}
}}

A continuación el programa principal:


using System;
using System.Collections.Generic;
using System.Linq;

namespace PostSingleton
{
public class Program
{
static List _conns = null;
public static int Main(string[] args)
{
  _conns = new List();
  string op = null;
  Console.ForegroundColor = ConsoleColor.White;
  do{
 Console.Write("\n");
 Console.WriteLine("+-------------------------------+");
 Console.WriteLine(" Ejemplo del patron singleton para conexiones");
 Console.Write("\n");
 Console.WriteLine("a) Conexión DB");
 Console.WriteLine("b) Ver Conexiones");
 Console.WriteLine("q) Salir");
 Console.Write("\n");
 Console.ForegroundColor = ConsoleColor.Yellow;
 Console.Write("Elija su opción y pulse  : ");
 Console.ForegroundColor = ConsoleColor.White;
 op = Console.ReadLine().ToLower();
 switch(op){
  case "a":
   ConectarDB();
   break;
  case "b":
   VerConexiones();
   break;
 }
  }while(op != "q");
  Console.WriteLine("\nHasta luego");
 return 0;
 
}
static void VerConexiones(){
try{
Console.Clear();
Console.WriteLine("\nListado de conexiones");
Console.Write("\n");
Console.WriteLine("+------------------------------------+");
Console.WriteLine("| CONEXIONES ACTIVAS                 |");
Console.WriteLine("+------------------------------------+\n");
if(_conns.Count > 0){
var q = from c in _conns where c.IsOpen == true select c;
foreach(var i in q){
 Console.WriteLine("{0}",i.Info);
}}else Console.WriteLine("NO HAY CONEXIONES ACTIVAS");
}catch(Exception x){ Console.WriteLine("Excepcion " + x.Message); }
}  
static void ConectarDB(){
 try{
 Console.Clear();
 Console.WriteLine("Datos de la cadena de conexion ");
    Console.ForegroundColor = ConsoleColor.Yellow;
    Console.Write("Servidor y pulse  : ");
    string server = @Console.ReadLine();
    Console.Write("Base de datos y pulse  : ");
    string database = @Console.ReadLine();
    Console.Write("Usuario y pulse  : ");
    string user = @Console.ReadLine();
    Console.Write("Password y pulse  : ");
    string password = @Console.ReadLine();
 Console.ForegroundColor = ConsoleColor.White;
 string connStr = String.Format(
    "Data Source={0};Initial Catalog={1};User ID={2};Password={3};",
    server,database,user,password);
    Console.WriteLine("Intentando conexión...");
   DataBase db = new DataBase(connStr);
    _conns.Add(db);
  VerConexiones();
}catch(Exception x){
 Console.WriteLine("Excepción " + x.Message);
}
}
static void Exit(){
Environment.Exit(0);
}}}

Al compilar y ejecutar la aplicación se mostrará el siguiente menú.

Escogiendo la opción (a) nos mostrará el menú para solicitarnos los parámetros de la cadena de conexión, si repetimos este procedimiento nos mostrará
las conexiones hechas hacia el servidor, una por cada vez que hayamos completado la opción (a) como se muestra en la siguiente imagen.

Observamos en la imagen como es diferente el tiempo entre cada una de las conexiones ya que se crea una conexión por cada llamado.

Bien ahora mostraremos el mismo ejercicio utilizando el patrón Singleton en el código de la clase DataBase, pero para no sobrescribir la clase DataBase del ejercicio anterior, nombraremos la clase Singleton como DataBase2.


using System;
using System.Data;
using System.Data.SqlClient;

namespace PostSingleton
{
public class DataBase2
{
static DataBase2 Instance = null;
static SqlConnection _conn = null;
private DataBase2(){  }
private static void CreateInstance(){
    if(Instance == null)
    { Instance = new DataBase2();}
    }
    public static DataBase2 GetInstance(string conStr){
    if(Instance == null){
    CreateInstance();
    Instance.ConnectionString = conStr;
    Instance.GetConnection();}
    return Instance;
    }
    void GetConnection(){
    try{
    _conn = new SqlConnection();
     _conn.StateChange += delegate(object o,StateChangeEventArgs args){
    Info = String.Format(" {1}| {2}| {3}|",args.CurrentState.ToString(),
    System.DateTime.Now.ToLocalTime(),_conn.DataSource,_conn.Database);
    };
    _conn.ConnectionString = ConnectionString;
    _conn.Open();
    IsOpen = true;
    }
    catch(SqlException x){
        if (_conn.State == System.Data.ConnectionState.Open)
              _conn.Close();
    throw x;
    }
    }
    public void Close(){
  if (_conn.State == System.Data.ConnectionState.Open){
              _conn.Close();
              IsOpen = false;
  }
 }
 string ConnectionString {set;get;}
 public bool IsOpen {set;get;}
 public string Info {set;get;} 
}}

Analizamos la clase y vemos el uso de los modificadores private y static en el constructor hace que no se pueda crear la clase de forma directa, sino solo a traves del método public GetInstance(string conStr) que regresa la instancia creada y por ende sus propiedades y métodos públicos.
Antes de ejecutar el programa principal para que utilice la clase con el singleton, hay que modificar la líneas donde se crea la lista de conexiones


static List _conns = null;
_conns = new List();

y tambien donde se invoca la conexión con la base de datos.


_conns.Add(DataBase2.GetInstance(connStr));

Haciendo estos cambios, ejecutando la aplicación, seleccionando la opción (a) para conectarse a una base de datos y creando varias conexiones debemos de ver
la salida del programa como en la siguiente pantalla:

Observamos en la imagen como el tiempo entre cada una de las conexiones es siempre el mismo, ya que se crea una sola instancia global de acceso.

Descarga el código fuente

Uso de funciones PL/SQL en postgreSQL

2010-04-26T22:10:00.000-07:00

Una función (function) en PostgreSQL son sentencias SQL agrupadas y precompiladas para ejecutarse en bloque dentro del servidor, a diferencia de las consultas SQL donde cada consulta es procesada en tiempo de ejecución por el servidor , las funciones procedurales son compilados cuando son creados, ya que el servidor asume que serán ejecutados más de una vez, un función ofrece las siguientes ventajas:

No sobrecarga la comunicación cliente/servidor al evitar enviar una consulta tras otra, en su lugar procesa una consulta tras otra y envía únicamente el resultado.

Cuando y se ejecuta la primera vez se crea un plan preparado de ejecución, las siguientes ejecuciones reutilizan el plan preparado.

Agrega estructuras de control y capacidad de calculo al lenguaje SQL.

Las mismas consultas están disponibles para varias aplicaciones.

Seguridad los datos solo estan accesibles mediante las funciones y evita el uso de SQL injection.

De los lenguajes más utilizados para crear funciones en postgreSQL, se encuentra PL/pgSQL, el cual se distribuye como un módulo cargable junto con postgreSQL, para emplearlo en nuestra base de datos es necesario darlo de alta, de la siguiente manera.

Revisamos si ya lo tenemos disponible en nuestra base de datos para utilizarlo
La sintaxis de PL/pgSQL (similar al lenguaje PL/SQL de Oracle)

Utilizando PL/pgSQL con C#

En este ejemplo usaremos PL/pgSQL y C# para resolver un requerimiento practico como seria relacionar la columna city de nuestra tabla authors en nuestra base de datos con una tabla llamada cities donde se encontrará la información de la columna ciudad mas un identificador.

La relación deberá de quedar de la siguiente manera, donde la columna city se debe cambiar por la clave primaria de la tabla cities que tendrá como clave primaria la clave de la ciudad y una columna adicional llamada city que contendrá el nombre de la ciudad.


CREATE TABLE cities(
idcity varchar(5) PRIMARY KEY,
city varchar(20) NOT NULL UNIQUE
);

Ahora usamos la siguiente funciónfunction para tomar los valores de la columna city en la tabla authors, crear un identificador único para la llave primaria, insertar ese valor de clave primaria junto con el nombre de la ciudad y por último sustituir los valores en la columna city y reemplazarlos con el valor de la llave primaria en la tabla cities.


CREATE FUNCTION AddCities(varchar) RETURNS VARCHAR AS
'DECLARE
hay record;
nume varchar;
BEGIN
SELECT INTO hay count(city) FROM cities WHERE city = $1;
IF hay.count = 0
THEN
INSERT INTO cities(idcity,city)
VALUES(substring($1,1,3) || substring(random() * 1000,1,2),$1);
SELECT INTO nume idcity FROM cities WHERE city = $1;
UPDATE authors SET city = nume WHERE city = $1;
RETURN nume;
END IF;
IF hay.count > 0
THEN
SELECT INTO nume idcity FROM cities WHERE city = $1;
UPDATE authors SET city = nume WHERE city = $1;
RETURN nume;
END IF;
END;
' LANGUAGE 'plpgsql';

Guardamos nuestra función en un archivo llamado store1.sql y lo ejecutamos para crearla dentro del servidor.

Una vez creada nuestra función mostraremos como emplearla desde C# con el siguiente:


using System;
using Gtk;
using System.Text;
using System.Data;
using Npgsql;
using NpgsqlTypes;

namespace PgForm {
class PgForm : Window {
Label lbMsg = new Label("DEBUG: ");
Entry txtNameFunction = new Entry();
Entry txtArg = new Entry();

public PgForm() : base("Ejecutar funciones"){
BorderWidth = 8;
SetDefaultSize(208,220);
this.DeleteEvent += new DeleteEventHandler(OnWindowDelete);
Frame frame = new Frame ("Ejecutar funciones");
Add (frame);
VBox MainPanel = new VBox (false, 8);
MainPanel.BorderWidth = 8;
frame.Add (MainPanel);
MainPanel.PackStart(new Label("Nombre de la funcion"),false,false,0);
MainPanel.PackStart(txtNameFunction,false,false,0);
MainPanel.PackStart(new Label("Si recibe un argumento de tipo varchar")
                   ,false,false,0);
MainPanel.PackStart(txtArg,false,false,0);
Button btnSubmit = new Button("Ejecutar funcion");
btnSubmit.Clicked += new EventHandler(btnSubmitClicked);
MainPanel.PackStart(btnSubmit,false,false,0);
MainPanel.PackStart(lbMsg,false,false,0);
lbMsg.LineWrap = true;
ShowAll();
}

public void OnWindowDelete(object o, DeleteEventArgs args) {
Application.Quit(); 
}

void btnSubmitClicked(object o, EventArgs args){
string cStr = "Server=127.0.0.1;Port=5432;User Id=postgres;" +
 "Password=postgres;Database=pubs;";
try{
using(NpgsqlConnection conn = new NpgsqlConnection(cStr))
{
conn.Open();
NpgsqlCommand cmd = new NpgsqlCommand(txtNameFunction.Text, conn);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
//en caso de tener un parametro como en nuestra funcion de ejemplo
if(txtArg.Text.Length > 0){
cmd.Parameters.Add(new NpgsqlParameter());
cmd.Parameters[0].NpgsqlDbType = NpgsqlDbType.Varchar;
cmd.Parameters[0].Value = txtArg.Text;
}
lbMsg.Text += cmd.ExecuteScalar().ToString();
}}catch(Exception e){
lbMsg.Text += e.Message;
}
}

static void Main(string[] args) {
Application.Init();
new PgForm();
Application.Run();
}} 
}

Compilamos y ejecutamos.

Podemos probar nuestro programa invocando la funcion version() predeterminada de PostgreSQL.

Al ejecutar la función sin argumentos desde el formulario se vera el mismo resultado.

Aquí el driver de PostgreSQL para .NET ejecuta la función usando la clase

NpgsqlCommand

la cual recibe como argumento el nombre de la función y la conexión al servidor donde se encuentra.

NpgsqlCommand cmd = new NpgsqlCommand(“version”, conn);

Si la función recibe parametros, debemos de crear una instancia de la clase

NpgsqlParameter()

por cada uno de los parametros que reciba, es muy importante no olvidar indicarle a la clase

NpgsqlCommand

que el comando que ejecutaremos es un stored procedure o una función pl/sql, esto lo hacemos mediante la instrucción:

cmd.CommandType = System.Data.CommandType.StoredProcedure;

Para mayor referencia no olvidar leer la documentación del data provider para PostgreSQL.
Si todo es ejecutado correctamente, ya podemos probar la función AddCities con el argumento del nombre de la ciudad y debe devolvernos la clave primaria de la tabla cities.

Descarga el código fuente

Tutorial de LINQ con C# y Mono

2010-04-04T13:46:00.000-07:00

En el número 15 de la revista Atix se publico un tutorial introductorio acerca de la utilización de LINQ (Language Integrated Query) con C#, la revista puede descargarse desde este enlace Revista Atix No 15.
El pdf de ese tutorial puede descargarse en este enlace Entendiendo LINQ con Mono y C# o bien en la sección documentos para descargar.

Patrones de diseño

2010-04-04T11:26:00.000-07:00

Los patrones de diseño son soluciones probadas en diferentes contextos que resuelven los problemas comunes de programación y desde la aparición del libro
"Design Patterns:Elements of Reusable Object Oriented Software"(Pearson Addison Wesley,1995) escrito por la famosisima Gang Of Four GoF (Erich Gamma,Richard Helm,Ralph Johnson, John Vlissides), han estado presentes en el desarrollo de software desde más decada, aunque su utilización es independiente del lenguaje de programación, han sido más conocidos y utilizados por los lenguajes orientados a objetos como C++,Java y por supuesto C#.
En el libro de GoF se describen 23 patrones agrupados en 3 categorías: estructurales, de creacion y de comportamiento.

De creación

Singleton

Factory

Abstract Factory

Builder

Prototype

Estructurales

Adapter

Bridge

Composite

Decorator

Facade

Flyweight

Proxy

De Comportamiento

Chain of Responsability

Command

Interpreter

Iterator

Mediator

Memento

Observer

State

Strategy

Template Method

Visitor

Los patrones de diseño se aplican en el diseño y en la arquitectura como formulas generales es decir: la idea con los patrones es que cuando se requiera resolver un problema, se identifique el problema y se aplique el patrón o los patrones adecuados para resolverlo, como una forma similar a los matemáticos que aplican una formula o varias formulas según se requiera para resolver un problema.
Lo bueno de esto es que una solución basada en patrones es reusable, extensible, mantenible y sobre todo elegante.

La segunda parte del tutorial de la revista Atix

2009-12-24T20:36:00.000-08:00

La revista Atix en su número 14 publicó la segunda parte del tutorial sobre XML utilizando MonoDevelop.

Los archivos del proyecto y el código fuente correspondientes al proyecto de ejemplo del tutorial pueden ser descargados en un archivo comprimido desde este enlace.

Descarga el código fuente

Archivos del proyecto de la Revista Atix

2009-10-05T23:04:00.000-07:00

La Revista Atix publicó la primera parte de un tutorial sobre XML utilizando MonoDevelop.

Desde este enlace se puede descargar un archivo comprimido, que contiene el código fuente del ejercicio y los archivos del proyecto.

Descarga el código fuente

Notas de Unified Modeling Language (UML)

2009-05-29T00:32:00.000-07:00

Hace ya casi un mes que terminé un curso de UML y hace un par de semanas que me llego el número de serie para activar Enterprise Architect, la cual es una herramienta muy útil para realizar los diagramas UML que sean requeridos por el proyecto, aunque siempre es bueno capacitarse, lo mejor es practicar.

Las notas que elaboré del curso son las siguientes:

Hay que tener en cuenta que para todo proyecto, sobre todo de sistemas existen un ¿qué hacer? (análisis o modelo conceptual) y un ¿cómo hacer? (diseño o modelo de clases), donde hay actores o agentes externos al sistema.
De todas las metodologías hay metodologías que cubren la parte de administración y la parte de ingeniería dentro de la misma metodología, dos ejemplos de metodologías que cubren estos dos aspectos de los proyectos son: Microsoft Solution Framework (MSF) y Rational Unified Process (RUP), las características principales de este último son:

Esta dirigido por casos de uso.
Centrado en la arquitectura (tecnología, hardware, aplicación) y un ciclo de vida
Es iterativo (cada dos o dos meses y medio entregar algo al cliente funcionando).

Este proceso toma una parte de la lógica del ciclo de vida en cascada, que tiene dos principios:

No se puede programar algo que no está diseñado.
No se puede probar algo que no está programado.

Buenas prácticas

solicitar una recomendación para nomenclatura de proceso.
solicitar procedimiento y reglamento.
objetivo del proceso.
usar verbos pasivos más el complemento para el nombre de las actividades.

Notas sobre los diagramas.

En los diagramas de actividades solo puede haber un estado inicial y un estado final.
Los diagramas de secuencia son uno a uno con los diagramas de casos de uso, es decir por cada diagrama de caso de uso debe de existir un diagrama de secuencia.
Cada diagrama no debe de tener más de nueve elementos en promedio de cinco a siete elementos.
Los actores primarios en el diagrama del caso de uso van del lado derecho y los actores secundarios van del lado izquierdo.
El término realización se refiere a que cada caso de uso realiza un requerimiento.
Nunca al redactarse un caso de uso se debe poner la palabra etc.
Siempre es bueno acompañar los diagramas con un glosario de términos.
Una forma de estimación de los casos de uso es la clasificación de actores, un ejemplo:
+-------------------------+
| Simple | 1 | Sistema |
+-------------------------+
| Mediana | 2 | Máquina |
+-------------------------+
| Dificíl | 3 | Humano |
+-------------------------+

En el modelo conceptual se muestran tanto las reglas físicas como las reglas de negocio.
El orden del ciclo hasta el diseño deberá ser:

Modelado del negocio: diagrama de Stakeholder y diagrama de proceso de negocio.

Requerimientos: matriz de requerimientos, matriz de trazabilidad y diagrama de casos de uso.

Análisis: descripción de alto nivel y especificación detallada de casos de uso.

Diseño: modelo conceptual, diseño detallado y prototipo.

Para aseguramiento de la calidad usar las revisiones de software y "poner puntos de control" es decir revisar los artefactos creados y regresar con el usuario.

El diagrama de comunicación solo muestra cuales son los mensajes.
El diagrama de secuencia muestra el orden en que deben de invocarse los mensajes.
Un escenario va de un estado inicial al estado final.
Siempre debemos de fijarnos entre la correspondencia entre el diagrama de secuencia y el diagrama de clases en cuanto a la multiplicidad, recordando que una multiplicidad se refiere a una colección.
En la nomenclatura de un diagrama de clases si se tiene dos puntos (:) se refiere a una instancia y si se tiene cuatro puntos (::) se refiere al namespace más la instancia.
Para hacer un diagrama de secuencia se debe de pensar en operaciones, en tiempo y en la responsabilidad.
Por buenas prácticas en el constructor solo se debe de poner los métodos que se inicialicen y se debe de separar de la invocación de los métodos.
Por estandarización no se ponen los retornos en el diagrama de secuencia, pero solamente si es necesario, la respuesta siempre regresa al actor que invoco el método.
Un caso de uso abstracto es un caso de uso que se utiliza para representar soluciones genéricas y se coloca dentro del paquete de casos de uso, este caso de uso se utiliza para ocurrencias que es una nota dentro del diagrama de secuencia que va hacia un diagrama de secuencia que está dentro del caso de uso abstracto.
La diferencia entre un diagrama de clases y un diagrama conceptual son los métodos, en el diagrama conceptual únicamente se muestran los atributos y la relación de los objetos además en el modelo conceptual se puede omitir el tipo de dato en cambio en el diagrama de clases es obligatorio poner el tipo de dato.
Una funcionalidad como los hilos (threads) solamente puede diagramarse en el diagrama de secuencia.
De un diagrama de secuencia puede sacarse el diagrama de colaboración o viceversa.
En un diagrama de actividades el estado inicial no es obligatorio.
En el diagrama de componentes existe el manifest: que indica una relación lógica entre el componente y un archivo físico.
En el diagrama de máquinas de estados, se ponen los objetos que más relaciones tienen además los diagramas de máquinas de estados son útiles en la etapa de análisis, aunque también pueden usarse en la etapa de diseño.

Esta herramienta también puede auxiliarnos en la etapa de desarrollo creando código desde el diagrama clases, aquí dependerá del lenguaje o los lenguajes que decidimos para el proyecto y por supuesto no olvidar que la notación de UML ayuda con un factor importante en los proyectos: la comunicación.

Ingeniería de software

2009-05-26T15:46:00.000-07:00

Hace un par de semanas me solicitaron la elaboración de dos propuestas, una para la migración y otra para un nuevo desarrollo por lo me solicitaron hacer un resumen general sobre Metodologías RUP, MSF y XP, el mismo para ambas propuestas, el resultado fue el siguiente:

Microsoft Solution Framework (MSF) proporciona un conjunto de modelos, principios, y guías para diseñar y desarrollar soluciones empresariales de una manera que asegura que todos los elementos del proyecto tal como gente, procesos y herramientas, puedan ser exitosamente conducidos. No solamente es aplicable a los proyectos de desarrollo sino igualmente a los de infraestructura o redes. MSF actualmente tiene dos instancias: MSF for Agile Software Development y MSF for CMMI (Capability Maturity Model Integration) Process Improvement.MSF contiene un meta-modelo que estaba basado en la filosofía de que un proceso esta creado para ayudar y no para estorba, este modelo es compartido para procesos agiles y maduros que ocupen MSF.MSF consta de cinco fases: Previsión, Planificación, Desarrollo, Estabilización e Implementación y es continuamente refinado por clientes, consultores, grupos de producto y partners de Microsoft.

Rational United Process (RUP) Es un refinamiento del proceso unificado, sus características principales son combinar las prácticas comúnmente aceptadas de los procesos incremental e iterativo. Su objetivo principal es entregar artefactos verificables por el cliente. El énfasis en el desarrollo iterativo e incremental previene muchos de los riesgos comunes en los proyectos al animar al equipo a desarrollar en principio lo más riesgoso del proyecto, además de que los artefactos y los roles de los participantes están bien definidos y que el proceso esta soportado por muchas herramientas de desarrollo, el proceso toma en cuenta que cada proyecto es diferente, con necesidades diferentes y habilita para que cada fase del proyecto sea personalizada para lo requerido por el proyecto. Este proceso comienza con la toma de requerimientos, el análisis y el diseño para todo el proyecto incluyendo el modelado de datos y de objetos antes de la construcción. En este sentido toma un enfoque de proceso en cascada para el análisis y el diseño y un enfoque iterativo para la construcción y la liberación.

Extreme Programming (XP) Los procesos ágiles mueven el enfoque de desarrollo de software hacia lo que se considera la importancia del desarrollo de software: ejecutar software. Esto es posible si se acepta que el desarrollo de software es un trabajo creativo hecho por seres humanos individuales, por eso este proceso anima a la comunicación, interacción y diversión. XP se distingue de otras metodologías en: es inmediato, concreto y se retroalimenta en ciclos muy cortos, tiene flexibilidad para programar las funcionalidades en acuerdo con los cambios en los requerimientos, se confía de pruebas automatizadas escritas por los programadores y clientes para monitorear el progreso del desarrollo que permite una detección de pruebas tempranas, se confía de la comunicación oral y el código fuente para mostrar la estructura del programa, tiene confianza en la cercana colaboración de los programadores con habilidades ordinarias. XP es diseñado para trabajar con proyectos que pueden ser construidos por equipos de dos a diez programadores.

En la revisión de las propuestas por parte del cliente, se selecciono la metodología MSF para el nuevo desarrollo y RUP para la migración, lo interesante de esta elección es que la tecnología empleada por el cliente en ambos proyectos es .NET, por lo que la elección natural hubiera sido MSF sin miramientos.

Pero bueno el cliente es el cliente y sus razones tendrá, aunque esta decisión no es tan dispar como pudiera parecerse, ya que MSF y RUP comparten una gran cantidad de artefactos, por lo que solo deberé que usar lo común a las dos metodologías.

Prueba de conocimientos

2009-04-12T07:38:00.000-07:00

Hace un par de meses con motivo de una consultoría una empresa transnacional me hizo un examen sobre conocimientos en C#, este examen me ha llamado la atención por el tipo de preguntas, que me da la impresión que era de un examen de Java y solo ajustaron las preguntas para C#, incluso en algunas preguntas decian "In Java we can .....bla,bla in C# how to .....bla,bla", como si asumieran que el entrevistado además de C# conoce Java, casos que no siempre es asi, algunas preguntas son en verdad muy buenas para conocer el nivel de programación.

Entre las preguntas se encontraban algunas que bien se podria responder dependiendo de la situación:

If you need to modify a value parameter to a function, which of the following can you do to achieve this?

1-. use a ref keyword
2-. use an out keyword
3-. use the return keyword
4-. All of Above

True or false Like in C++, using exception does carry some performance penalty.
1-. true
2-. false

if we want to hide a non virtual method, public void Print(), was the way to declare the method in the derived class?

1-.public void Print();
2-.public virtual void Print();
3-.public override void Print();
4-.public new void Print();

To catch all exceptions, which of the following would you declare?
1-.catch(...)
2-.catch(exception e)
3-.catch(throwable t)
4-.catch

En lo particular me gusta este tipo de exámenes ya que todas las respuestas son soluciones y solo es correcta la mejor, es decir la que es considerada como una buena práctica (best practice).

Code Access Security CAS, la seguridad en el código

2009-03-05T19:42:00.000-08:00

CAS (Code Access Security), es la forma en que los ensamblados solicitan permisos para acceder a ciertos recursos para su ejecución en el CLR, esto proporciona seguridad a nivel código,como una forma complementaria y adicional a la seguridad del sistema operativo.
Esta seguridad debe estar presente sobre todo si de desarrollan componentes, plugins, add-ons o juegos que serán ejecutados en diferentes ambientes que no conocemos ni controlamos.
Señalo que esta seguridad es complementaria y en ningún momento deberá reemplazar la seguridad del sistema operativo.
Para explicar voy a usar un ejemplo, un banco nos solicito realizar un aplicación donde el usuario genera unos archivos de estados de cuenta esta aplicación en un diseño inicial esta compuesta por un formulario y un ensamblado que se encarga de generar el estado de cuenta en un archivo XML.
Obviamente una aplicación de esta naturaleza, necesitaría una disciplina de análisis y diseño, pero para fines ilustrativos, logramos llegar a la etapa de construcción sin la utilización del CAS.
La aplicación se mostraría más o menos así,

La operación de la aplicación consiste que cuando el usuario presione el botón de generar, se generaría un archivo XML en una carpeta restringida para ciertos usuarios, el código del método del ensamblado es el siguiente:

public void WriteBank(string fileName)
{
try
{
string rootpath = string.Format(@"C:{0}Banks{0}",Path.DirectorySeparatorChar);
if(!Directory.Exists(rootpath))
Directory.CreateDirectory(rootpath);
XmlTextWriter tw = new XmlTextWriter(rootpath + fileName,Encoding.UTF8);
tw.Formatting = Formatting.Indented;
tw.WriteStartDocument();
tw.WriteStartElement("BankStatement");
tw.WriteElementString("Date",Fecha);
tw.WriteElementString("Bank",Banco);
tw.WriteElementString("MovementType",TipoMovimiento);
tw.WriteElementString("Description",Descripcion);
tw.WriteElementString("Amount",Monto);
tw.WriteEndDocument();
tw.Flush();
tw.Close();
}
catch{ throw;}
}

El método de la aplicación para invocar el método del ensamblado es el siguiente:

void BtnGenerarClick(object sender, EventArgs e)
{
try{
Ensamblado1 ensamblado1 = new Ensamblado1();
ensamblado1.Banco = cbBanco.SelectedItem.ToString();
ensamblado1.TipoMovimiento = cbTipoMovimiento.SelectedItem.ToString();
ensamblado1.Descripcion = txtDescripcion.Text;
ensamblado1.Monto = txtMonto.Text;
ensamblado1.WriteBank(string.Format("{0}{1}.xml",ensamblado1.Banco,ensamblado1.Fecha.Replace("/","_")));
}
catch(ApplicationException appex){ MessageBox.Show(appex.Message);}
catch(Exception ex){MessageBox.Show(ex.Message);}
}

La aplicación es utilizada sin ningún problema hasta que varios archivos de estados de cuenta no coinciden al utilizarlos en la contabilidad, se encuentran localizados en una ubicación que no es la ruta predeterminada y el sistema operativo no indica ninguna excepción en las bitácoras de seguridad.
Supongamos que un usuario autenticado construye un programa malintencionado que ejecuta el método de nuestro ensamblado para escribir los estados de cuenta afuera de la carpeta predeterminada un código como el siguiente:

using System;

namespace Godel.Posts {
class SinPermiso {
[STAThread]
static void Main() {
try {
Console.WriteLine("Creando estado de cuenta...");
Ensamblado1 ensamblado1 = new Ensamblado1();
ensamblado1.Banco = "BankHack";
ensamblado1.Descripcion = "Deposito para pagar todas mis deudas";
ensamblado1.Monto = "10000";
ensamblado1.TipoMovimiento = "Deposito";
ensamblado1.WriteBank(string.Format("..\\{0}{1}.xml",ensamblado1.Banco,ensamblado1.Fecha.Replace("/","_")));
Console.WriteLine("Estado de cuenta creado");
}
catch(Exception ex){ Console.WriteLine(ex.StackTrace);}
Console.Read();
}
}
}

Para compilar este código usamos:
csc /r:Ensamblado1.dll SinPermiso.cs
Con la opción /r le indicamos al compilador, que haga referencia al metadata del ensamblado indicado, en este caso al Ensamblado1 donde se encuentra el método para generar estados de cuenta.
Al revisar los códigos observamos que el método esta implementado para generar los archivos debajo de una carpeta llamada [Banks] en la partición [C:\\] y que la protección de los valores del ensamblado dependerá de las validaciones que implementemos en el formulario de la aplicación, mas no del ensamblado mismo, por eso al invocar el método y pasar le la cadena con una secuencia ..\\ indicamos al ensamblado que escriba el archivo un nivel arriba.

Más que buscar un culpable a nivel usuario, la pregunta se plantea a nivel código:
¿como podemos evitar que el código realice operaciones para las que no fue diseñado?
La respuesta sin duda alguna es uno de los objetivos del CAS.
Usando CAS podemos evitar que un usuario o un proceso autenticado utilice los métodos del ensamblado para realizar acciones que no están consideradas en la lógica del programa.
Para lograr ese objetivo CAS utiliza permisos encapsulados como objetos que pueden ser usados a nivel de métodos o ensamblados, estos permisos pueden ser de manera declarativa usados como o como atributos dentro del código, en este ejemplo usaremos un permiso de forma declarativa para nuestro método.
[FileIOPermission(SecurityAction.PermitOnly,Write="C:\\Banks")]

public void WriteBank(string fileName)
{
try
{
string rootpath = string.Format(@"C:{0}Banks{0}",Path.DirectorySeparatorChar);
if(!Directory.Exists(rootpath))
Directory.CreateDirectory(rootpath);
XmlTextWriter tw = new XmlTextWriter(rootpath + fileName,Encoding.UTF8);
tw.Formatting = Formatting.Indented;
tw.WriteStartDocument();
tw.WriteStartElement("BankStatement");
tw.WriteElementString("Date",Fecha);
tw.WriteElementString("Bank",Banco);
tw.WriteElementString("MovementType",TipoMovimiento);
tw.WriteElementString("Description",Descripcion);
tw.WriteElementString("Amount",Monto);
tw.WriteEndDocument();
tw.Flush();
tw.Close();
}
catch{ throw;}
}
Los permisos representan acciones que son revisadas cada vez que el CLR carga el ensamblado para ejecutarse, estos permisos son controlados por el CAS.

UIPermission Controla la manipulación a la interfaz de usuario y el portapapeles.
ResourcePermissionBase Controla el acceso a los recursos de Windows
RegistryPermission Controla el acceso al Registro de Windows
ReflectionPermission Controla el acceso a la funcionalidad de la reflexión proporcionada por el CLR
IsolatedStoragePermission Controla el acceso a isolated storage
FileIOPermission Controla el acceso de escritura o lectura al disco duro
FileDialogPermission Controla el acceso a archivos o carpetas.
EnviromentPermission Controla el acceso a leer, modificar y crear variables de ambiente.

Si ejecutamos nuevamente el código para escribir los estados de cuenta fuera de la carpeta predeterminada con el ensamblado modificado, se mostrará el siguiente error.

Ahora nuestro ensamblado esta protegido por la seguridad del CAS y no depende de la validación que implementen las clases que invoquen sus métodos.

Para habilitar o des habilitar la seguridad del CAS se utiliza la herramienta caspol con el siguiente argumento:
caspol -s on
Siempre es recomendable habilitar la seguridad del CAS.
Para compilar la aplicación:
csc /r:Ensamblado1.dll EstadosCuenta.cs EstadosCuenta.Designer.cs

Descarga el código fuente

70-340 Implementando seguridad de aplicaciones C#

2009-02-23T21:46:00.000-08:00

El día sábado presente el examen de certificación "70-340 Implementing Security applications with C#" que trata sobre seguridad de las aplicaciones .NET independientemente si son de tipo escritorio,Web o de consola, los temas igualmente aplican para las aplicaciones desarrolladas con Mono.

Este examen esta basado en el FrameWork .NET 1.1 (Visual Studio 2003, Mono 1.1) por lo que los temas y su ejemplos los ejecuté en mi vieja portátil que conserva este ambiente.

Entre los temas que trata están:

- CAS (Code Access Security)
- Autenticación
- Autorización
- SQL Injection
- Buenas prácticas de codificación (validar todas las entradas del usuario, uso de bloques try/catch/finally, uso de una cuenta con el menor privilegio)

Al final pase el examen con un mínimo necesario: 721 de 700.

Este examen se mantendrá hasta el mes de Marzo y sera retirado de las carreras de certificación.

Bibliografía recomendada:

Writing Secure Code, Second Edition: Michael Howard and David Leblanc

Professional C# 3rd Edition: Simon Robinson, Christian Nagel, Karli Watson, Jay Glynn, Morgan Skinner, Bill Evjen