Latam Developers - Blog de Pablo Barrientos

Hosting de calidad: Bueno, bonito y barato y en español. Casi gratis diria yo

2011-03-09T10:43:00.002-03:00

Estuve probando un servicio de hosting bastante bueno, con muchas características de las que andaba necesitando. Solo para mencionar algunas les listo las siguientes que me gustaron:

- Totalmente en Español

- 3GB de espacio en disco
- Dominio incluido
- Se pueden alojar mas dominios
- Subdominios ilimitados
- Bases de datos MySQL ilimitadas
- Instalador Fantastico para aplicaciones como Wordpress y Joomla
- Además te dan como "bonos" un pack de herramientas muy interesantes

En fin, me gustó y se los quería recomendar :)

Pueden ver el detalle completo del sevicio y contratarlo haciendo click aquí

.-

MCTS 70-536 Links a MSDN en castellano 7/7

2008-11-24T21:27:00.004-02:00

Implementing globalization, drawing, and text manipulation functionality in a .NET Framework application

Format data based on culture information. (Refer System.Globalization namespace)
- Access culture and region information in a .NET Framework application.
- Format date and time values based on the culture.
- Format number values based on the culture.
- Perform culture-sensitive string comparison.
- Build a custom culture class based on existing culture and region classes.
Enhance the user interface of a .NET Framework application by using the System.Drawing namespace.
- Enhance the user interface of a .NET Framework application by using brushes, pens, colors, and fonts.
- Enhance the user interface of a .NET Framework application by using
  graphics, images, bitmaps, and icons.
- Enhance the user interface of a .NET Framework application by using
  shapes and sizes.
Enhance the text handling capabilities of a .NET Framework application (refer
System.Text namespace), and search, modify, and control text in a .NET Framework application by using regular expressions. (Refer System.Text.RegularExpressions namespace)
- StringBuilder class
- Regex class
- Match class and MatchCollection class
- Group class and GroupCollection class
- Encode text by using Encoding classes
- Decode text by using Decoding classes.
- Capture class and CaptureCollection class

MCTS 70-536 Links a MSDN en castellano 6/7

2008-11-08T21:18:00.002-02:00

Implementing interoperability, reflection, and mailing functionality in a .NET Framework application

.NET Framework components to COM. (Refer System.Runtime.InteropServices namespace)
Call unmanaged DLL functions in a .NET Framework application, and control the marshaling of data in a .NET Framework application. (Refer System.Runtime.InteropServices namespace)
- Platform Invoke
- Create a class to hold DLL functions.
- Create prototypes in managed code.
- Call a DLL function.
- Call a DLL function in special cases, such as passing structures and implementing callback functions.
- Create a new Exception class and map it to an HRESULT.
- Default marshaling behavior
- Marshal data with Platform Invoke
- Marshal data with COM Interop
- MarshalAsAttribute class and Marshal class
Implement reflection functionality in a .NET Framework application (refer System.Reflection namespace), and create metadata, Microsoft intermediate language (MSIL), and a PE file by using the System.Reflection.Emit namespace.
- Assembly class
- Assembly attributes
- Info classes
- Binder class and BindingFlags enumeration
- MethodBase class and MethodBody class
- Builder classes
Send electronic mail to a Simple Mail Transfer Protocol (SMTP) server for delivery from a .NET Framework application. (Refer System.Net.Mail namespace)
- MailMessage class
- MailAddress class and MailAddressCollection class
- SmtpClient class, SmtpPermission class, and SmtpPermissionAttribute class
- Attachment class, AttachmentBase class, and AttachmentCollection class
- SmtpException class, SmtpFailedReceipientException class, and SmtpFailedReceipientsException class
- SendCompletedEventHandler delegate
- LinkedResource class and LinkedResourceCollection class
- AlternateView class and AlternateViewCollection class

MCTS 70-536 Links a MSDN en castellano 5/7

2008-11-05T06:46:00.003-02:00

Improving the security of the .NET Framework applications by using the .NET Framework 2.0 security features

Implement code access security to improve the security of a .NET Framework application. (Refer System.Security namespace)
- SecurityManager class
- CodeAccessPermission class
- Modify the Code Access security policy at the computer, user, and enterprise policy level by using the
  Code Access Security Policy tool (Caspol.exe).
- PermissionSet class and NamedPermissionSet classStandard Security interfaces
  - IEvidenceFactory interface
  - IPermission interface
Implement access control by using the System.Security.AccessControl classes.
- DirectorySecurity class, FileSecurity class, FileSystemSecurity class, and
  RegistrySecurity class AccessRule class
- AuthorizationRule class and AuthorizationRuleCollection class
- CommonAce class, CommonAcl class, CompoundAce class, GenericAce class, and GenericAcl class
- AuditRule class
- MutexSecurity class, ObjectSecurity class, and SemaphoreSecurity class
Implement a custom authentication scheme by using the System.Security.Authentication classes. (Refer System.Security.Authentication namespace)
- Authentication algorithms and SSL protocols
Encrypt, decrypt, and hash data by using the System.Security.Cryptography classes. (Refer System.Security.Cryptography namespace)
- DES class and DESCryptoServiceProvider class
- HashAlgorithm class
- DSA class and DSACryptoServiceProvider class
- SHA1CryptoServiceProvider class
- TripleDES and TripleDESCryptoServiceProvider class
- MD5 class and MD5CryptoServiceProvider class
- RSA class and RSACryptoServiceProvider class
- RandomNumberGenerator class
- CryptoConfig class
- RC2 class and RC2CryptoServiceProvider class
- AssymetricAlgorithm class
- ProtectedData class and ProtectedMemory class
- RijndaelManaged class and RijndaelManagedTransform class
- CspParameters class
- CryptoAPITransform class
- Hash-based Message Authentication Code (HMAC)
Control permissions for resources by using the System.Security.Permissions classes. (Refer System.Security.Permissions namespace)
- SecurityPermission class
- PrincipalPermission class
- FileIOPermission class
- StrongNameIdentityPermission class
- UIPermission class
- UrlIdentityPermission class
- PublisherIdentityPermission class
- GacIdentityPermission class
- FileDialogPermission class
- DataProtectionPermission class
- EnvironmentPermission class
- IUnrestrictedPermission interface
- RegistryPermission class
- IsolatedStorageFilePermission class
- KeyContainerPermission class
- ReflectionPermission class
- StorePermission class
- SiteIdentityPermission class
- ZoneIdentityPermission class
Control code privileges by using System.Security.Policy classes. (Refer
System.Security.Policy namespace)
- ApplicationSecurityInfo class and ApplicationSecurityManager class
- ApplicationTrust class andApplicationTrustCollection class
- Evidence class andPermissionRequestEvidence class
- CodeGroup class, FileCodeGroup class, FirstMatchCodeGroup class,
  NetCodeGroup class, and UnionCodeGroup class
- Condition classes
- PolicyLevel class and PolicyStatement class
- IApplicationTrustManager interface, IMembershipCondition interface, and
  IIdentityPermissionFactory interface
Access and modify identity information by using the System.Security.Principal classes. (Refer System.Security.Principal namespace)
- GenericIdentity class and GenericPrincipal class
- WindowsIdentity class and WindowsPrincipal class
- NTAccount class and SecurityIdentifier class
- IIdentity interface and IPrincipal interface
- WindowsImpersonationContext class
- IdentityReference class and IdentityReferenceCollection class

MCTS 70-536 Links a MSDN en castellano 4/7

2008-11-04T18:41:00.003-02:00

Implementing serialization and input/output functionality in a .NET Framework application

Serialize or deserialize an object or an object graph by using runtime serialization techniques. (Refer System.Runtime.Serialization namespace)
- Serialization interfaces
- Serilization attributes
- SerializationEntry structure and SerializationInfo class
- ObjectManager class
- Formatter class, FormatterConverter class, and FormatterServices class
- StreamingContext structure
Control the serialization of an object into XML format by using the System.Xml.Serialization namespace.
- Serialize and deserialize objects into XML format by using the XmlSerializer class.
- Control serialization by using serialization attributes.
- Implement XML Serialization interfaces to provide custom formatting for XML serialization.
- Delegates and event handlers are provided by the System.Xml.Serialization namespace
Implement custom serialization formatting by using the Serialization Formatter classes.
- SoapFormatter class (Refer System.Runtime.Serialization.Formatters.Soap namespace)
- BinaryFormatter class (Refer System.Runtime.Serialization.Formatters.Binary namespace)
Access files and folders by using the File System classes. (Refer System.IO namespace)
- File class and FileInfo class
- Directory class and DirectoryInfo class
- DriveInfo class and DriveType enumeration
- FileSystemInfo class and FileSystemWatcher class
- Path class
- ErrorEventArgs class and ErrorEventHandler delegate
- RenamedEventArgs class and RenamedEventHandler delegate
Manage byte streams by using Stream classes. (Refer System.IO namespace)
- FileStream class
- Stream class
- MemoryStream class
- BufferedStream class
Manage the .NET Framework application data by using Reader and Writer classes. (Refer System.IO namespace)
- StringReader class and StringWriter class
- TextReader class and TextWriter class
- StreamReader class and StreamWriter class
- BinaryReader class and BinaryWriter class
Compress or decompress stream information in a .NET Framework application (refer System.IO.Compression namespace), and improve the security of application data by using isolated storage. (Refer System.IO.IsolatedStorage namespace)
- IsolatedStorageFile class
- IsolatedStorageFileStream class
- DeflateStream class
- GZipStream class

70-536 Links a MSDN en español 3/7

2008-11-04T07:47:00.002-02:00

Embedding configuration, diagnostic, management, and installation features into a .NET Framework application

Embed configuration management functionality into a
.NET Framework application. (Refer System.Configuration namespace)
- Configuration class and
  ConfigurationManager class
