Aprendiendo.NET

Como hacer un servicio de Windows auto instalable

2010-09-17T06:38:00.000-07:00

Todos nos hemos encontrado en la situación de tener que instalar un servicio, y utilizar el comando installutil.exe, pero por qué no ahorrarnos un paso y hacer que el servicio sea auto instalable?

Este tip no tiene mayor secreto, simplemente es un atajo al installutil.exe dentro del ejecutable de nuestro servicio.

Lo que haremos será ir a la clase Program.cs en C# o Módulo Main.vb eb VB y modificar el método main de la siguiente manera:


static class Program
    {
        /// 
        /// The main entry point for the application.
        /// 

        static void Main(String[] args)
        {
            if (args.Length > 0)
            {
                switch (args[0])
                {
                    case "/install":
                        install();
                        break;
                    case "/uninstall":
                        uninstall();
                        break;
                }
            }
            else
            {
                ServiceBase[] ServicesToRun;
                ServicesToRun = new ServiceBase[] { new SecurityProviderService() };
                ServiceBase.Run(ServicesToRun);
            }
        }
    }

Lo que hicimos fue agregarle a nuestro ejecutable la posibilidad de recibir parámetros, en éste caso /install o /uninstall, sólo nos resta crear los métodos para ejecutar éstas acciones y listo.


        // Devuelve la ruta a installutil.exe
        private static String installUtill()
        {
            return System.IO.Path.Combine(System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(), "installutil.exe");
        }

        private static void uninstall()
        {
            if (System.IO.File.Exists(installUtill()))
            {
                System.Diagnostics.Process.Start(installUtill(), String.Format("/u \"{0}\"", System.Reflection.Assembly.GetExecutingAssembly().Location));
                System.Diagnostics.Trace.WriteLine("Service uninstalled.");
            }
            else
                throw new System.IO.FileNotFoundException("InstallUtil.exe not found");
        }

        private static void install()
        {
            if (System.IO.File.Exists(installUtill()))
            {
                System.Diagnostics.Process.Start(installUtill(), String.Format("\"{0}\"", System.Reflection.Assembly.GetExecutingAssembly().Location));
                System.Diagnostics.Trace.WriteLine("Service installed.");
            }
            else
                throw new System.IO.FileNotFoundException("InstallUtil.exe not found");
        }

Muy simple, ahora cuando necesitemos instalar nuestro servicio simplemente lo haremos desde una consola ejecutando NombreDelServicio.exe /install

Referencia de atajos de teclado para Visual Studio 2010

2010-08-16T05:29:00.000-07:00

Desde la web de Microsoft, nos ofrecen una serie de archivos PDF con los atajos de teclado para Visual Studio 2010.

Descargar

Como acceder a la propiedad Text de un control NumericUpDown

2009-10-14T11:24:00.000-07:00

Hoy me encontré con un problemita trabajando sobre un formulario que contiene varios NumericUpDown. El tema es que se podía seleccionar un valor, luego borrarlo y el sistema no hacía una validación que indicara al usuario que debía introducir un valor.

Al empezar a hacer pruebas noté que el texto queda vacío, pero el valor no cambia, o sea que si el NumericUpDown tiene un valor de 75 y le borramos el texto, al acceder a la propiedad Value del mismo, ésta nos devuelve 75.

El problema para solucionar ese bug me lo encontré cuando intenté acceder a la propiedad Text, para chequear que la misma no contenga un String vacío... Oh sorpresa, no se puede acceder a esa propiedad porque es privada!!

Para acceder a la propiedad Text aprovecharemos de la herencia de esta clase, NumericUpDown es una subclase de Control, entonces al hacer un cast podemos acceder a la propiedad Text para hacer el chequeo.
Esto nos permite varias soluciones posibles, una que me pareció bastante elegante fue asignar un event handler, o manejador de eventos al evento TextChanged, al cual también accederemos mediante un cast a Control.

Solución:


Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
  For Each c As Control In Me.Controls
    If TypeOf c Is NumericUpDown Then
      AddHandler c.TextChanged, AddressOf NumericUpDownControls_TextChanged
    End If
  Next
End Sub

Private Sub NumericUpDownControls_TextChanged(ByVal sender As Object, ByVal e As System.EventArgs)
  If CType(sender, Control).Text = String.Empty Then
    CType(sender, Control).Text = CType(sender, NumericUpDown).Value.ToString()
  End If
End Sub

Otra posible solución, más eficiente desde el punto de vista de reusabilidad sería crear un control que herede de NumericUpDown y ya implemente de por si este comportamiento; que a mi entender es una falta de parte del equipo que desarrolló el control.

Deshabilitar el Cortar / Copiar de líneas vacías en Visual Studio

2009-06-08T07:21:00.000-07:00

Un comportamiento muy molesto de Visual Studio es cuando por error copias o cortas una línea vacía, o sin seleccionar nada... hasta hace un tiempo pensaba que era el comportamiento normal del IDE, pero un día hurgando en la ventana de opciones me encontré con que se puede desactivar.

Extendiendo la clase List(Of T)

2009-05-07T11:39:00.000-07:00

Hoy necesité exportar el contenido de una Lista a un DataTable, entonces pensé:

Crear una tabla con la estructura necesaria

Recorrer la lista secuencialmente y agregar filas a la tabla

Pero pensando como programador, se me ocurrió que seguramente volviera a necesitar esta función y posiblemente la necesitaría con diferentes tipos de listas.

Como era lógico, pensé en Generics, entonces me creé una función que recibe una System.Collections.Generic.List(Of T) y devuelve un System.Data.DataTable con la siguiente firma:

Public Function ListToDataTable(Of T)(List As System.Collections.Generic.List(Of T)) As System.Data.DataTable

después creé toda la lógica utilizando System.Reflection para examinar las propiedades, y aprovechando los CustomAttributes para poder ocultar propiedades, entonces para hacer un Test, hice una clase con la siguiente estructura:


Public Class MiClase

    Private mId As Integer
    Private mNombre As String
    Private mCantidad As Integer

     _
    Public Property Id() As Integer
        Get
            Return mId
        End Get
        Set(ByVal value As Integer)
            mId = value
        End Set
    End Property

    Public Property Nombre() As String
        Get
            Return mNombre
        End Get
        Set(ByVal value As String)
            mNombre = value
        End Set
    End Property

    Public Property Cantidad() As Integer
        Get
            Return mCantidad
        End Get
        Set(ByVal value As Integer)
            mCantidad = value
        End Set
    End Property

    Public Sub New()

    End Sub

    Public Sub New(ByVal Id As Integer, ByVal Nombre As String, ByVal Cantidad As Integer)
        mId = Id
        mNombre = Nombre
        mCantidad = Cantidad
    End Sub

End Class

como ven, la propiedad Id tiene un CustomAttribute, el System.ComponentModel.BrowsableAttribute seteado con el valor False, o sea que esa propiedad estaría excluida de la exportación.

Todo muy lindo, funcionó a la perfección... pero se me ocurrió algo mejor... usar Extension Methods o métodos de extensión, esa nueva posibilidad que nos brinda el .Net Framework 3.5 de extender clases sin la necesidad de tener el código fuente de la misma.

Entonces creé un módulo llamado ListExtension y le asigné el mismo Namespace de la lista, System.Collections.Generic.


Imports System.Reflection
Imports System.ComponentModel
Imports System.Runtime.CompilerServices