- ConfigurationSettings class, ConfigurationElement class, ConfigurationElementCollection class, and ConfigurationElementProperty class
- Implement IConfigurationSectionHandler interface
- ConfigurationSection class, ConfigurationSectionCollection class, ConfigurationSectionGroup class, and ConfigurationSectionGroupCollection class
- Implement ISettingsProviderService interface
- Implement IApplicationSettingsProvider interface
- ConfigurationValidatorBase class
- Implement IConfigurationSystem interface
Create a custom Microsoft Windows Installer for the .NET Framework components by using the System.Configuration.Install namespace, and configure the .NET Framework applications by using configuration files, environment variables, and the .NET Framework Configuration tool (Mscorcfg.msc).
- Installer class
- Configure which runtime version a .NET Framework application should use.
- Configure where the runtime should search for an assembly.
- Configure the location of an assembly and which version of the assembly to use.
- Direct the runtime to use the DEVPATH environment variable when you search for assemblies.
- AssemblyInstaller class
- ComponentInstaller class
- Configure a .NET Framework application by using the .NET Framework Configuration tool (Mscorcfg.msc).
- ManagedInstaller class
- InstallContext class
- InstallerCollection class
- Implement IManagedInstaller interface
- InstallEventHandler delegate
- Configure concurrent garbage collection.
- Register remote objects by using configuration files.
Manage an event log by using the System.Diagnostics namespace.
Manage system processes and monitor the performance of a .NET Framework application by using the diagnostics functionality of the .NET Framework 2.0. (Refer
System.Diagnostics namespace)
Debug and trace a .NET Framework application by using the System.Diagnostics namespace.
- Debug class and Debugger class
- Trace class, CorrelationManager class, TraceListener class, TraceSource class, TraceSwitch class, XmlWriterTraceListener class, DelimitedListTraceListener class, and EventlogTraceListener class
- Debugger attributes
Embed management information and events into a .NET Framework application. (Refer System.Management namespace)
- Retrieve a collection of Management objects by using the ManagementObjectSearcher class and its derived classes.
- ManagementQuery class
- Subscribe to management events by using the
  ManagementEventWatcher class.

70-536 Links a MSDN en castellano 2/7

2008-11-03T10:37:00.001-02:00

Implementing service processes, threading, and application domains in a .NET Framework application

Implement, install, and control a service. (Refer System.ServiceProcess namespace)
- Inherit from ServiceBase class
- ServiceController class and ServiceControllerPermission class
- ServiceInstaller and ServiceProcessInstaller class
- SessionChangeDescription structure and SessionChangeReason enumeration
Develop multithreaded .NET Framework applications. (Refer System.Threading namespace)
- Thread class
- ThreadPool class
- ThreadStart delegate, ParameterizedThreadStart delegate, and SynchronizationContext class
- Timeout class, Timer class, TimerCallback delegate, WaitCallback delegate, WaitHandle class, and WaitOrTimerCallback delegate
- ThreadExceptionEventArgs class and ThreadExceptionEventHandler delegate
- ThreadState enumeration and ThreadPriority enumeration
- ReaderWriterLock class
- AutoResetEvent class and ManualResetEvent class
- IAsyncResult interface (Refer System namespace)
- EventWaitHandle class, RegisterWaitHandle class, SendOrPostCallback delegate, and IOCompletionCallback delegate
- Interlocked class, NativeOverlapped structure, and Overlapped class
- ExecutionContext class, HostExecutionContext class, HostExecutionContextManager class, and ContextCallback delegate
- LockCookie structure, Monitor class, Mutex class, and Semaphore class
Create a unit of isolation for common language runtime in a .NET Framework application by using application domains. (Refer System namespace)

70-536 Links a MSDN en castellano 1/7

2008-11-03T06:57:00.005-02:00

Developing applications that use system types and collections

Manage data in a .NET Framework application by using the .NET Framework 2.0 system types. (Refer System namespace)
Manage a group of associated data in a .NET Framework application by using collections. (Refer System.Collections namespace)
- ArrayList class
- Collection interfaces
- Iterators
- Hashtable class
- CollectionBase class and ReadOnlyCollectionBase class
- DictionaryBase class and DictionaryEntry class
- Comparer class
- Queue class
- SortedList class
- BitArray class
- Stack class
Improve type safety and application performance in a .NET Framework application by using generic collections. (Refer System.Collections.Generic namespace)
- Collection.Generic interfaces
- Generic Dictionary
- Generic Comparer class and Generic EqualityComparer class
- Generic KeyValuePair structure
- Generic List class, Generic List.Enumerator structure, and Generic SortedList class
- Generic Queue class and Generic Queue.Enumerator structure
- Generic SortedDictionary class
- Generic LinkedList
- Generic Stack class and Generic Stack.Enumerator structure
Manage data in a .NET Framework application by using specialized collections. (Refer System.Collections.Specialized namespace)
- Specialized String classes
- Specialized Dictionary
- Named collections
- CollectionsUtil
- BitVector32 structure and
  BitVector32.Section structure
Implement .NET Framework interfaces to cause components to comply with standard contracts. (Refer System namespace)
- IComparable interface
- IDisposable interface
- IConvertible interface
- ICloneable interface
- IEquatable interface
- IFormattable interface
Control interactions between .NET Framework application components by using
events and delegates. (Refer System namespace)
- Delegate class
- EventArgs class
- EventHandler delegates

CH01- Resumen - Preguntas y Respuestas

2008-07-02T20:42:00.001-03:00

Resumen Capítulo 1

*- La plataforma .NET da soporte al CLS (Common Language Specification), el cual detalla el comportamiento que deben tener los lenguajes compatibles. Incluye la especificación de tipos comunes (CTS – Common Type Specifications) detallando los tipos para todos los lenguajes .NET

*- C# es el lenguaje ideal para el desarrollo de cualquier tipo de aplicaciones de la plataforma .NET

*- El programa Hola Mundo ilustra los fundamentos de cualquier programa en C#

*- Los pasos a seguir son: escribir el código fuente en un archivo .cs, compilar y ejecutar.

*- El producto de la compilación no es código nativo sino que es código IL (Microsoft Intermediate Language). El CLR () convierte este código IL en un programa ejecutable en un proceso conocido como JIT (Just in Time)

Preguntas y Respuestas – Capítulo 1

1- Qué es ADO.NET?
Es la tecnología incluida en el Framework como reemplazo de ADO; provee un modelo de objetos para interactuar con proveedores de datos como por ejemplo bases de datos relacionales.

2- Qué es MSIL?
Es el código generado por el compilador. Se trata de código intermedio que es utilizado por el JIT para la generación de código ejecutable. La principal ventaja de este código IL es que diferentes lenguajes compatibles con .NET generan IL casi idéntico lo que permite utilizar componentes desarrollados en un lenguaje diferente siempre y cuando respete el CLS.

3- Cuales son los tipos de comentarios soportados en C#?
Existen tres tipos de comentarios soportados en C#. Los comentarios de bloque (/**/), los comentarios que afectan una sola línea de código (//) y por ultimo los comentarios de documentación XML (///)

4- Qué es un namespace?
Es simplemente una forma de organizar la jerarquía de clases comunes.

En la próxima entrada comenzaremos con el capítulo 2 de este tutorial donde veremos los fundamentos del lenguaje

CH01-02 - Primer programa en C# - Parte II

2008-07-01T17:29:00.001-03:00

En esta entrada seguiremos viendo los elementos constitutivos de un programa simple en C#

Comentarios:
En este ejemplo simple podemos ver una línea que comienza con dos barras (//)

//Imprimir en pantalla

Esta línea se trata de un comentario en C#, no es mas que una nota o recordatorio o como su nombre lo indica un comentario :) que el desarrollador puede escribir sin afectar en nada la normal ejecución del programa. C# tiene soporte para tres tipos de comentarios como se detalla en la siguiente lista:

* Comentarios de bloque al estilo de C /* */
* Comentarios de línea al estilo C++
* Comentarios de documentación XML ///

Los comentarios al estilo C son utilizados para comentar bloques de código completos usualmente de muchas líneas. Comienzan con barra-asterisco y cierran con asterisco-barra. Por lo general se utiliza para deshabilitar de forma temporal bloques de código.

Los comentarios mas comunes que vamos a encontrar o utilizar son los del estilo de C++ de las doble barra (//) Este tipo de comentarios se aplican a una línea en particular desde su ubicación hasta el final de la línea, esto significa que podemos utilizarlos tanto al comienzo como en cualquier parte de la línea. Los ejemplos de abajo ilustran lo expuesto.

//Sumamos dos números
c = a + b;

c = a + b; //Sumamos dos numeros

El tercer tipo de comentarios son los comentarios de documentación XML. Aprenderemos más sobre esta poderosa característica mas adelante en este tutorial. Básicamente son comentarios pensados en describir las características de nuestros métodos, tipos retornados y parámetros recibidos para de tal forma que con una herramienta se colecte esta información para generar documentación a partir de estos comentarios especiales.

Los comentarios son una técnica muy poderosa si se utilizan bien. Una de las claves para tener éxito con los comentarios es agregar el propósito de
una determinada línea de código mas que la descripción de lo que la línea de código hace. Código bien escrito es código bien comentado. Mas de una vez nos sorprendemos de volver sobre código que escribimos hace no mucho y nos preguntamos cual fue el propósito de escribirlo de esa forma. Los comentarios también serán útiles para los pobres desdichados que deban leer nuestro código, por lo tanto no debemos escatimar esfuerzos en lograr un buen equilibrio entre cantidad y calidad de comentarios en nuestras aplicaciones.

Console
La última línea de nuestro programa de ejemplo es la que realiza todo el trabajo

System.Console.WriteLine("Hola Mundo!");

Lo primeros que tenemos que decir es que se trata de una aplicación de consola. Las aplicaciones de consola corren en una ventana de consola usualmente llamada una consola DOS. La consola es nuestro monitor y la aplicación simplemente escribe en la consola, por ello, en el monitor.

Las aplicaciones de consola son muy simples, con poco o nada de soporte para Interfaces Gráficas de Usuario (GUI). En los primeros capítulos de este tutorial vamos a realizar un uso intensivo de este tipo de aplicaciones de consola ya que nos permiten enfocarnos en las nociones del lenguaje sin tener que lidiar con las complicaciones de las interfaces de usuario.

Para este ejemplo diremos que C# maneja su consola a través del objeto Console. WriteLine es uno de los métodos de este objeto, el cual recibe un string como parámetro y su función es, como ya adivinaron, escribir en la consola (nuestro monitor)

Namespaces
Otra de las cosas que notamos es que Console esta precedida por System. System es el espacio de nombres (namespace) donde reside la clase Console. La librería de clases del framework de .NET posee miles de clases sumamente útiles. Cada clase posee un número de métodos. Los espacios de nombre ayudan a organizar de forma ordenada el agrupamiento de clases afines. Accedemos a las clases dentro de un namespace de la misma forma que invocamos un metodo dentro de una clase, con el operador punto (.). De esta forma accedemos a System.Console o bien System.Console.WriteLine("")

En la próxima entrada veremos un resumen de conceptos claves de este capítulo I, como así también preguntas y respuestas relacionadas a los temas expuestos.

CH01-02 - Primer programa en C# - Parte I

2008-06-30T10:33:00.002-03:00

Como marca la tradición de cada libro y tutorial de cualquier lenguaje de programación, comenzaremos por el programa más simple que se puede escribir y veremos en detalle sus partes constitutivas.

- Código Fuente:
Todo programa consiste básicamente de una cierta cantidad de lineas de código fuente. Este código fuente es el que el desarrollador escribe en un archivo (en nuestro caso, archivos con extensión .cs).
Luego este archivo de código fuente es compilado a IL (Microsoft Intermediate Languaje). Al ejecutar el programa, el CLR convierte el código IL en código nativo para la plataforma sobre la que se esta ejecutando. Una vez compilado este código se guarda en un cache de memoria de tal forma que la próxima vez que es invocado está listo para ejecutarse sin necesidad de volver a compilarse.


namespace Tutorial
{
    class HolaMundo
    {
        static void Main()
        {
            //Imprimir en pantalla
            System.Console.WriteLine("Hola Mundo!");
        }
    }
}

Aunque es un ejemplo de lo mas simple, es muy útil para ilustrar diferentes conceptos del lenguaje. Veamos en detalle parte por parte.

-Clases:
Lo primero que notamos es la palabra reservada "class" en la tercera linea: **class HolaMundo**
La palabra reservada class crea un nuevo tipo. Un tipo es una cosa y el mundo está lleno de cosas como una mesa, una silla, el telefono, etc. El perro, mi hermano, mis hijos son cosas también. El cielo es una cosa, las ideas del amor y el honor son cosas.
Como podemos ver, somos una especie orientada a cosas (objetos) y C# es un lenguaje orientado a objetos también. Algunas cosas son concretas (mesa, silla) y otras son abstractas (amor, libertad) y C# tiene la habilidad de representar ambos tipos.

Una clase define una nueva cosa o una nueva entidad. Un objeto es una instancia de una clase. Por ejemplo la palabra perro describe la generalidad de la idea y mi perro Snoopy es una instancia de la clase perro, es un perro especifico.
De la misma forma, en una aplicación Windows, la palabra botón describe como son los botones y que capacidades poseen los botnoes de una aplicación y los botones Aceptar, Cancelar o Imprimir son instancias especificas de la clase botón.

Las clases definen nuevos tipos. Desde la perspectiva del lenguaje, un tipo describe el tamaño y las capacidades de los objetos. C# provee un número de tipos propios (built-in) como int, long, double, y al mismo tiempo como desarrolladores podemos crear nuestros propios tipos.

- Metodos:
Si miramos el codigo dentro de la clase, encontramos el metod main:


 static void Main()
        {
            //Imprimir en pantalla
            System.Console.WriteLine("Hola Mundo!");
        }

Cada clase posee propiedades y comportamiento. De hecho, en C#, todo lo que sucede, sucede dentro de una clase. Por esta razón una clase no es solo una palabra clave del lenguaje sino es un concepto clave sobre el cual se fundamentan muchos otros conceptos.
El comportamiento de una clase está definido por sus métodos (funciones miembros). Los métodos son tipicamente nombres de acciones que un objeto determinado puede realizar, como por ejemplo ListarNombres o WriteLine. Cada programa debe tener un método especial llamado Main(), el cual no tiene un nombre de acción pero tiene un rol especial en cada programa: es el punto de entrada, esto significa que lo primero que se invoca al llamar a un programa es este método.

Otro aspecto de este metodo es que debe ser marcado como estatico, es decir anteponiendo la palabra reservada static. Mas adelante veremos que significa marcar un metodo con esta palabra reservada. Mientras tanto lo que necesitamos saber es que todo metodo Main() debe ser marcado como static.

De forma general, un metodo posee: un nombre, parametros y un tipo retornado. Cuando un métodono devuelve ningún tipo este tipo es void.
Por ejemplo veamos el siguiente codigo:


int SumarNumeros(int num1, int num2)
{
    int resultado = 0;
    resultado = num1 + num2;
    return resultado;
}

El nombre del metodo es SumarNumeros al cual se le pasan dos parametros de tipo entero y retorna otro tipo entero. Las variables que se pasan por parámetro actúan como varibales locales al método y son destruídas al finalizar la invocación al método.

Veremos en mayor detalle los conceptos de variables, su ámbito y alcance, como asi también invocaciones a métodos. Lo que necesitamos concoer a este nivel es la utilidad de los metodos en una clase: manipular los datos de la clase y permitir la interacción con otros objetos.

En la siguiente entrada continuaremos con el análisis de nuestro primer programa en CSharp. Veremos otros conceptos claves: comentartios, el objeto Console y namespaces.

CH01-01 Arquitectura .NET y Lenguaje C#

2008-06-22T20:46:00.004-03:00

Con esta entrada vamos a comenzar un tutorial en C# (pronunciado CSharp) y temas relacionados con el .NET Framework 2.0.

Objetivos en la creación de C# (CSharp)
Este lenguaje fue diseñado con los siguientes objetivos en mente:
- Simple: C# es un lenguaje simple con 80 palabras reservadas y nua docena de tipos
- Seguro: C# es un lenguaje type-safe (seguro en tipos) lo que significa que el compilador está preparado para asistirnos en la prevención de errores mientras desarrollamos
- Orientado a Objetos: C# fue construido sobre las lecciones aprendidas de C++ y Java en lo que se refiere a orientación a objetos. Los objetos son los elementos fundamentales de toda aplicación y representan entidades reales del dominio de la aplicación que estamos construyendo.
- Centralizado en Internet: Este objetivo está relacionado con la idea de integrar las aplicaciones de escritorio con aplicaciones de Internet aprovechando la gran propagación de entornos conectados.
- De alto rendimiento: Finalmente, C# no sacrifica las características de alto rendimiento de los lenguajes de programación de la familia de C.

El Common Language Runtime (CLR)
El CLR ofrece la plataforma orientada a objetos para el desarrollo de aplicaciones tanto Windows como Web. Es el CLR quien interpreta el código de la aplicación e interactúa con la plataforma subyacente.
El CLR además es el host para el compilador JIT (Just in Time), los tipos intrínsecos y el soporte para el manejo de excepciones.

Arquitectura .NET
El framework de .NET ha sido construido en una capa por encima del CLR, el cual a su vez reside una capa por encima de la plataforma Windows. La siguiente figura nos ayuda a entender su arquitectura.
Vamos a explicar el gráfico comenzando por la capa inferior hasta la superior.
Como ya dijimos, la plataforma Windows es la primera capa por sobre la cual se encuentra el CLR con los elementos que ya explicamos.

Por encima del CLR encontramos las clases del framework propiamente dicho. El Framework es una colección de clases que de otra forma deberíamos escribir nosotros mismos. Estas clases incluyen entre otras, clases para el manejo de hilos, streams, seguridad, trabajo con archivos, etc.

ADO.NET es la capa construida encima del .NET Framework que nos provee una abstracción de alto nivel para trabajar con tablas y sus relaciones en una base de datos. Veremos en mas detalle mas adelante.

Por encima de todas las capas anteriores, encontramos el soporte para la creación de aplicaciones Windows, Web y Web Services. Los Web Services son aplicaciones web sin interfaz de usuario y proveen funcionalidad a otras aplicaciones. Ejemplos de web services son los servicios de clima proveyendo una determinada ubicación.

MSIL
MSIL (Microsot Intermediate Language) o simplemente IL es el código que genera la compilación de nuestro código fuente (nuestros archivos .cs). Se trata de código intermedio tal como su nombre lo indica y este código intermedio es traducido por el CLR a código nativo. Este código intermedio es el que permite utilizar diferentes componentes escritos en diferentes lenguajes que soportados por .NET. Podríamos por ejemplo en una aplicación escrita en C# utilizar un componente escrito en VB.NET ya que el código IL es virtualmente idéntico.

Esto ha sido todo por hoy, en la próxima entrada vamos a comenzar con nuestro primer programa escrito en C#. Como en todo tutorial, tendremos nuestro "Hola Mundo!" y explicaremos sus partes constitutivas.

Clases publicas por defecto en Visual Studio

2008-06-05T09:41:00.002-03:00

Hace tiempo publiqué un post acerca de la generacion de clases en Visual Studio.
Por defecto las crea privadas y por lo general no lo tenemos en cuenta sino hasta la hora de la compilación.
Como ya estaba cansado de esto y queria crearlas publicas por defecto, encontré un post muy útil donde explicaba exactamente lo que necesitaba.

El truco es el siguiente:
Vamos a la carpeta donde están instalados los templates de cada item del IDE de Visual Studio. En mi caso uso Visual Studio 2005 y la ruta puede variar dependiendo tambien del idioma que tengamos en el Sistema Operativo.
La ruta en cuestión es C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\ItemTemplates\CSharp\1033
Alli encontraremos un archivo Class.zip que al abrirlo veremos que contiene un archivo .cs que lista lo siguiente:

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

namespace $rootnamespace$
{
class $safeitemrootname$
{
}
}

Lo unico que hay que hacer es modificar este template de acuerdo a nuestras preferencias agregando public.

Tambien podemos agregar los namespaces que son más utilizados en nuestras aplicaciones y por ejemplo podria quedar algo como

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Reflection;

namespace $rootnamespace$
{
public class $safeitemrootname$
{
}
}

El último paso que necesitamos es recargar el template modificado para que Visual Studio lo use. Esto se logra con el siguiente comando:

devenv /installvstemplates

Esto toma un poco de tiempo, asi que paciencia.
Eso es todo, ahora cada nueva clase se creará con el template que nosotros hemos definido

Examen 70-536. MSDN Rampup. Herramientas y links

2008-05-08T11:52:00.004-03:00

Luego de una ausencia importante, volvemos a publicar :)

En esta entrada les quiero contar que me estoy preparando para rendir la certificación de Microsoft: TS: Microsoft .NET Framework 2.0—Application Development Foundation
El exámen es el 70-536:
http://www.microsoft.com/learning/exams/70-536.mspx

Voy a ir agregando entradas referidas a este tema en los próximos meses, pero les voy adelantando los libros y links que estoy utilizando, como así también una iniciativa de Microsoft llamada MSDN Rampup para promover esta certificación.

- Libro: "MCTS Self-Paced Training Kit (Exam 70-536): Microsoft .NET Framework 2.0 Application Development Foundation". Es la guía recomendada de forma oficial para autoaprendizaje. Es un libro bastante extenso con 16 capítulos dedicados solo al Framework 2.0.
Lo pueden encontrar en Amazon:
http://www.amazon.com/MCTS-Self-Paced-Training-Exam-70-536/dp/0735622779/ref=pd_bxgy_b_text_b

- Libro: "Programming Microsoft® Visual C#® 2005: The Language". Es el otro libro recomendado por Microsoft para la preparación del examen 70-536. Es un libro más que interesante que desarrolla con buena profundidad las clases del Framework 2.0.
En Amazon:
http://www.amazon.com/Programming-Microsoft%C2%AE-Visual-2005-Developer/dp/0735621810/ref=pd_sim_b_title_6

- Libro: CLR via C#. Si bien no está recomendado para este examen sino para un examen posterior, cayó en mis manos y me pareció realmente muy buen libro y de gran ayuda para este examen. El complemento perfecto para el libro anterior.
También lo pueden encontrar en Amazon:
http://www.amazon.com/CLR-via-Second-Pro-Developer/dp/0735621632/ref=pd_sim_b_title_10

- Link: Página de Public Joe: Este recurso es de lo mas interesantes ya que el buen amigo Joe se tomó la tarea de buscar en MSDN todos los links de los temas necesarios para el examen.
http://www.publicjoe.f9.co.uk/536/70-536.html

- MSDN Rampup: Este es un programa que permite tomar contacto con algunas de las prestaciones del framework. Eligiendo el track "Visual Studio 2002/2003 Developer" se accede a una serie de trainings en 4 niveles cada uno con su examen. Al concluir todo el programa (los 4 niveles con sus exámenes), se accede a una serie de premios que incluyen:
1) voucher de descuento de 50% para rendir el examen,
2) voucher 50% descuento para la colección de E-learning
3) voucher de 30% de descuento para la compra de la guía oficial de autoaprendizaje.
Link a MSDN Rampup:
http://msdn.microsoft.com/en-us/rampup/default.aspx