Namespace System.Collections.Generic
    Module ListExtension
        ''' 
        ''' Gets a Datatable with all Browsable properties of T as columns containing all Items in the List.
        ''' 

        ''' 
        ''' System.Collections.Generic.List(Of T)
        ''' System.Data.DataTable
        ''' http://aprendiendonet.blogspot.com
         _
        Public Function ToDataTable(Of T)(ByVal List As List(Of T)) As DataTable
            Dim dt As New DataTable()

            Dim tipo As Type = GetType(T)
            Dim members As MemberInfo() = tipo.GetMembers() ' Obtenemos todos los Miembros de la clase correspondiente al tipo T

            For Each m As MemberInfo In members
                If m.MemberType = MemberTypes.Property Then ' Sólo nos interesan las propiedades
                    Dim skip As Boolean = False

                    Dim atts As Object() = m.GetCustomAttributes(GetType(BrowsableAttribute), False) ' Chequeamos si tiene BrowsableAttribute
                    If atts.Length > 0 Then
                        If CType(atts(0), BrowsableAttribute).Browsable = False Then
                            skip = True ' Seteamos un flag para no agregar la columna
                        End If
                    End If

                    If Not skip Then
                        Dim c As DataColumn = Nothing
                        Try
                            c = New DataColumn(m.Name, CType(m, PropertyInfo).PropertyType) ' Nueva columna con el nombre de la propiedad y el tipo de la misma
                        Catch ex As Exception
                            c = New DataColumn(m.Name, GetType(String)) ' En caso de error intento crearla como String
                        End Try
                        dt.Columns.Add(c)
                    End If
                End If
            Next

            For Each itm As T In List ' Recorro la lista y agrego una fila por cada item de la misma
                Dim r As DataRow = dt.NewRow()
                For Each c As DataColumn In r.Table.Columns
                    Dim aux As MemberInfo() = tipo.GetMember(c.ColumnName)
                    If aux.Length > 0 Then
                        r(c.ColumnName) = CType(aux(0), PropertyInfo).GetValue(itm, Nothing)
                    End If
                Next
                dt.Rows.Add(r)
            Next

            Return dt
        End Function

    End Module
End Namespace

Entonces ahora en toda mi solución tengo la posibilidad de exportar mis Listas a DataTable con tan solo llamar a este método de extensión:

Dim auxDT as DataTable = miLista.ToDataTable()

Como dejar un log en el Visor de Sucesos de Windows

2009-04-29T12:49:00.000-07:00

Todos hemos visto el Visor de Sucesos de Windows, y a veces es una buena alternativa para guardar registros de nuestras aplicaciones, ya que nos evita el tener que definirnos una estructura de logs.

Suele ser muy útil cuando desarrollamos un Servicio de Windows y queremos llevar registro de excepciones o ciertas situaciones... por eso el ejemplo de hoy se trata de crear un log para nuestra aplicación utilizando la clase EventLog del Namespace System.Diagnostics.


        Public Sub EscribirEventLog(ByVal Origen As String, ByVal Mensaje As String, ByVal Equipo As String, ByVal TipoDeEntrada As EventTipoDeEntrada)
            If Not EventLog.SourceExists(Origen, Equipo) Then ' Si el origen no existe lo creamos
                EventLog.CreateEventSource(Origen, "GNSys", Equipo)
            End If

            Dim eLog As New EventLog("GNSys", Equipo, Origen) ' Instanciamos la clase EventLog
            eLog.WriteEntry(Mensaje, TipoDeEntrada, GetSafeShort(111), GetSafeShort(1)) ' Escribimos la entrada
        End Sub

En el código anterior, (que por cierto es muy sencillo), en la línea que escribe nuestra entrada de log hay datos que deberemos definir en función de nuestras necesidades, veamos la línea y cómo está formada:

eLog.WriteEntry([Event], LogEntryType, GetSafeShort(111), GetSafeShort(1))

La firma del método WriteEntry es la siguiente:

Public Shared Sub WriteEntry(ByVal source As String, ByVal message As String, ByVal type As System.Diagnostics.EventLogEntryType, ByVal eventID As Integer, ByVal category As Short)

Viendo la siguiente imágen se puede ver qué es cada campo.

Como leer y escribir en el Registro de Windows desde una aplicación .NET

2009-04-28T09:51:00.000-07:00

Para trabajar sobre el registro de Windows utilizaremos las cases Registry y RegistryKey del Namespace Microsoft.Win32. Con éstas 2 clases podremos realizar todas tareas de lectura y escritura en el registro.
Este es un ejemplo muy sencillo, por lo tanto vamos a crear una clave Key, dentro crearemos un valor Value luego los eliminaremos. Después leeremos todos los Values que se encuentren en HKLM\Microsoft\Windows\CurrentVersion\Run, que son los que indican qué aplicaciones se ejecutan al iniciar Windows para todos los usuarios.

Debajo de estas líneas está el código, uno de los ejemplos más sencillos para leer y escribir en el Registro de Windows.


Imports Microsoft.Win32
Public Class Form1

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        CrearKey()
    End Sub

    Private Sub CrearKey()
        Dim KeyPath As String = "Software\Test"
        Registry.CurrentUser.CreateSubKey(KeyPath)
    End Sub


    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        CrearValue()
    End Sub

    Private Sub CrearValue()
        Dim KeyPath As String = "Software\Test"
        Dim ValueName As String = "TestValue"

        Dim key As RegistryKey = Registry.CurrentUser.OpenSubKey(KeyPath, True) ' True indica que se abre para escritura
        If key IsNot Nothing Then ' Si key es Nothing significa que no se encontró
            key.SetValue(ValueName, "Esto es una prueba", RegistryValueKind.String)
        Else
            If MessageBox.Show(String.Format("No se encontró la clave 'HKCU\{0}'. Desea crearla?", KeyPath), "", MessageBoxButtons.YesNo, MessageBoxIcon.Question) = Windows.Forms.DialogResult.Yes Then
                CrearKey() ' Creamos la clave y volvemos a intentar crear el valor
                CrearValue()
            End If
        End If
    End Sub


    Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
        EliminarValue()
    End Sub

    Private Sub EliminarValue()
        Dim KeyPath As String = "Software\Test"
        Dim ValueName As String = "TestValue"

        Dim Key As RegistryKey = Registry.CurrentUser.OpenSubKey(KeyPath, True)

        If Key IsNot Nothing Then
            If Key.GetValueNames().Contains(ValueName) Then ' Buscamos el nombre del valor en la lista de todos los valores de la clave
                Key.DeleteValue(ValueName) ' Borramos el valor
            Else
                MessageBox.Show(String.Format("No se encontró el valor '{0}'.", ValueName))
            End If
        Else
            MessageBox.Show(String.Format("No se encontró la clave 'HKCU\{0}'.", KeyPath))
        End If
    End Sub

    Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.Click
        EliminarKey()
    End Sub

    Private Sub EliminarKey()
        Dim KeyPath As String = "Software\Test"

        Dim key As RegistryKey = Registry.CurrentUser.OpenSubKey(KeyPath)

        If key IsNot Nothing Then
            Registry.CurrentUser.DeleteSubKey(KeyPath) ' Borramos la sub clave
        Else
            MessageBox.Show(String.Format("No se encontró la clave 'HKCU\{0}'.", KeyPath))
        End If
    End Sub


    Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button5.Click
        LeerRegistro()
    End Sub

    Private Sub LeerRegistro()
        Dim KeyPath As String = "Software\Microsoft\Windows\CurrentVersion\Run"
        Dim key As RegistryKey = Registry.LocalMachine.OpenSubKey(KeyPath, False) ' Abrimos para sólo lectura

        If key IsNot Nothing Then
            Dim sb As New System.Text.StringBuilder()

            Dim values As String() = key.GetValueNames() ' Obtenemos los nombres de todos los valores en la key
            For Each value As String In values
                sb.AppendLine(String.Format("{0}   >   {1} ({2})", value, key.GetValue(value), key.GetValueKind(value).ToString()))
            Next

            Me.TextBox1.Text = sb.ToString() ' Mostramos el resultado en nuestra TextBox Multilínea
        End If
    End Sub
End Class

Como imprimir un formulario - Microsoft.VisualBasic.PowerPacks.Printing.PrintForm

2009-03-09T06:19:00.000-07:00

Este código muestra una forma sencilla de imprimir un formulario, para lo cual utilizaremos la clase PrintForm, que se encuentra en el Namespace Microsoft.VisualBasic.PowerPacks.Printing.

Lo primero que haremos será chequear si tenemos la referencia, para lo cual haremos click con el botón derecho sobre nuestro cuadro de herramientas y en el menú seleccionaremos la opción Choose Items..., cuando se abra el diálogo para seleccionar las referencias buscaremos la que corresponde al namespace antes mencionado y si no está seleccionada la seleccionaremos en este momento.

Puede ocurrir que no se muestre en el cuadro de herramientas, para poder verla haremos un click con el botón derecho sobre el cuadro de herramientas y en el menú seleccionaremos la opción Show All, que nos agregará varias secciones al cuadro de herramientas, la que buscamos se encuentra bajo el título de VisualBasic PowerPacks.

Ahora ya podemos arrastrar este componente a nuestro form y crear el siguiente método para poder imprimir el formulario:

    Private Sub Imprimir()
        PrintForm1.PrintAction = Printing.PrintAction.PrintToPreview ' Crea una vista previa
        ' PrintForm1.PrintAction = Printing.PrintAction.PrintToFile ' Imprime a un archivo
        ' PrintForm1.PrintAction = Printing.PrintAction.PrintToPrinter ' Envía a la impresora
        PrintForm1.Print() ' Finalmente hacemos la impresión
    End Sub

Utilizando el portapapeles de Windows en nuestras aplicaciones .NET

2009-02-27T04:49:00.000-08:00

Para manejar el portapapeles de Windows, el .Net Framework provee la clase Clipboard, del namespace My.Computerla cual posee todo lo necesario para copiar y pegar archivos, textos, imágenes, etc.

Veamos como copiar elementos al portapapeles:

My.Computer.Clipboard.SetImage(PictureBox1.Image) - Copia la imagen del picturebox

My.Computer.Clipboard.SetText(WebBrowser1.DocumentText, TextDataFormat.Html) - Copia el código HTML del documento que estamos mostrando en el WebBrowser como texto y setea el formato de éste como HTML.

My.Computer.Clipboard.SetText(RichTextBox1.Rtf, TextDataFormat.Rtf) - Ídem anterior pero formato RTF.

My.Computer.Clipboard.SetText(TextBox1.Text) - Copia un texto cualquiera, sin formato.

My.Computer.Clipboard.SetData(MyClassInstance.GetType().Name, MyClassInstance) - Copia el objeto MyClassInstance al portapapeles.

Ahora tenemos que recuperar los objetos que copiamos al portapapeles:

PictureBox2.Image = My.Computer.Clipboard.GetImage() - Recupera la imagen copiada al portapapeles y la setea como Image en el PictureBox2.

WebBrowser2.DocumentText = My.Computer.Clipboard.GetText(TextDataFormat.Html) - Obtiene el texto con formato HTML

RichTextBox2.Rtf = My.Computer.Clipboard.GetText(TextDataFormat.Rtf) - Idem anterior con formato RTF.

TextBox2.Text = My.Computer.Clipboard.GetText() - Recupera un texto sin formato y lo asigna en TextBox2.Text

Dim MyClassNewInstance As MyClass = CType(My.Computer.Clipboard.GetData(GetType(MyClass).Name), MyClass) - Recupera el objeto de tipo MyClass que copiamos anteriormente.

Para limpiar ó vaciar el portapapeles utilizaremos:

My.Computer.Clipboard.Clear()

Algunos controles que podemos hacer sobre la info contenida en el portapapeles:

If My.Computer.Clipboard.ContainsImage() Then - Para saber si hay una imagen en el portapapeles

If My.Computer.Clipboard.ContainsText(TextDataFormat.Html) - Para saber si el portapapeles contiene un texto en formato HTML

If My.Computer.Clipboard.ContainsData(GetType(MyClass).Name) Then - Comprueba si hay un objeto del tipo MyClass en el portapapeles.

Al preguntar por My.Computer.Clipboard.ContainsText(), se puede preguntar por varios formatos, los mismos se especifican en el Enum TextDataFormat:

CommaSeparatedValue

Html

Text

UnicodeText

Y ese sería un resumen de los usos más frecuentes del portapapeles, aunque también se puede utilizar de varias maneras más, estas son las que consideré más útiles.

Una aclaración con respecto a copiar y pegar objetos, yo utilicé como nombre del formato el nombre del tipo tal cual se devuelve por GetType().Name, en ese parámetro se puede escribir cualquier String, pero considero una buena práctica utilizar el nombre del tipo para que al recuperar sepamos qué es lo que estamos buscando.

Trabajando con Archivos y Carpetas: System.IO.Path

2009-02-11T07:27:00.000-08:00

La clase System.IO.Path provee una serie de métodos para realizar las tareas más comunes a la hora de trabajar con rutas de archivos o directorios, a continuación veremos los métodos de esta clase y para qué sirve cada uno.

System.IO.Path.AltDirectorySeparatorChar : Devuelve el caracter alternativo usado como separador de directorios en el sistema actual. Generalmente "/".

System.IO.Path.ChangeExtension("C:\prueba.txt", "xml") : Cambia la extensión del archivo pasado como primer parámetro, en este ejemplo devuelve C:\prueba.xml.

System.IO.Path.Combine("C:\Directorio1\", "prueba.xml") : Combina ambas rutas para generar una sola. Atención al segundo parámetro porque si empieza con el separador de directorio no funcionará como esperamos.

System.IO.Path.DirectorySeparatorChar : Devuelve el caracter usado como separador de directorios en el sistema actual. Generalmente "\".

System.IO.Path.GetDirectoryName("C:\Directorio1\prueba.txt") : Devuelve la ruta al directorio según la ruta que recibe por parámetro. En este ejemplo devuelve "C:\Directorio1"

System.IO.Path.GetExtension("C:\Directorio1\prueba.xml") : Devuelve la extensión del archivo que recibe por parámetro, por el ejemplo ".xml" si el archivo no tiene extensión devuelve "".

System.IO.Path.GetFileName("C:\Directorio1\prueba.xml") : Devuelve el nombre del archivo especificado en el parámetro sin el resto de la ruta. En este ejemplo devuelve "prueba.xml". Si la ruta especificada termina con el separador de directorios, devuelve "".

System.IO.Path.GetFileNameWithoutExtension("C:\Directorio1\prueba.xml") : Idem que GetFileName() pero sin extensión. En el ejemplo "prueba"

System.IO.Path.GetFullPath("C:") Devuelve la ruta actual sobre la unidad C: Por ejemplo "C:\miApp\bin\Debug

System.IO.Path.GetFullPath("\prueba1") : Devuelve la ruta absoluta, toma en cuenta la unidad actual o la ruta actual.

System.IO.Path.GetInvalidFileNameChars() : Devuelve los caracteres que no pueden formar parte del nombre de un archivo

System.IO.Path.GetInvalidPathChars() : Devuleve los caracteres no válidos para una ruta.

System.IO.Path.GetPathRoot("C:\Directorio1\prueba.xml") : Devuelve la raíz de la ruta especificada, en este caso "C:\"

System.IO.Path.GetRandomFileName() : Devuelve un nombre randómico para usar como nombre de archivo o directorio.

System.IO.Path.GetTempFileName() : Devuelve un nombre de archivo temporal, apuntando al directorio especificado en %TEMP%. Por ejemplo "C:\Documents and settings\usuario\Configuración local\Temp\tmp131E.tmp"

System.IO.Path.GetTempPath() : Devuelve la ruta al directorio temporal, siguiendo con el ejemplo anterior, "C:\Documents and settings\usuario\Configuración local\Temp\"

System.IO.Path.HasExtension("C:\prueba.xml") : Devuelve un valor Boolean indicando si la ruta especificada contiene una extensión, en el ejemplo la extensión es ".xml" o sea que devuelve True

System.IO.Path.IsPathRooted("..\Directorio1\prueba.xml") : Devuelve un valor Boolean indicando si la ruta especificada es absoluta o no, en el ejemplo la ruta es relativa por lo que devuelve False

System.IO.Path.PathSeparator : Devuelve el separador de rutas, generalmente ";"

System.IO.Path.VolumeSeparatorChar : Devuelve el caracter separador de volúmenes, generalmente ":"

Estos son todos los miembors de la clase System.IO.Path con una breve descripción de cada uno.

Problema al crear un WebService: Failed to access IIS metabase - SOLUCIONADO

2009-02-06T04:38:00.000-08:00

Intentando crear un WebService con C# me encontré con que cada vez que intentaba ejecutarlo IIS me devolvía el siguiente error: Failed to access IIS metabase problem.

Busqué por acá y por alla, descargué un código VBS pero nada... después de probar las mil y una soluciones encontré la solución definitiva, así que decidí publicarla aquí para tenerla siempre a mano y de paso le puede servir a alguien más.

La solución consiste en abrir una consola, ir al directorio de instalación del Framework, 2.0 en este caso y ejecutar un comando que hará una reinstalación de ASP.Net


C:\> cd WINDOWS\Microsoft.NET\Framework\v2.0.50727

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\> aspnet_regiis.exe -i

Start installing ASP.NET (2.0.50727).
......................
Finished installing ASP.NET (2.0.50727).

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\>

MethodInvoker: un delegado simple integrado en el framework

2009-01-16T04:18:00.001-08:00

Muchas veces necesitamos hacer un Invoke, para las veces que necesitamos invocar un método simple, sin parámetros podemos usar el delegado MethodInvoker, que no es más que un Delegate sub sin parámetros:

Public Delegate Sub MethodInvoker()

O sea que si tenemos que utilizarlo podríamos por ejemplo ahcer lo siguiente:

Dim d as MethodInvoker = New MethodInvoker(AddressOf MyProcedimiento)

Simplemente un tip, que me fue útil, ya que hasta que lo encontré declaraba mi propio delegate.

101 Ejemplos de LINQ en VB.Net

2009-01-14T05:25:00.000-08:00

Un muy buen recurso para aprender a dominar esta gran tecnología, tiene ejemplos de LINQ para SQL, Dataset, XML y Objetos, todos con código fácil de comprender.

Sin duda es un enlace que vale la pena tener a mano.

Enlace: http://msdn.microsoft.com/es-es/vbasic/bb688088(en-us).aspx

Recursividad + Invoke = Procedimiento Thread Safe

2009-01-05T16:14:00.000-08:00

Este es más un apunte que un gran conocimiento, pero puede ayudar a más de uno, la idea es mostrar datos en la UI desde un hilo diferente del principal, por ejemplo: creamos un hilo que se encargue de ir a buscar datos a la BDD y los muestre en una grilla cuando los reciba.

Cuando aprendí a usart Invoke lo que hacía era un método que mostraba los datos en la UI y otro que chequeaba si era necesario utilizar Invoke o no.

Public Sub MostrarDatos(Datos as DataSet)
 If Me.InvokeRequired = True Then
  Me.Invoke(New SetDataSource_Delegate(AddressOf SetDataSource), Datos)
 Else
  Me.SetDataSource(Datos)
 End If
End Sub


Private Delegate Sub SetDataSource_Delegate(ds As DataSet)

Private Sub SetDataSource(ds As DataSet)
 Me.DatagridView1.DataSource = ds
 Me.DatagridView1.DataMember = ds.Tables(0).TableName
End Sub

Un tiempo después, como parte de mi eterna búsqueda por escribir mejor código, descubrí que podía simplificar todo eso usando una llamada recursiva y combinando ambos procedimientos en uno solo de la siguiente manera:

Private Delegate Sub MostrarDatos_Delegate(ds As DataSet)


Public Sub MostrarDatos(Datos as DataSet)
 If Me.InvokeRequired = True Then
  Me.Invoke(New MostrarDatos_Delegate(AddressOf MostrarDatos), Datos)
 Else
  Me.DatagridView1.DataSource = ds
  Me.DatagridView1.DataMember = ds.Tables(0).TableName
 End If
End Sub

Como se puede ver, el código queda más legible y no deja de ser eficiente, además de ahorrarnos un par de líneas... que en un formulario muy extenso puede ayudarnos bastante.

Tipos anónimos en .Net

2008-12-23T14:57:00.000-08:00

Los tipos anónimos son una nueva característica de .Net que utilizada junto a LINQ nos brinda grandes ventajas a la hora de escribir nuestro código.

Primero que nada, deberemos chequear que la opción Option Infer esté habilitada en nuestro proyecto. Para ello iremos a Propiedades del proyecto, en la pestaña Compilación. Por supuesto, al principio podremos tener algunos problemas si también utilizamos la opción Option Srtict, pero es cuestión de costumbre.

Volviendo a los tipos anónimos, al escribir una sentencia en LINQ, podremos definirnos una variable sin tipo y a pesar de ello tener intellisense.

Por ejemplo:

//C#
var hola = from x in myDdatacontext.table1
            where x.id > 20
            select x;


'VB.Net

Dim Hola = From x in MyDataContext.Table1 _
            Where x.Id > 20 _
            Select x

En realidad nuestras variables Hola, tomarán, en este caso el tipo IQueriable(Of Table1) con lo cual podremos ir navegando a través de los items devueltos por la consulta.

Suponiendo que Table1 tiene los campos Id, Nombre y Apellido, al escribir x. el intellisense nos mostrará como proiedades Id, Nombre y Apellido. Y de igual manera, cuando recorremos nuestras variables de tipos anónimos podremos ver el intellisense y acceder a cada propiedad, por ejemplo:

'VB.Net
For Each x in Hola
     Console.Writeline(String.Format("ID: {0}   Nombre: {1}    Apellido: {2}", x.Id, x.Nombre, x.Apellido))
Next

Otra forma, sería si quisiéramos devolver el primer elemento del resultado de la consulta, entonces:

' VB.Net
Return Hola.First

Microsoft Beginner Developer Learning Center

2008-11-22T08:39:00.000-08:00

Microsoft ha publicado una serie de tutoriales y videos orientados a los nuevos programadores, la idea es enseñarles programación utilizando la serie Express de herramientas para programar .Net.

Nueva Academia Virtual de Microsoft

2008-09-11T07:13:00.000-07:00

Microsoft ha lanzado una nueva Academia Virtual llamada Microsoft Virtual Academy. En la misma presentan cursos para aprender y para actualizarse seleccionando una carrera, igual que una academia real.

MVA es una forma gratuita de capacitarse, puediendo anotarte en varios cursos y carreras, en los cuales irás obteniendo puntos según tu desempeño con los cuales podrás solicitar una membresía, obtener descuentos y varios beneficios más.

Enlace: mva

Como mostrar un dialogo de confirmación antes de cerrar la ventana

2008-08-28T11:50:00.000-07:00

Es lo más común, se va a cerrar una ventana, pero se han editado datos y no se han guardado. En ese caso es muy conveniente utilizar un diálogo con los botones Si, No, Cancelar, los cuales utilizaremos para Guardar los cambios, Descartarlos o cancelar el cerrado de la ventana respectivamente.

Lo primero que necesitamos es alguna rutina o bandera que nos indique si se han realizado cambios en nuestra ventana, para este ejemplo será una variable de tipo Boolean que se seteará en True cada vez que se modifique un dato.

Luego escribiremos una rutina en el manejador del evento FormClosing de nuestro Form que mostrará el diálogo y dependiendo de la respuesta del usuario realizará una acción:

    Private Sub Form1_FormClosing(ByVal sender As Object, ByVal e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
        If Me.HayCambios Then
            Dim respuesta As DialogResult = MessageBox.Show("Hay cambios pendientes, desea guardarlos antes de salir?", "Cambios pendientes", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2)
            Select Case respuesta
                Case Windows.Forms.DialogResult.Yes
                    Me.GuardarArchivoComo()
                Case Windows.Forms.DialogResult.No
                    'Descartar los cambios 
                Case Windows.Forms.DialogResult.Cancel
                    e.Cancel = True
            End Select
        End If
    End Sub

Función recursiva para limpiar todas las cajas de texto de un Form

2008-08-21T10:59:00.000-07:00

Siempre es necesario limpiar cajas de texto en un form, por ejemplo después de cierta acción queremos dejar todas las cajas de texto vacías... pues qué mejor que tener una función que las busque todas??

Public Sub LimpiarCajas(Controls as System.Windows.Forms.Control.ControlCollection)
 For each c as Control in Controls
  If Not c.Controls Is Nothing AndAlso c.Controls.Count > 0 Then
   LimpiarCajas(c.Controls)
  ElseIf c.GetType().Equals(GetType(TextBox)) Then
   CType(c, TextBox).Text = ""
  End If
 Next
End Sub

Este procedimiento puede ser muy útil si se lo ubica en un módulo público, de manera que pueda ser utilizado desde cualquier parte de nuestra aplicación. Aunque si trabajan con el framework 3.5 pueden utilizar métodos de extensión como explican en Nuevos Programadores.

Como usar ErrorProviders para informar al usuario

2008-08-13T10:49:00.000-07:00

Un ErrorProvider es un componente que se utiliza para informar al usuario de manera gráfica que ha ocurrido un error, en lo personal me gusta utilizarlo para mostrar errores de validación, por ejemplo cuando el usuario deja en blanco un campo obligatorio, ingresa letras en un campo numérico, etc.

Lo que hacemos es agregar un ErrorProvider a nuestro Form, desde el tab "Componentes" nuestra Toolbox. Luego cada vez que hacemos una validación, o cuando deseemos mostrar que hubo un error en cierto control, utilizamos el método SetError(control as System.Windows.Forms.Control, value as String) del objeto ErrorProvider.

Por lo tanto una función de validación de 2 campos obligatorios que muestre un ErrorProvider cuando el usuario no complete un campo se vería de la siguiente manera:

Private Function ValidarDatos() As Boolean
 Dim resultado As Boolean = False

 Me.ErrorProvider1.Clear() ' "Limpliamos" el ErrorProvider para que oculte los errores anteriores

 If Me.ComboBox1.SelectedIndex <> -1 Then ' Si seleccionó un item del ComboBox
  If Me.TextBox1.Text <> "" Then ' Si ingresó algo en la TextBox
   'Hacer más validaciones o controles
   resultado = True
  Else
   Me.ErrorProvider1.SetError(Me.TextBox1, "Debe ingresar un valor.") ' Muestra el ErrorProvider asociado al control TextBox1
  End If
 Else
  Me.ErrorProvider1.SetError(Me.cmbField1, "Debe seleccionar una propiedad.")
 End If
 
 Return resultado
End Function

Inicializar un thread, capturar eventos y usar Invoke (VB.NET)

2008-07-30T08:24:00.000-07:00

En este ejemplo haremos una aplicación que al presionar un botón creará un thread aparte que "hará algo", en este caso no hará nada, solo hará tiempo, pero éste thread lanzará un evento al inicio y otro al fin de su ejecución, nosotros capturaremos esos eventos y los mostraremos en pantalla.

Como la interfaz de usuario y el thread obviamente pertenecen a distintos hilos, será necesario utilizar un Delegate con el método Invoke del control que utilizaremos, de lo contrario tendremos una InvalidOperationException por CrossThread

Lo primero que haremos será asignar los manejadores a los eventos que hemos declarado anteriormente, para eso utilizaremos AddHandler y AddressOf.

#Region " Eventos de Thread y sus handlers"
    Private Event InicioThread(ByVal Inico As DateTime)
    Private Event FinThread(ByVal Fin As DateTime)

    Private Trabajando As Boolean = False

    Public Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        AddHandler InicioThread, AddressOf App_InicioThread
        AddHandler FinThread, AddressOf App_FinThread
    End Sub

    Private Sub App_InicioThread(ByVal Inicio As DateTime)
        Trabajando = True
        If TextBox1.InvokeRequired Then
            TextBox1.Invoke(New MostrarEnTextBox_Delegate(AddressOf MostrarEnTextBox), TextBox1, Inicio.ToString())
        Else
            MostrarEnTextBox(TextBox1, Inicio.ToString())
        End If
        If TextBox2.InvokeRequired Then
            TextBox2.Invoke(New MostrarEnTextBox_Delegate(AddressOf MostrarEnTextBox), TextBox2, "Todavía haciendo algo...")
        Else
            MostrarEnTextBox(TextBox2, "Todavía haciendo algo...")
        End If
    End Sub

    Private Sub App_FinThread(ByVal Fin As DateTime)
        Trabajando = False
        If TextBox2.InvokeRequired Then
            TextBox2.Invoke(New MostrarEnTextBox_Delegate(AddressOf MostrarEnTextBox), TextBox2, Fin.ToString())
        Else
            MostrarEnTextBox(TextBox2, Fin.ToString())
        End If
    End Sub
#End Region

Como se puede ver en los maejadores de eventos utilizamos un Delegate del método que inserta el texto en las TextBox, eso es porque requiere parámetros, sino lo hubiésemos podido hacer directamente usando AddressOf.
Así que lo siguiente será crear el método que ingresa texto en las TextBox y su correspondiente Delegate.

#Region " Delegate para Invoke "
    Private Delegate Sub MostrarEnTextBox_Delegate(ByVal txt As TextBox, ByVal str As String)

    Private Sub MostrarEnTextBox(ByVal txt As TextBox, ByVal str As String)
        txt.Text = str
    End Sub
#End Region

Como dice al principio del post, ésta aplicación tiene un botón que es el que inicia un nuevo hilo, así que agregaremos el botón y en el evento click llamaremos a un método que creará e iniciará el nuevo Thread. Adicionalmente, tenemos un flag para que no permitir la creación de más de un hilo por vez, su valor se cambia con los eventos del Thread.

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        If Not Trabajando Then
            InicializarThread()
        Else
            MessageBox.Show("Hay un 'hilo haciendo' algo aún. Intente nuevamente en unos segundos.", "Hilo trabajando", MessageBoxButtons.OK, MessageBoxIcon.Information)
        End If
    End Sub

#Region " Thread "
    Private Sub InicializarThread()
        Dim t As New Thread(AddressOf HacerAlgo)
        t.Name = "Thread_HacerAlgo"
        t.IsBackground = True
        t.Start()
    End Sub

    Private Sub HacerAlgo()
        RaiseEvent InicioThread(DateTime.Now)
        For i As Byte = 0 To 254
            Thread.Sleep(30)
        Next
        RaiseEvent FinThread(DateTime.Now)
    End Sub
#End Region

Como abrir una web en el navegador por defecto

2008-07-29T09:33:00.001-07:00

Este es un tip pequeño, simplemente lanzaremos un proceso con la URL a abrir, el Sistema Operativo se encargará de usar la aplicación por defecto para manejar la URL, en nuestro caso un navegador web.

Para probarlo crearemos una nueva aplicación de Winforms y en el form que se crea por defecto agregaremos un LinkLabel, al cual pondremos como texto la URL que queremos abrir, aunque puede ser cualquier texto, en nuestro ejemplo utilizaremos el texto de la etiqueta para ejecutar el proceso.

Ahora nos resta programar el evento Click del LinkLabel para que lance el proceso:


Private Sub lnkAprendiendoNet_LinkClicked(ByVal sender As System.Object, ByVal e As System.Windows.Forms.LinkLabelLinkClickedEventArgs) Handles lnkAprendiendoNet.LinkClicked
Process.Start(lnkAprendiendoNet.Text)
End Sub

Implementación de Singleton y manejo de hilos en C#

2008-07-23T05:35:00.000-07:00

Via NuevosProgramadores.com me encuentro con 2 artículos, uno donde explican como implementar el patrón Singleton y otro donde explican el manejo de hilos y delegates. Todo está implementado en C# y se puede descargar el código fuente del ejemplo.

Link: Implementación de Singleton en C#

Link: Manejo de hilos en C# + delegates + invoke

Hola Mundo, la primera aplicacion

2008-07-17T10:37:00.000-07:00

Como es clásico en el mundo de la programación, lo primero que haremos será el clásico Hola Mundo!

En esta ocasión utilizaremos una Aplicación de Consola en lenguaje VB.Net, para ello iremos a crear un nuevos proyecto y seleccionaremos Visual Basic y Console Application.

Eso nos creará la aplicación y automáticamente agregará un módulo con el procedimiento que se ejecutará al iniciar la aplicación.

Module Module1

Sub Main()

End Sub

End Module

A continuación agregaremos 2 líneas, la primera se encargará de escribir en nuestra consola el texto Hola Mundo!, y la segunda esperará a que el usuario presione una tecla para continuar la ejecución del código... que en este caso llevará al final de la aplicación.

Module Module1

Sub Main()
Console.WriteLine("Hola Mundo!")
Console.Read()
End Sub

End Module

Y así de simple hemos escrito nuestra primera aplicación en .Net, ahora sólo resta ejecutarla, para lo cual presionaremos la tecla F5.

Que es el .net framework?

2008-07-11T17:56:00.000-07:00

Sólo una breve introducción, por si alguien aún no está familiarizado con ésta tecnología.

.Net Framework es una plataforma de desarrollo de software que Microsoft lanzó al mercado como respuesta a la creciente couta del mercado que está tomando la tecnología Java de Sun Microsystems.

Se trata de un conjunto de utilidades que gracias a la norma, (incluída en ECMA-335, ISO/IEC 23271), que define la implementación de BCL, permite su implementación en varias plataformas; una de ellas es Mono, un proyecto que pretende ser la implementación libre de .Net para GNU/Linux.

A grandes rasgos, el framework permite el desarrollo de aplicaciones en varios lenguajes gracias al CLR. Básicamente, todo se compila en un lenguaje intermedio, que es compatible con CLR, llamado MSIL, el cuál está basado en CLS.

Luego para ejecutar las aplicaciones se utiliza un compilador JIT el cual ejecuta el código máquina real en la máquina del cliente, lo cual permite independencia con respecto a la arquitectura.

En la imagen se puede ver la estructura básica del .Net Framework.

Fuente: Wikipedia