Esto es todo por el momento, es una cantidad importante de material y cada uno aporta lo suyo.
Espero que les sea de utilidad.

Introduccion a AJAX, extensiones AJAX y Toolkit

2008-03-04T17:30:00.003-02:00

Para comenzar a hablar de estos temas vamos a valernos de un mapa que tuve que confeccionar con contenidos introductorios al mundo de AJAX y ASP.NET

Con esta entrada vamos a comenzar a escribir acerca de AJAX, la implementación de Microsoft, es decir las extensiones de ASP.NET AJAX y por supuesto el AJAX Control Toolkit.

Anteriormente hemos visto como se realiza el download y la instalación de estos componentes; comenzaremos a realizar un poco de repaso por la teoría y también vamos a ver implementaciones de código de las extensiones de ASP.NET AJAX los controles del toolkit.

Para comenzar vamos a basarnos en este mapa y voy a ir agregando información acerca de cada uno de los nodos del mismo.

Como siempre todos sus comentarios son bienvenidos.

Resharper 3.0 - Buscar y navegar

2008-03-01T19:15:00.004-02:00

Siguiendo con la serie de entradas dedicadas a Resharper 3.0, en esta entrada vamos a ver la categoría Navegación y búsqueda. Hay muchas prestaciones y características. A continuación enumero solo algunas.

Ir a tipo por nombre:
A través de un atajo de teclado, en este caso CTRL+N podemos encontrar rápidamente un archivo de nuestra solución. Con esta funcionalidad podemos ingresar parte del nombre del archivo y Resharper genera de forma dinámica una lista de las clases, archivo o carpetas de nuestra solución que respondan al criterio de búsqueda. Esta característica nos permite utilizar caracteres comodines (*, ?). Como podemos observar en la imagen basta con ingresar pag para que Resharper busque todas nuestras clases o carpetas que comienzan con esa combinación de teclas.

Ir a miembro del archivo:
De la misma forma que buscamos archivos en nuestra solución con la característica anterior, es posible buscar nombres de elementos (atributos, métodos) dentro de un determinado archivo. Para esta funcionalidad existe también un atajo de teclas, en este caso CTRL+F12

Encontrar Usos:
A través de esta característica, podemos visualizar de forma rápida todos los usos de un determinado elemento (tipo, método, atributo, etc). En este caso, el atajo de teclado es ALT+F7.

Resharper abre una nueva ventana con los resultados de la búsqueda.

Vista de tipo jerárquica:
Esta característica nos permite ver la jerarquía de clases y herencia para una clase determinada de nuestra solución y poder navegar de forma directa a través de ella, todo esto desde una ventana emergente. En esta caso la combinación de teclas para acceder de modo directo es CTRL+ALT+H.

Vista de estructura de archivo:
Con este tipo de vista que básicamente explora la estructura de un determinado archivo de nuestra solución es posible dirigirnos y seleccionar un elemento determinado tales como regiones, atributos y métodos. Una de las cosas que me resultó de lo más atractivo es la sincronización con el editor, de tal forma que si arrastramos un elemento en esta vista (por ejemplo mover la ubicación de un determinado método), automáticamente el código es modificado en el editor.

AJAX: Tecnologías que la componen

2008-02-29T11:46:00.005-02:00

Asynchronous JavaScript and XML, o AJAX, es posible gracias a la combinación de tecnologías. Algunas de estas tecnologías son utilizadas del lado del cliente, pero algunas requieren componentes del lado del servidor para trabajar correctamente. Debido a esta característica de tratarse de una serie de tecnologías relacionadas, realizar debug en aplicaciones AJAX puede ser un proceso complicado. Veamos los principales componentes de AJAX:

- HTML: Hypertext Markup Language, o HTML es el standard aceptado para mostrar aplicaciones web tradicionales en un browser y esto no cambia al comenzar a utilizar AJAX. Es posible utilizar el nuevo HTML extensible o XHTML que posee mejoras en la sintaxis, pero en líneas generales podremos crear la interfaz de usuario de la misma forma en que lo veníamos haciendo con este lenguaje.

- CSS: Las hojas de estilo en cascadas o Cascading Style Sheets es el standard utilizado para agregar estilos y diseño a nuestras paginas HTML o XHTML. CSS es extremadamente util ya que permite separar el contenido de la pagina HTML de la forma en la que será visualizado pudiendo almacenarse en un archivo separado y ser aplicado en muchas o todas las paginas de una determinada aplicación.

- DOM: El Document Object Model, o DOM, es una forma de representar HTML o XHTML en una estructura jerárquica y también proveer acceso de forma programática a los elementos de nuestras aplicaciones, ya sea contenido, estilos o información misma de la estructura.- JavaScript: JavaScript es lenguaje mejor soportado y el mas utilizado para agregar funcionalidad del lado del cliente en aplicaciones web. Utilizando JavaScript podemos crear páginas web más dinámicas manipulando DOM desde el cliente respondiendo a eventos generados por el usuario. HTML, CSS, DOM y JavaScript se pueden combinar para crear aplicaciones DHTML (Dynamic HTML).

- XML: Extensible Markup Language, o XML, es el lenguaje de marcado que se ha convertido en el standard para representar datos en formato de texto e independientes de la plataforma. AJAX utiliza XML para comunicar datos desde el cliente al servidor. Además cuenta con la ventaja de que al tratarse de un standard, existen disponibles muchas herramientas como Stylus Studio o Altova XML SPy.

- JSON: JavaScript Object Notation es un formato para el intercambio de datos que es muy util para la representación de objetos en JavaScript permitiendo la serialización y deserialización de objetos.

-XMLHTTP: El protocolo XMLHTTP es una forma de intercambio de datos en formato XML entre el cliente y el servidor. Se puede acceder a este protocolo del lado del cliente a través del objeto XmlHttpRequest. AJAX combina el uso de este protocolo con la otras tecnologías listadas anteriormente para montar el framework que posibilita la llamada de postbacks de forma asincrónica.

Revisión de Resharper 3.0 de JetBrains

2008-02-28T17:34:00.007-02:00

Tuve la oportunidad de utilizar este add-in en mi actual empleo. En mi empleo anterior habia tenido la oportunidad de utilizarlo en su versión 2.5 y los resultados habían sido muy buenos. Con esta nueva versión que nos provee JetBrains, mis expectativas han sido superadas.

Para conseguirlo visiten http://www.jetbrains.com/resharper/

Las principales ventajas que he encontrado a este producto son las siguientes:
* Es tanto una herramienta para ser utilizada en tareas de refactoring sino que incrementa la calidad de nuestro código.
* Está perfectamente integrada con el IDE de desarrollo de Visual Studio 2005
* Implementa las mejores prácticas de programación para brindarnos sugerencias a la hora de escribir código.
* Posee una API abierta lo cual posibilita la creación de plugins de terceras partes.

Como no existe el producto perfecto, las desventajas también existen:
* Las herramientas para test de unidad (UT) no se integran con Visual Studio Team Suite. Esto podría solucionarse con productos de terceras partes.
* Si bien es mucho más ágil que la versión anterior, aún tiene algunos aspectos de performance que por lo general se mitigan agregando mas RAM.
* Las reglas de análisis de código parecen no ser personalizables y digo parecen porque no lo he podido lograr aún anque necesita mas investigación.

Mas allá de estas desventajas, se trata de un producto que me resultó de mucha utilidad y ayuda.
Con esta entrada del blog comienzo una serie de entradas en las que voy a mostrar algunas de las características que he tenido la oportunidad de utilizar, testear y aprovechar. Vamos a comenzar separando las prestaciones en diferentes categorías:

I) Categoría: Análisis de Código
a) Análisis dinámico de código
Resharper detecta de forma automática e instantánea errores en nuestro código y lo resalta sin que tengamos la necesidad de compilar siquiera. Realiza esta operación mientras estamos trabajando. Si posicionamos el mouse en la sección resaltada aparece un tooltip con la descripción del error

b) Advertencias
Además de los errores y advertencias que son detectables por el compilador, Resharper nos provee advertencias adicionales que pueden llegar a ser errores reaales de código.
Por citar algunos ejemplos nos brinda avisos de casteos redundantes, formateo incorrecto de strings, variables locales declaradas pero nunca utilizadas, etc

c) Sugerencias de Código
Resharper realiza un análisis en profundidad en la estructura de nuestro código activando sugerencias de código, las cuales no representan que existen errores pero nos proporciona información que es muy útil conocer, dado que están basadas en las mejores prácticas de diseño.

d) Quick-fixes
Cuando Resharper detecta un error, lo señaliza a traves del ícono de una lampara roja en la parte izquierda de la linea que contiene el error. A través de un shortccut (ALT+ENTER) aparecen las diferentes opciones de fix y al seleccionar la opción que mejor se adecua a nuestras necesidades se corrige automáticamente.

e) Indicador de estado
Al abrir un archivo, Resharper ejecuta un análisas en profundidad utilizando las reglas y mejores prácticas y nos informa a traves de códigos de colores el "estado de salud" del código que contiene nuestro archivo. Este indicador de estado lo encontramos en la esquina superior derecha del archivo, pero adicionalmente posee indicadores de color en cada linea (también en la parte derecha de nuestro editor).

f) Análisis de valor
Este tipo de análisis está relacionado a los valores de nuestras variables y objetos. Es utilizada principalmente para detectar valores que pueden estar seteados a null y brindar un aviso inmediatamente. Otra utilización frecuente es avisarnos de que una variable del tipo boolean está siempre seteada a true o a false.

Sistema de Archivos: Unidades de Disco

2007-10-31T21:01:00.001-03:00

La clase DriveInfo nos brinda los elementos necesarios para poder acceder a la información de las unidades disponibles en nuestro sistema. esto incluye no solo los discos rigidos, sino las unidades de red que tengamos mapeadas, unidades extraibles, etc.-

Esta clase posee un único metodo estático (GetDrives()) el cual devuelve la lista de todas las unidades de nuestro sistema.

Las instancias de esta clase cuentan con las siguientes propiedades:
- AvailableFreeSpace: Retorna el espacio disponible de una unidad (en bytes). Puede diferir del valor retornado por TotalFreeSpace, dependiendo de las cuotas de discos.
- DriveFormat: Retorna el formato de la unidad tal como FAT32 o NTFS.
- DriveType: Retorna una enumeración (ver el ejemplo) para el tipo de la unidad (Fijo, Optico, Red, etc.)
- IsReady: Retorna el estado de la unidad. Especifica si la unidad esta lista para ser accedida (por ejemplo no es posible acceder a mi unidad de CD mientras escucho mi CD de musica)
- Name: El nombre de la unidad.
- RootDirectory: Retorna un objeto DirectoryInfo que representa el directorio raiz de la unidad.
- TotalFreeSpace: Retorna el total de espacio libre en la unidad (en bytes).
- TotalSize: Retorna el tamaño total de la unidad.
- VolumeLabel: Retorna o escribe una etiqueta para unidades que no sean de solo lectura (CD/DVD).

Veamos un ejemplo utilizando algunos de estos conceptos:

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

namespace Exam70536.FileSystemTest
{
 class Program
 {
     private const string HARD_DRIVES = "Unidades de Discos duros";
     private const string NETWORK_DRIVES = "Unidades de Red";
     private const string OPTICAL_DRIVES = "Unidades de CD/DVD";
     private const string REMOVABLE_DRIVES = "Unidades Extraibles";
     private const string LINE = "--------------------------------------------";

     static void Main(string[] args)
     {
         ViewSystemDrives();
         Console.ReadKey();
     }

     private static void ViewSystemDrives()
     {
         DriveInfo[] drives = DriveInfo.GetDrives();
         List<DriveInfo> hardDrives = null;
         List<DriveInfo> opticalDrives = null;
         List<DriveInfo> netDrives = null;
         List<DriveInfo> remDrives = null;
      
         try
         {
             hardDrives = new List<DriveInfo>();
             opticalDrives = new List<DriveInfo>();
             netDrives = new List<DriveInfo>();
             remDrives = new List<DriveInfo>();

             foreach (DriveInfo drive in drives)
             {                                                    
                 switch (drive.DriveType)
                 {
                     case DriveType.CDRom:
                         if (drive.IsReady)
                             opticalDrives.Add(drive);
                         break;
                     case DriveType.Fixed:
                         hardDrives.Add(drive);
                         break;
                     case DriveType.Network:
                         netDrives.Add(drive);
                         break;
                     case DriveType.NoRootDirectory:
                         break;
                     case DriveType.Ram:
                         break;
                     case DriveType.Removable:
                         remDrives.Add(drive);
                         break;
                     case DriveType.Unknown:
                         break;
                     default:
                         break;
                 }
             }

             Console.WriteLine(HARD_DRIVES);
             Console.WriteLine(LINE);
             foreach (DriveInfo hDrive in hardDrives)
             {
                 Console.WriteLine("{0}  Tamaño:{1}GB  Espacio disponible:{2}GB",
                     hDrive.Name,
                     hDrive.TotalSize / 1024 / 1024 / 1024,
                     hDrive.AvailableFreeSpace / 1024 / 1024 / 1024);
             }

             Console.WriteLine();
             Console.WriteLine(OPTICAL_DRIVES);
             Console.WriteLine(LINE);
             foreach (DriveInfo oDrive in opticalDrives)
             {
                 Console.WriteLine("{0}", oDrive.Name);
             }

             Console.WriteLine();
             Console.WriteLine(REMOVABLE_DRIVES);
             Console.WriteLine(LINE);
             foreach (DriveInfo rDrive in remDrives)
             {
                 Console.WriteLine("{0}", rDrive.Name);
             }

             Console.WriteLine();
             Console.WriteLine(NETWORK_DRIVES);
             Console.WriteLine(LINE);
             foreach (DriveInfo nDrive in netDrives)
             {
                 Console.WriteLine("{0}", nDrive.Name);
             }          
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.Message);
         }
     }
 } 
}

ASP.NET AJAX Extensions: Introduccion

2007-08-29T16:22:00.000-03:00

AJAX es un término genérico para definir una colección de tecnologías y procesos que podemos utilizar en nuestras aplicaciones web. ASP.NET AJAX es la implementación comenzada por Microsoft y que luego pasó a ser mantenida por una comunidad e incluye varios beneficios para los desarrolladores.

Muchos desarrolladores hemos encontrado un poco complicado crear aplicaciones con AJAX debido a la complejidad relacionada con JavaScript para implementar funcionalidad AJAX.

ASP.NET AJAX combina una extensa librería de código con una coleccion de componentes del lado del servidor que hacen la vida de los desarrolladores mucho mas simple y pueden ser utilizadas en nuestras aplicaciones AJAX-enabled. Algunos de los beneficios principales de la utilización de esta tecnología harán que nuestras aplicaciones web sean:

- Más dinámicas.
- Con mejores tiempos de respuesta.
- Más fáciles de utilizar.
- Más interesantes desde el punto de vista de usuario.
- Compatibles con la gran mayoria de los browsers.

Funcionalidad del lado del Cliente:
Del lado del cliente, ASP.NET AJAX provee un conjunto de archivos con código JavaScript conocidos como AJAX Library lista para ser agregada a nuestras aplicaciones web. Estos archivos. Estos archivos usan extensiones del lenguaje JavaScript para hacer posible que el código sea parecido a C#, incluyendo el uso de estructuras de Programación Orientada a Objetos (POO) . Esto nos permite a los desarrolles agregar codigo JavaScript a nuestras aplicaciones web de una forma mucho mas fácil. Además, esta librería trabaja con todos los browsers actuales liberando al desarrollador de la tediosa tarea de escribir código específico para cada browser.

Funcionalidad del lado del Servidor:
Para los desarrolladores ASP.NET 2.0 está disponible una serie de controles de servidor conocido como AJAX extensions, estos controles del lado del servidor permiten escribir muy pocas o ninguna linea de código JavaScript. Todos los controles de servidor generan el código JavaScript necesario. Algunos de estos controles conocidos como extenders afectan la funcionalidad o comportamiento de otros controles en vez de proveer su propia interfaz de usuario. De esta forma, podemos utilizar por ejemplo un text box extender para agregar la funcionalidad a un text box de nuestra aplicación para por ejemplo agregar la funcionalidad de autocompletar.

Framework Extensible:
ASP.NET AJAX nos permite extender o ampliar la funcionalidad existente, tanto de código del lado del cliento como de codigo del lado del servidor. Hay disponibles clases bases y archivos JavaScript de los cuales se pueden heredar y agregar funcionalidad. También se puede descargar el AJAX Control Toolkit con el cual tendremos disponibles muchos componentes listos para utilizar (extenders).
El AJAX Control Toolkit incluye una plantilla para simplificar la creación de componentes del lado del cliente.

Hasta aqui una breve introduccion. En proximas entradas ire profundizando en conceptos relaciondos.

Visual Studio add-in: GhostDoc

2007-08-03T07:39:00.000-03:00

GhostDoc es un add-in para Microsoft Visual Studio 2003/2005 que permite generar de forma automátizada comentarios XML indispensables para la documentación en nuestros desarrollos. El mayor problema de escribir estos comentarios XML es quye es un trabajo tedioso que demanda tiempo y por lo general se termina escribiendo siempre comentarios generales y similares. El objetivo de GhostDoc es automatizar este trabajo tedioso mirando el nombre de nuestras clases y métodos como así también y realizar una "adivinanza" de lo que los comentarios XML deberían incluir. El único problema, pero que a largo plazo redunda en mejoras a nuestro código es que funciona en inglés y de acuerdo a las recomendaciones en la nomenclatura de nuestros elementos (clases, interfaces o métodos). No debería reemplazar nuestra tarea de documentación pero al menos se encarga de la parte repetitiva de la misma.

- Source / Download: http://www.roland-weigelt.de/ghostdoc/

- Licencia: FREE.

- Integración con el IDE de Desarrollo: Luego de la instalación al abrir VS 2005 nos aparecen dos pantallas para terminar de configurar el ad-in. En las mismas se nos requiere asignar un atajo de teclado donde CTRL+Shift+D es el atajo por defecto aunque podemos seleccionar de un drop down list otras opciones e incluso podemos omitir este paso. Este add-in tiene tres formas principales de integrarse a nuestro IDE

A través de una opcion en el menú Tools -> GhostDoc
A través del menú contextual con la opción "Document this"
A través del atajo de teclado una vez que hemos seleccionado un elemento (clase, interface, método)

- Veamos un ejemplo:

Supongamos que tenemos el siguiente método

    public DataSet getEmployeeList(long companyId, string companyName)
{
DataSet dsEmployees = new DataSet();
// Code for getting DataSet
return dsEmployees;
}

Al seleccionar el método y utilizar cualquiera de las tres opciones enumeradas anteriormente veremos que se genera de forma automática lo siguiente:

    /// <summary>
/// Gets the employee list.
/// </summary>
/// <param name="companyId">The company id.</param>
/// <param name="companyName">Name of the company.</param>
/// <returns></returns>
public DataSet getEmployeeList(long companyId, string companyName)
{
DataSet dsEmployees = new DataSet();
// Code for getting DataSet
return dsEmployees;
}

Como se puede observar, dependiendo de cuan descriptivo sean nuestros nombres de métodos y parámetros y las recomendaciones seguidas en cuestión de nomenclatura, resulta un complemento de mucha utilidad.

Visual Studio add-in: CopySourceAsHtml

2007-08-03T07:36:00.000-03:00

CopySourceAsHtml es un add-in para Microsoft Visual Studio 2003/2005 que permite copiar código fuente, coloreo de sintaxis y todo el formato provisto por Visual Studio como HTML para que sea muy cómodo insertarlo en nuestros sitios webs, blogs o foros. En nuestra fase de prueba hemos notado algunos problemas en como se visualiza en Blogger pero si se edita el HTML de Blogger se pueden lograr resultados aceptables. Más abajo incluimos una sección de código C# (aunque puede ser utilizado con VB.NET o cualquier lenguaje soportado por el Framework) para dar un ejemplo de cómo funciona. La idea de este add-in es lograr que un browser visualice el código lo más parecido posible al entorno de desarrollo y lo logra de forma más que aceptable.

- Source / Download: http://www.jtleigh.com/people/colin/software/CopySourceAsHtml/

- Licencia: FREE. COPYRIGHT NOTICE. Copyright © 2006 J.T. Leigh & Associates Inc. All rights reserved.

- Proceso de instalación: En el sitio web se pueden obtener los instaladores para las diferentes versiones de VS.NET (2003/2005). El proceso de instalación es bien sencillo y no ofrece complicaciones.

- Integración con el IDE de Desarrollo: La integración con el IDE de desarrollo es realmente muy simple, intuitiva y efectiva. Todo lo que necesitamos es seleccionar nuestro código fuente y realizar click derecho donde encontraremos la opción "Copy As HTML". Esta opción abre una caja de diálogo donde podemos setear numerosas propiedades como agregar números de línea, el tamaño de la indentación, y hasta podemos incluir código CSS personalizado.

GridView - Paginacion y Ordenamiento simultaneo

2007-08-02T20:03:00.000-03:00

Cuando trabajamos con el componente GridView las tareas mas comunes son las de Ordenamiento y de Paginación.
El hecho de lograr ambas tareas de forma simultanea en páginas ASP.NET presenta un pequeño cuidado; se debe mantener el índice de la página en la que estamos cuando establecemos un nuevo criterio de ordenamiento. De la misma forma debemos mantener el criterio de ordenamiento al cambiar el índice de la página a la que queremos acceder.

El código que sigue es un ejemplo o una de las formas, siempre hay mas de una forma :), de como se puede lograr esta tarea.-

- SortingPaging.aspx (nuestra página aspx)

    <asp:GridView ID="gridSample" runat="server" AutoGenerateColumns="false"
     AllowPaging = "true" OnPageIndexChanging = "gridView_PageIndexChanging"
     PageSize = "5"
     AllowSorting = "true" OnSorting = "gridView_Sorting">
     <Columns>
         <asp:BoundField HeaderText="Nombre"
             DataField="Nombre"
             SortExpression = "Nombre" />
         <asp:BoundField HeaderText="Edad"
             DataField="edad"
             SortExpression = "edad" />
     </Columns>
 </asp:GridView>

- SortingPaging.aspx.cs (nuestro archivo de code behind)

using System;
using System.Data;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class SortingPaging : Page {
 protected void Page_Load(object sender, EventArgs e) {
     DataSet ds = new DataSet();
     // Aqui llenamos nuestro DataSet
     DataView dv = ds.Tables[0].DefaultView;
     dv = sortDataView(dv, true);
     gridSample.DataSource = dv;
     gridSample.DataBind();
 }

 private string GridSampleSortDirection {
     get { return ViewState["SortDirection"] as string ?? "ASC"; }
     set { ViewState["SortDirection"] = value; }
 }

 private string GridSampleSortExpression {
     get { return ViewState["SortExpression"] as string ?? "Nombre"; }
     set { ViewState["SortExpression"] = value; }
 }

 private string getSortDirection() {
     switch (GridSampleSortDirection) {
         case "ASC":
             GridSampleSortDirection = "DESC";
             break;

         case "DESC":
             GridSampleSortDirection = "ASC";
             break;
     }
     return GridSampleSortDirection;
 }

 protected void gridView_PageIndexChanging(object sender, GridViewPageEventArgs e) {
     gridSample.DataSource = sortDataView(gridSample.DataSource as DataView, true);
     gridSample.PageIndex = e.NewPageIndex;
     gridSample.DataBind();
 }

 protected DataView sortDataView(DataView dataView, bool isPageIndexChanging) {
     if (isPageIndexChanging) {
         dataView.Sort = string.Format("{0} {1}",
         GridSampleSortExpression,
         GridSampleSortDirection);
     } else {
         dataView.Sort = string.Format("{0} {1}",
         GridSampleSortExpression,
         getSortDirection());
     }
     return dataView;
 }

 protected void gridView_Sorting(object sender, GridViewSortEventArgs e) {
     GridSampleSortExpression = e.SortExpression;
     int pageIndex = gridSample.PageIndex;
     gridSample.DataSource = sortDataView(gridSample.DataSource as DataView, false);
     gridSample.DataBind();
     gridSample.PageIndex = pageIndex;
 }
}

Navega tu sitio con siteMapPath

2007-07-31T20:43:00.000-03:00

Vamos a ver un ejemplo de como agregar navegación simplificada a través de diferentes secciones de nuestro sitio sin importar la estructura de directorios del mismo.

Siguiendo con la idea de utilizar nuestra aplicación base de ejemplo, vamos suponer que tenemos una sección de inscripciones de alumnos y que vamos a mostrar en determinadas páginas de nuestro sitio el camino que recorre la aplicación (Inicio > Alumnos > Inscripciones).

Para ello ASP.NET nos provee de elementos que nos hacen la vida muy facil. Para nuestro ejemplo vamos a utilizar 3 elementos:

- <asp:SiteMapDataSource/>
- <asp:SiteMapPath/>
- Archivo Site Map (xml)

Como se trata de código que nos gustaría utilizar en diferentes páginas de nuestro sitio, vamos a crear un web user control y vamos a agregarle los dos primeros elementos que mencionamos. El código sería algo como lo siguiente:

<%@ Control Language="C#" AutoEventWireup="true"
CodeFile="siteNavigation.ascx.cs" Inherits="commonControls_siteNavigation" %>
<asp:SiteMapDataSource ID="SiteMapDataSource1" runat="server" />
<asp:SiteMapPath ID="SiteMapPath1" runat="server"/>

Luego necesitamos crear el archivo web.siteMap.xml. Esto es tan simple como hacer click derecho en la aplicación > Add Item y seleccionar Site Map de las opciones en Visual Studio o bien agregar un archivo xml y nombrarlo web.siteMap.xml.

La estructura de este archivo es como el ejemplo que sigue. Note que todos los archivos están en el directorio raiz de mi aplicación pero a través de los nodos siteMapNode puedo lograr la creación de secciones lógicas de acuerdo a mis necesidades.

<?xml version="1.0" encoding="utf-8" ?>
<siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0" >
   <siteMapNode url="~\inicio.aspx" title="Inicio" description="">
       <siteMapNode url="~\alumnos.aspx" title="Alumnos" description="">
           <siteMapNode url="~\alumnoInscripcion.aspx"
            title="Inscripciones" description="" />
   </siteMapNode>
 </siteMapNode>
</siteMap>

Por último incluimos el web user control que creamos antes en las páginas que necesitamos que se muestre el path de la aplicación. Por ejemplo en nuestra página alumnoInscripcion.aspx:

<%@ Page Language="C#" MasterPageFile="~/MasterPage.master"
  AutoEventWireup="true"
  CodeFile="alumnoInscripcion.aspx.cs" Inherits="alumnoInscripcion"
  Title="Untitled Page" %>
<%@ Register Src="~/commonControls/siteNavigation.ascx"
   TagName="siteNavigation" TagPrefix= "uc1" %>

<asp:Content ID="Content1" ContentPlaceHolderID="ContentPlaceHolder1" Runat="Server">
   <uc1:siteNavigation ID="siteNavigation1" runat="server" />
</asp:Content>

Esto es todo lo que necesitamos; compilamos y ejecutamos la aplicacion y si vamos a nuestra página alumnoInscripcion.aspx veremos algo parecido a la siguiente imagen. Espero que les haya sido útil, no dejen de participar dejando comentarios.

Dando formato a código C# y HTML

2007-07-30T19:03:00.000-03:00

Una de las necesidades que surgen a partir de la decisión de comenzar un blog o sitio web que involucra tecnologías de desarrollo es la de ofrecer a tus lectores code snippets o porciones de código tanto HTML como C#.

Uno de los add-ins que he utilizado es CopySourceAsHTML. Pueden leer un artículo que he escrito en la siguiente url: http://www.ide-plugins.com.ar/visual-studio-add-ins/visual-studio-.net-2005/copysourceashtml.html

Esta extensión para Visual Studio funciona muy bien y me ha resultado muy util en otros sitios web y herramientas CMS (DNN, Joomla, etc), pero en lo que respecta a Blogger, no genera el código de forma óptima por lo cual he necesitado cambiarlo por uno que me recomendó mi amigo Martin Olivares Pick.

Se trata de un formateador online que podemos encontrar en: http://www.manoli.net/csharpformat/
Funciona mucho mejor con Blogger y es muy simple de utilizar, por lo tanto lo recomiendo ampliamente.

Gracias Martin!!!

ASP.NET AJAX Toolkit: Download e Instalación

2007-07-19T21:15:00.000-03:00

Una de las características principales de un desarrollo WEB 2.0 radica en la utilización de la tecnología AJAX. Microsoft nos provee de las herramientas necesarias para el desarrollo de aplicaciones con esta tecnología. Estas herramientas son las siguientes: las ASP.NET 2.0 AJAX Extensions 1.0 y el ASP.NET AJAX Control Toolkit. Vamos a ver en este primer contacto como conseguir estas herramientas, instalarlas en nuestro sistema y configurarlas en nuestro entorno de desarrollo.

- Download e Instalación
Para realizar el download de estas herramientas, apuntamos nuestro navegador favorito a la siguiente dirección: http://www.asp.net/ajax/downloads/;
aqui tenemos dos links para realizar el download de estas herramientas.

En el paso 1 vamos a hacer click en el link que muestra la figura para realizar el download de las ASP.NET Extensions v1.0. Este link nos direcciona una página del sitio web de Microsoft.

Una vez hecho el download procedemos a la instalación. El proceso de instalación es bastante estandar y no merece comentarios adicionales. La ruta donde se instalarán las extensiones es: C:\Archivos de programa\Microsoft ASP.NET\ASP.NET 2.0 AJAX Extensions\v1.0.61025

Luego repetimos el proceso para el paso 2 hacieno click en el botón Download the Control Toolkit. En este caso, accederemos a una página en el sitio de CodePlex. Aqui podremos descargar tanto el Toolkit incluyendo el código fuente. En nuestro primer contacto, solo necesitamos el Toolkit sin incluir el código, el cual es evidentemente un download de menor tamaño. Hacemos click en AjaxControlToolkit-NoSource.zip y lo descomprimimos en algún lugar de nuestro disco. En lo personal prefiero mantener cierto orden para esta instalación para lo cual descomprimo este archivo en la siguiente ruta: C:\Archivos de programa\Microsoft ASP.NET\ASP.NET AJAX Control Toolkit\.

- Configuración del entorno
Una vez realizados los pasos anteriores (Downloads de los dos archivos e instalación de las ASP.NET Extensions -este es un paso requerido por el Toolkit-). Abrimos Visual Studio y creamos un nuevo sitio web eligiendo "AJAX Control Toolkit Web Site" an la sección My Templates.

Aquí vamos a agregar un tab en nuestro Toolbox para poder utilizar los controles provistos por el Toolkit. Para ello hacemos click derecho debajo del tab General y elegimos "Add Tab"; le ponemos un nombre como AJAX Toolkit; dentro de este nuevo tab hacemos click derecho y seleccionamos la opción "Choose Items...", un cuadro de diáologo aparece y hacemos click en "Browse..." y buscamos la carpeta bin del sitio de ejemplo en el path de la instalación de las AJAX Toolkit. Par nuestro caso la ruta completa es C:\Archivos de programa\Microsoft ASP.NET\ASP.NET AJAX Control Toolkit\SampleWebSite\Bin; alli seleccionamos el archivo AjaxControlToolkit.dll y listo. Ahora tenemos disponibles los controles para agregar en nuestras aplicaciones ASP.NET!

- Paging and Sorting

2007-03-15T19:57:00.000-03:00

Las tareas de Paging y Sorting de forma simultanea en páginas ASP.NET presenta un pequeño cuidado; se debe mantener el índice de la página en la que estamos cuando establecemos un nuevo criterio de ordenamiento. De la misma forma debemos mantener el criterio de ordenamiento al cambiar el índice de la página a la que queremos acceder.

El código que sigue es un ejemplo o una de las formas, siempre hay mas de una forma :), de como se puede lograr esta tarea.-

- SortingPaging.aspx (nuestra página aspx)

    <asp:GridView ID="gridSample" runat="server" AutoGenerateColumns="false"
       AllowPaging = "true" OnPageIndexChanging = "gridView_PageIndexChanging"
       PageSize = "5"
       AllowSorting = "true" OnSorting = "gridView_Sorting">
       <Columns>
           <asp:BoundField HeaderText="Nombre"
               DataField="Nombre"
               SortExpression = "Nombre" />
           <asp:BoundField HeaderText="Edad"
               DataField="edad"
               SortExpression = "edad" />
       </Columns>
   </asp:GridView>

- SortingPaging.aspx.cs (nuestro archivo de code behind)

using System;
using System.Data;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class SortingPaging : Page {
   protected void Page_Load(object sender, EventArgs e) {
       DataSet ds = new DataSet();
       // Aqui llenamos nuestro DataSet
       DataView dv = ds.Tables[0].DefaultView;
       dv = sortDataView(dv, true);
       gridSample.DataSource = dv;
       gridSample.DataBind();
   }

   private string GridSampleSortDirection {
       get { return ViewState["SortDirection"] as string ?? "ASC"; }
       set { ViewState["SortDirection"] = value; }
   }

   private string GridSampleSortExpression {
       get { return ViewState["SortExpression"] as string ?? "Nombre"; }
       set { ViewState["SortExpression"] = value; }
   }

   private string getSortDirection() {
       switch (GridSampleSortDirection) {
           case "ASC":
               GridSampleSortDirection = "DESC";
               break;

           case "DESC":
               GridSampleSortDirection = "ASC";
               break;
       }
       return GridSampleSortDirection;
   }

   protected void gridView_PageIndexChanging(object sender, GridViewPageEventArgs e) {
       gridSample.DataSource = sortDataView(gridSample.DataSource as DataView, true);
       gridSample.PageIndex = e.NewPageIndex;
       gridSample.DataBind();
   }

   protected DataView sortDataView(DataView dataView, bool isPageIndexChanging) {
       if (isPageIndexChanging) {
           dataView.Sort = string.Format("{0} {1}",
           GridSampleSortExpression,
           GridSampleSortDirection);
       } else {
           dataView.Sort = string.Format("{0} {1}",
           GridSampleSortExpression,
           getSortDirection());
       }
       return dataView;
   }

   protected void gridView_Sorting(object sender, GridViewSortEventArgs e) {
       GridSampleSortExpression = e.SortExpression;
       int pageIndex = gridSample.PageIndex;
       gridSample.DataSource = sortDataView(gridSample.DataSource as DataView, false);
       gridSample.DataBind();
       gridSample.PageIndex = pageIndex;
   }
}

- Conversión de Ilist en DataTable

2007-03-15T18:19:00.000-03:00

Nota: Este código ha sido probado con .NET Framework 2.0

Muchas veces retornamos de nuestra fuente de datos un set de datos de tipo Ilist, el cual enlazamos a nuestros GridViews sin ningún problema.

Como veremos en próximas entradas, hay una forma muy interesante de realizar sorting y paging al mismo tiempo, para ello necesitamos pasar como parámetro un DataTable en uno de los métodos que implementaremos , por lo cual vamos a escribir una utilidad que convierta un Ilist en un DataTable.

Como en casos anteriores, tomaremos la aplicación de ejemplo de este blog (virtualEducation) y agregaremos en el módulo de Utilidades la clase Converter.cs, la cual iremos completando en las próximas entradas. En esta oportunidad , solo definiremos el método public static DataTable IList2DataTable(IList iList) para tener solo el conversor que necesitamos.

Aquí tenemos el código:


using System;
using System.Collections;
using System.Data;
using System.Reflection;

namespace Utilidades {
    public class Converter {
        public static DataTable IList2DataTable(IList iList) {
            DataTable oDataTableReturned = new DataTable();

            if (iList.Count > 0) {
                object _baseObj = iList[0];
                Type objectType = _baseObj.GetType();
                PropertyInfo[] properties = objectType.GetProperties();

                foreach (PropertyInfo property in properties) {
                    DataColumn oColumna;
                    oColumna = new DataColumn();
                    oColumna.ColumnName = property.Name;
                    oColumna.DataType = property.PropertyType;
                    oDataTableReturned.Columns.Add(oColumna);
                }

                foreach (object objItem in iList) {
                    DataRow oFila;
                    oFila = oDataTableReturned.NewRow();
                    foreach (PropertyInfo property in properties) {
                        oFila[property.Name] = property.GetValue(objItem, null);
                    }
                    oDataTableReturned.Rows.Add(oFila);
                }
            }
            return oDataTableReturned;
        }
    }
}

- Issue con nuevas clases en VS2005

2007-03-15T17:59:00.000-03:00

El nuevo Visual Studio 2005 es una muy buena herramienta que nos ofrece muchas ventajas y nos ahorra muchos esfuerzos.

Sin embargo hay una característica que no me resulta del todo agradable. Cuando agregamos librerias de clases (class libraries) como en el ejemplo de virtualEducation y creamos una clase dentro de alguna de estas librerías como hemos hecho en una entrada anterior con el generador de GUIDs; notamos que las clases nuevas no tienen accesibilidad pública por lo que al querer utilizarlas no están disponibles.

Esto requiere que agreguemos el modificador de acceso a public y hagamos un rebuild de la librería de clases y a veces necesitamos hacer rebuild de toda la solución.-

Me gustaría saber si alguien conoce una forma de configurar el VS 2005 para que por defecto genere las clases como públicas.

- Subir archivos grandes con httpRuntime

2007-03-12T19:54:00.000-03:00

En algunas situaciones necesitamos permitir que los usuarios de nuestra aplicación realicen upload de archivos de tamaño importante (digamos 6 a 10 Mb).
Hemos visto a través de una entrada anterior como subir archivos con ASP.NET y AJAX.
Por defecto, ASP.NET permite realizar uploads de hasta 4Mb. Hoy veremos como podemos configurar nuestros servidores o nuestra aplicación para que permita subir archivos mayores a este tamaño.

Esta configuración se puede realizar tanto en los archivos machine.config como en archivos web.config de cada aplicación. El elemento en cuestión que nos permitirá esta operación es <httpRuntime> a través de su atributo maxRequestLength.

Este atributo indica el tamaño máximo soportado por ASP.NET para un archivo que necesita ser subido a un servidor. El tamaño se debe especificar en kbytes. Como adelantamos antes el valor por defecto es 4096 kb.

El elemento <httpRuntime> debe ubicarse dentro de la sección configuration/system.web de nuestro archivo de configuración. Veamos un ejemplo simple para un archivo de 6Mb:

<configuration>
   <system.web>
      <httpRuntime maxRequestLength="6144"/>
   </system.web>
</configuration>

- GUID Generator con C#

2007-03-12T10:01:00.000-03:00

GUID es un acrónimo para Globally Unique Identifier o identificador único global, es un número de 128 bits que es producido por el sistema operativo Windows o por algunas aplicaciones Windows para identificar un componente particular, una aplicación, un archivo, un registro en una base de datos y/o un usuario. Por ejemplo, podemos tener un sitio web que genere un GUID y se lo asigne a un usuario para grabar las acciones de este usuario en la sesión (lo que se conoce como session tracking).

GUID se utiliza también en el registro de Windows para identificar dlls COM. Algunos DBAs incluso utilizan un GUID como claves primarias de sus bases de datos.
Un ejemplo de GUID generado es el siguiente: {ded53e2b-91e9-4682-b673-862ca6503b2e}

Si bien no está garantizado que un GUID generado sea único, el total de claves que se pueden generar (2 elevado a la 128 potencia) es tan grande que la probabilidad de que se repita es realmente muy pequeña. Para dar una idea de esto podemos decir que una aplicación que genere 10 mil millones de GUID la probabilidad de que se repita una clave generada es de 1 en un quintillión (en la escala americana - 10 elevado a la 30 potencia en la escala tradicional).

Veamos entonces como se genera un GUID en una aplicación Windows con C#. Para mostrar un ejemplo vamos a utilizar la aplicación virtualEducation que generamos en una entrada anterior (ver entrada) y vamos a ubicar nuestra clase GUIDGenerator en el módulo de Utilidades.
Este es todo el código que necesitamos:



namespace Utilidades {
    class GUIDGenerator {
        public static string getGUIDString() {
            string guidIdentifier = System.Guid.NewGuid().ToString();
            guidIdentifier = guidIdentifier.Replace("-", string.Empty);
            guidIdentifier.ToUpper();
            return guidIdentifier;
        }
    }
}

- Tabs simples en ASP.NET

2007-03-09T14:48:00.000-03:00

Algunas de nuestras aplicaciones necesitan mostrar tabs o elementos superpuestos. Vamos a ver como se logra este efecto utilizando dos elementos de ASP.NET; estos son el elemento asp:Menu y el elemento asp:MultiView. El código es realmente muy sencillo y nos ayudamos con un set de 4 imágenes. Dos imágenes para el primer y segundo tab (con sus estados activado y desactivado).

-SimpleTabulation.aspx (nuestra página aspx)

<body>
   <form id="form1" runat="server">
       <div>
           <asp:Menu ID="MenuTab" Width="120px" runat="server"
               Orientation="Horizontal" StaticEnableDefaultPopOutImage="False"
               OnMenuItemClick="MenuTab_MenuItemClick">
               <Items>
                   <asp:MenuItem ImageUrl="~/images/TabOneOn.jpg" Value="0"/>
                   <asp:MenuItem ImageUrl="~/images/TabTwoOff.jpg" Value="1"/>
               </Items>
           </asp:Menu>
           <asp:MultiView ID="MultiView1" runat="server" ActiveViewIndex="0">
               <asp:View ID="View1" runat="server">
                   Contenido del Tab 1!
               </asp:View>
               <asp:View ID="View2" runat="server">
                   Contenido del Tab 2!
               </asp:View>
           </asp:MultiView>
       </div>
   </form>
</body>

-SimpleTabulation.aspx.cs (nuestro archivo de code behind)

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

public partial class SimpleTabulation : Page {
   protected void MenuTab_MenuItemClick(object sender, MenuEventArgs e) {
       MultiView1.ActiveViewIndex = Int32.Parse(e.Item.Value);
       int selectedTab = Int32.Parse(e.Item.Value);

       switch (selectedTab) {
           case 0:
               MenuTab.Items[0].ImageUrl = "~/images/TabOneOn.jpg";
               MenuTab.Items[1].ImageUrl = "~/images/TabTwoOff.jpg";
               break;

           case 1:
               MenuTab.Items[0].ImageUrl = "~/images/TabOneOff.jpg";
               MenuTab.Items[1].ImageUrl = "~/images/TabTwoOn.jpg";
               break;
       }
   }
}

- Custom Exceptions en ASP.NET

2007-03-09T14:14:00.000-03:00

En esta entrada veremos como utilizar excepciones personalizadas o custom exceptions. La idea básica es muy simple. Se trata crear una clase que herede de la clase Exception de ASP.NET y pasarle argumentos básicos como puede ser el mensaje de la excepción e incluso parámetros personalizados. Vamos a ver un ejemplo muy simple en el cual tenemos un label en el cual mostraremos el mensaje de la excepción arrojada desde nuestra aplicación.

- CustomExceptions.aspx (nuestra página aspx)

<body>
   <form id="form1" runat="server">
       <div>
           <asp:Label ID="lblException"
           runat="server" Text="" />
       </div>
   </form>
</body>

- CustomExceptions.aspx.cs (nuestro archivo de code behind)

using System;
using System.Web.UI;

public class MyCustomException : Exception {
   public MyCustomException(string message) : base(message) { }
}

public partial class TestCustomExceptions : Page {

   public void Page_Load(object sender, EventArgs e) {
       try {
           if (1 == 1) {
               throw new MyCustomException("Testing Custom Exceptions.-");
           }
       } catch (MyCustomException exc) {
           Trace.Write(exc.Message);
           lblException.Text = exc.Message;
       }
   }
}

- File Upload con AJAX

2007-03-09T12:17:00.000-03:00

Vamos a ver en esta entrada el código necesario para realizar upload de un archivo y que la experiencia de usuario sea cómoda a través del uso de AJAX. El concepto es muy simple; utilizamos dos divs, uno para mostrar el componente FileUpload de ASP.NET y otro para mostrar un mensaje o una imagen animada al usuario mientras la tarea de subir el archivo se ejecuta en segundo plano y no se muestra al usuario ninguna acción de Postback o roundtrip al servidor. A través de AJAX utilizamos una serie de funciones JavaScript para mostrar/ocultar los divs.

He aquí el codigo necesario:
- FileUpload.aspx (Nuestra página aspx)

<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" runat="server">
   <title>File Upload Test</title>
<script language="javascript" type="text/javascript">

function divFileHide() {
   var divFile = document.getElementById('fileUploadDiv');
   divFile.style.display = 'none';
  
   var divLoading = document.getElementById('loadingFileDiv');
   divLoading.style.display = 'block';
}

function divFileShow() {
   var divFile = document.getElementById('fileUploadDiv');
   iframe.style.display = 'block';

   var divLoading = document.getElementById('loadingFileDiv');
   divLoading.style.display = 'none';
}

function upload(){
   divFileHide();
}

function onComplete( result ) {
   divFileShow();
}
</script>

</head>
<body>
   <form id="form1" runat="server">
       <div id="fileUploadDiv">
           <asp:FileUpload ID="FileUpload1" runat="server" Visible="true" />
           <asp:Button ID="btnUpload" runat="server" Text="Subir Archivo"
               OnClick="btnUpload_Click"
               Visible="true" />
           <asp:Label ID="lblError" runat="server" Visible="false"
           Font-Bold="true" ForeColor="red" />
       </div>
       <div id="loadingFileDiv" style="display: none;">
           El archivo está subiendo...
       </div>
   </form>
</body>

- FileUpload.aspx.cs (Nuestro archivo de code behind)

using System;
using System.Web.UI;

public partial class FileUpload : Page {
   protected void Page_Load(object sender, EventArgs e) {
       btnUpload.Attributes.Add("onclick", "return upload();");
   }
   protected void btnUpload_Click(object sender, EventArgs e) {
       if (FileUpload1.HasFile) {
           try {
               String uploadFolder = "D:\\Uploads\\";
               String file = FileUpload1.FileName;

               FileUpload1.SaveAs(uploadFolder + file);
           } catch (Exception ex) {
               Trace.Write(ex.Message);
           }
       } else {
           lblError.Text = "El archivo no ha sido especificado";
           lblError.Visible = true;
       }
   }
}

- Esqueleto de una aplicación Web en ASP.NET

2007-03-01T09:59:00.000-03:00

En esta oportunidad quiero compartir con ustedes una de las formas básicas de crear una aplicación web que utilice componentes reutilizables, que tenga módulos independientes y que pueda integrar algún framework de persistencia como NHibernate o Ibatis.
Esta tarea la llevaremos a cabo utilizando el IDE de desarrollo Visual Studio 2005. Vamos a suponer que estamos desarrollando una aplicación orientada a e-learning. Lo primero que debemos tener presente es que todos estos módulos los tendremos en una misma carpeta. En mi caso la carpeta en cuestión es D:\NETProjects\E-Learning.

* Módulos de nuestra aplicación:
- Sitio Web: En éste módulo tendremos nuestras páginas .aspx con sus correspondientes archivos de code behind (.aspx.cs), las cuales utilizarán las clases y objetos (no se trata de otra cosa) del resto de los módulos involucrados en la aplicación.

- Módulo de Model: En éste módulo almacenaremos todas las clases de objetos que nuestra aplicación requiera. En nuestro caso, al tratarse de una aplicación de e-learning, ejemplos de clases que pondremos en este módulo son: curso, asignatura, profesor, etc.

- Módulo de Persistencia: En éste módulo crearemos dos carpetas. La primera será nuestra carpeta de Interfaces en la cual tendremos las interfaces de las clases que necesitamos persistir. El uso de interfaces nos permite además migrar de un framework a otro teniendo que modificar solo las implementaciones del mismo. Entonces necesitaremos una segunda carpeta que puede llamarse Implementaciones. En ella almacenaremos los archivos necesarios que dependerán del framework de persistencia que elijamos.

- Módulo de Servicio: En éste módulo se almacenarán las clases necesarias para ejecutar llamadas a las clases en el módulo de persistencia y eventualmente procesar reglas de negocio antes de realizar la persistencia.

- Módulo de Utilidades: En éste módulo se almacenarán aquellas clases que pueden ser reutilizables en más de un proyecto como pueden ser utilidades de conversion para listas, arrays, etc.-

Veamos como es el proceso en Visual Studio 2005 para lograr este esqueleto:

1- Sitio Web: Creamos el sitio Web a través de la opción File... New Web Site... elegimos el lenguaje (C# en nuestro caso) , elegimos la ruta y el nombre de nuestro sitio o aplicación Web, para nuestro ejemplo será D:\NETProjects\E-Learning\virtualEducation donde E-Learning es la carpeta del proyecto conteniendo todos los módulos y virtualEducation es nuestro sitio web.

2- Módulos: Agregamos los móulos que vamos a necesitar. Abrimos la opción File... New Project y aquí tenemos varias opciones a tener en cuenta. Lo primero es elegir el tipo de proyecto. Elegimos Visual C# - Windows en Project types. Elegimos Class Library como template. Especificamos el nombre del poyecto, en nuestro caso Model, especificamos la ubicación: D:\NETProjects\E-Learning y por último seleccionamos el drop down list a Add to Solution.

Realizamos el mismo procedimiento para nuestros otros módulos teniendo en cuenta la creación de las dos carpetas en el módulo de Persistencia (Interfaces e Implementaciones)

3- Referencias: Ahora necesitamos agregar a nuestro sitio web las referencias a estos módulos para que al realizar la compilación nos genere dlls para estos proyectos. Para ello hacemos click derecho en nuestro sitio web y seleccionamos Add Reference... vamos al tab de Projects y seleccionamos los proyectos creados en el paso anterior.

4- Construir Solución: Por último, hacemos click derecho a nuestra solución Solution \virtualEducation (5 projects) y elegimos la opción Rebuild Solution. Vemos como se generan las dlls de nuestros proyectos en la carpeta Bin de nuestro sitio web.-

Con estos sencillos 4 pasos, tenemos listo nuestro esqueleto para una aplicación Web modularizada, escalable, lista para utilizar un framework de persistencia y componentes reutilizables.-

- Tooltips en columnas de GridView

2007-03-01T09:38:00.000-03:00

Muchas veces por razones de espacio necesitamos poner nombres abreviados o acrónimos en las cabeceras de nuestros GridViews. Para enriquecer la experiencia de usuario podemos agregar tooltips a estas cabeceras de una forma muy sencilla de modo de proveer al usuario el nombre completo o mas descriptivo para determinado campo mostrado.

Pre-Requisitos:
* Tenemos establecida la conexión a la base de datos.
* Tenemos un DataSet con los datos para realizar el Binding al Dataview.
* Tenemos los datos en el gridview a traves de Databind().

Elementos Clave:
* Habilitar la propiedad HtmlEncode a false en cada campo enlazado.
* Utilizar elementos HTML en la propiedad HeaderText.

He aquí nuesto código:
- products.aspx (Nuestra página aspx)

<asp:gridview id="gvProducts" runat="server" autogeneratecolumns="false">
  <Columns>
      <asp:BoundField
          HeaderText="Producto"
          DataField="name"/>
      <asp:BoundField
          HtmlEncode="false"
          HeaderText="&lt;div title='Cantidad'> Cant. </div>"
          DataField="qty"/>
      <asp:BoundField
          HtmlEncode="false"
          HeaderText="&lt;div title='Precio'> $ </div>"
          DataField="price"/>
  </Columns>
</asp:gridview>

Esta es solo una de las formas de realizarlo, otra forma es utilizando el tag <acronym> de HTML.