Vicrodg´s blog

Capitulo 12–Usuarios y seguridad de datos

2010-12-31T14:40:00.001-03:00

Hola nuevamente!! ... perdón la demora. Como actualmente me encuentro en Barcelona trabajando, no he podido hacerme tiempo para mi blog.

Espero que algunos ya hayan podido rendir esta certificación, y para los que no, continúo con el resumen. Espero les sirva.

Muchas gracias por los comentarios!.

_____________________________________________________________________

Usuarios y seguridad de datos

En una empresa es importante controlar quién puede acceder a los datos confidenciales.

Por ej., una aplicación para el seguimiento de gastos debe mostrar a los usuarios sus propios gastos, pero los administradores pueden ver los gastos de otras personas.

La protección de datos requiere la coordinación de varias tecnologías diferentes. Seguridad basada en roles (RBS) que permite controlar lo que los usuarios pueden acceder en función de su nombre de usuario y pertenencias a grupos.

Para proteger los datos, el Framework de. NET proporciona herramientas de criptografía para cifrar, validar y firmar datos.

Lección 1- Autentificación y autorización de usuarios

Autentificación es identificar al usuario. A partir de PINs o nombres y contraseñas.

Autorización es el proceso de verificar si el usuario tiene permiso de acceder a algo o no. generalmente sucede después de la autentificación.

La clase windowsIdentity

System.Security.Principal. WindowsIdentity nos da acceso al nombre de usuario actual de windows, el tipo de autenticación y un número token. Almacena el resultado de la autenticación, incluyendo su username y token.

Para poder crear una instancia de WindowsIdentity se puede llamar a cualquiera de estos métodos:

· GetAnonymous, representa un usuario no autenticado
· GetCurrent, devuelve el usuario actual de Windows
· Impersonate, devuelve un WindowsImpersonationContext que representa un usuario específico en el sistema.

Ejemplo:

Después de que la variable es asignada, sus propiedades son:

· AuthenticationType, cadena que representa el método de autenticación (NTLM normalmente)
· IsAnonymous, indica si un usuario anónimo.
· IsAuthenticated, indica si es usuario autenticado.
· IsGuest, indica si el usuario es invitado.
· IsSystem, indica si el usuario es parte del sistema.
· Name, una cadena representando el dominio y username de la forma "DOMAIN\Username".
· Token, un entero representando el token de autenticación del usuario.

Clase WindowsPrincipal

Esta clase nos brinda acceso al group membership. Se debe crear usando una instancia de WindowsIdentity. Por ejemplo:

Otra forma de conseguir una instancia de WindowsPrincipal, es usando el thread principal

El método más importante de esta clase es: IsInRole. Y se puede usar de la siguiente manera:

La mayoría de las veces, no se sabrá el nombre del equipo o el nombre de dominio antes de tiempo como para insertarlo en la cadena que se pasa al método IsInRole. En lugar de esto, se puede usar System.Environment.MachineName para obtener los nombres de grupos de la maquina local, o System.Environment.UserDomainName para especificar los nombres de grupos que existen en maquina local o en un Active Directory Domain.

Clase PrincipalPermission

La clase PrincipalPermission es útil para realizar acciones de seguridad, imperativas y declarativas. Se pueden combinar cualquiera de las 3 propiedades de esta clase:

· Authenticate, indica si requiere que el usuario este autenticado.
· Name, string con el username.
· Role, string que debe coincidir con uno de los roles principales.

PrinciapalPermission posee el método Demand que verifica si el usuario activo tiene los permisos indicados.

Cómo usar la declarativa para realizar peticiones de seguridad para restringir el acceso a los métodos?

La RBS Declarativa restringe el acceso a un método. El problema que tiene es que si en runtime se lanza una excepción por un evento de windows, este la captura y la aplicación se puede detener.

Para usar RBS declarativa, se debe tener en el código:

· El método System.AppDomain.CurrentDomain.SetPrincipalPolicy para especificar la política de seguridad.
· Bloques try/catch para capturar acceso desprivilegiado y mostrarlo como error.
· El Atributo PrincipalPermission para declarar requerimientos de acceso a método.

Ejemplo:

Ejemplo con varias declarativas:

Cómo usar el método imperativo de seguridad basado en demandas para crear aplicaciones que restrinjan el acceso a porciones de su lógica?

El método imperativo de demandas RBS le permiten restringir las porciones de un método, mientras que las demandas RBS declarativa los restringen en su totalidad.

Para usarla se deben de tener 4 elementos:

· El método System.AppDomain.CurrentDomain.SetPrincipalPolicy para especificar las políticas de seguridad principales.
· Bloques Try/catch para capturar accesos no privilegiados.
· El objeto PrincipalPermission con propiedades acordes a las restricciones que se quieren imponer.
· Una llamada al método PrincipalPermission.Demand para declarar los requerimientos de acceso al método.

Ejemplo, el código una lanza excepción (que se captura con System.Security.SecurityException), si el usuario no es miembro del grupo Administrators:

Como implementar usuarios y roles personalizados?

Si se necesita autenticar a los usuarios contra una base de datos personalizada, se pueden utilizar las interfaces System.Security.Principal.IIdentity y System.Security.Principal.IPrincipal. Además se pueden ampliar aplicando clases de identidad propias, con propiedades y funcionalidades adicionales.

Cómo crear una clase de identidad personalizada?

La interfaz IIdentity sirve para crear clases de identidad personalizadas.

WindowsIdentity, FormsIdentity y PassportIdentity son clases que implementan esta interfaz. Mientras que GenericIdentity ofrece una implementación flexible de IIdentity.

Para implementar esta interfaz, se deben usar las siguientes propiedades:

· AuthenticationType, string que almacena la descripción del mecanismo de autenticación del usuario.
· IsAuthenticated, se setea este valor en true cuando el usuario ha sido autenticado.
· Name, string que guarda el username.

Además de este, se debe realizar un constructor que defina cada una de las propiedades.

Ejemplo:

Cómo crear una clase principal personalizada?

WindowsPrincipal y GenericPrincipal están basadas en la interfaz IPrincipal. Los objetos basados en esta interfaz representan el contexto de seguridad de un usuario, incluyendo la identidad del usuario y cualquier rol o grupo al que pertenezca.

Para implementar la interfaz IPrincipal, debemos de implementar al menos un constructor, una propiedad y un método. El constructor debe aceptar un objeto IIdentity y un arreglo de strings que contienen los roles de identidad. La propiedad que se debe implementar es IPrincipal.Identity que debe devolver el identity principal del objeto.

El metodo IPrincipal.IsInRole que toma un string y un rol y retorna true cuando el identity principal es un miembro de ese rol; sino retorna false.

También se pueden añadir otras funcionalidades sobrescribiendo IPrincipal:

· Añadir una propiedad Roles que devuelva un arreglo de strings conteniendo los roles del usuario.
· Agregar los métodos IsInAllRoles y IsInAnyRole que indiquen si el usuario es miembro de múltiples roles.
· Añadir los métodos IsHigherThanRole y IsLowerThanRole que habiliten jerarquía en los grupos de membresía.

Ejemplo de implementación:

Como crear modelos simples de privilegios de usuario personalizados?

Si solo se necesitan las funcionalidades básicas de IIdentity y IPrincipal, se debe usar System.Security.Principal.GenericIdentity y System.Security.Principal.GenericPrincipal. Estas clases implementan solo las propiedades y métodos requeridos por las interfaces. Cada uno ofrece constructores que la aplicación debe de usar para especificar las propiedades de cada clase.

GenericIdentity: tiene 2 constructores. Se puede usar un username, o un username y el tipo de autenticación.

GenericPrincipal: tiene un constructor que pide un GenericIdentity y un arreglo de string con los roles de identidad.

Después de crear el objeto principal, principal.IsInRole("Users") debería retornar true.

Cómo utilizar demandas RBS con identidades personalizadas y principals?

Si es que se define custom IIdentity y IPrincipal, o se usa GenericIdentity y GenericPrincipal, se puede usar declarativa e imperativa RBS estos pasos:

1. Crear un objeto IIdentity o GenericIdentity que represente al usuario actual.

2. Crear un objeto IPrincipal o GenericPrincipal basado en mi objeto IIdentity

3. Setear Thread.CurrentPrincipal a mi objeto IPrincipal

4. Adherir una declarativa o imperativa RBS.

Manejando excepciones en Streams

Para manejar autenticaciones remotas, se usa: System.Net.Security.NegotiateStream o System.Net.Security.SslStream.

Estas excepciones pueden ser:

· System.Security.Authentication.AuthenticationException: Una excepción de este tipo indica que se debe solicitar al usuario credenciales diferentes y que vuelva a intentar la autenticación.
· System.Security.Authentication.InvalidCredentialException: indica que el stream no se encuentra en un estado válido, y no se puede volver a intentar la autenticación.

Capitulo 11 - Seguridad de aplicaciones

2010-11-30T04:21:00.006-03:00

Lección 1- entendiendo la seguridad de acceso a código Code Access Security (CAS)

¿Qué es el código de seguridad de acceso?
La seguridad de acceso a código (CAS) es un sistema de seguridad que permite a los administradores y desarrolladores de aplicaciones controlar y autorizar a los usuarios. Con CAS, se puede permitir que una aplicación lea y escriba en el registro. Se puede controlar la autorización usando seguridad basada en roles de sistema (RBS), de:

El sistema de archivos
El registro
Impresoras
Los registros de sucesos

Elementos de seguridad de acceso a código
Cada sistema de seguridad necesita una forma de identificar a los usuarios y determinar lo que un usuario puede o no puede hacer. Como CAS identifica y asigna los permisos a las aplicaciones en lugar de a la gente, que no puede utilizar los nombres de usuario, contraseñas y listas de control de acceso (ACL). En cambio, CAS identifica assemblies usando evidencias. Una evidencia es una manera de identificar la ubicación donde se almacena, un hash del código del assembly, o su firma. Un conjunto de pruebas determina el código de grupo al que pertenece y le otorga permisos.

¿Qué es la evidencia?
La evidencia es la información que se obtiene en tiempo de ejecución acerca de un assembly a para determinar qué grupos de código pertenece. Las formas comunes de pruebas incluyen la carpeta o el sitio Web donde el assembly se está ejecutando y sus firmas digitales.

Clases del namespace System.Security.Policy:

Evidencia	Descripción
Application directory	Directorio donde se encuentran los assemblies.
Hash	El hash criptográfico del assembly, identifica de forma exclusiva una versión específica de un ensamblado. Cualquier modificación al assembly, el hash no es válido.
Publisher	Firma digital del editor de assemblies, que identifica de forma única el desarrollador de software.
Site	El sitio del cual se baja el assembly
Strong Name	Nombre de cifrado fuerte del assembly, que identifica de forma exclusiva el espacio de nombres de este.
URL	URL del cual se baja el assembly
Zone	Zona donde se ejecuta el assembly, Internet o intranet Local.

¿Qué es un permiso?
Un permiso es una entrada de control de acceso del CAS. Por ejemplo, el permiso de diálogo de archivos que determina si un assembly puede interactuar con el usuario con un cuadro de diálogo Abrir, el cuadro de diálogo Guardar, ambas o ninguna.

De forma predeterminada, 19 permisos están disponibles para la configuración en el archivo.

Permisos	Descripcion
Directory Services	Otorga un acceso al Active Directory. se pueden especificar las rutas, o ver si el acceso de escritura está disponible.
DNS	Activa o restringe el acceso de un ensamblado a presentar peticiones DNS.
Environment Variables	Otorga a los assemblies acceso a las variables de entorno, Ruta de acceso, nombre de usuario, y número De Procesadores.
Event Log	Proporciona un acceso a los registros de sucesos. Puede permitir el acceso ilimitado o limitar el acceso a la navegación o auditoría.
File Dialog	Controla si un assembly puede pedir al usuario el cuadro de diálogo Abrir, el cuadro de diálogo Guardar, o ambos.
File IO	Restringe el acceso a los archivos y carpetas.
Isolated Storage	Permite el acceso al almacenamiento aislado. Se puede configurar el nivel de aislamiento y el tamaño de la cuota de disco.
Message Queue	Permite acceder a las colas de mensajes, que puede ser restringido por la ruta y el tipo de acceso.
Performance Counter	Controla si un assembly puede leer o escribir los contadores de rendimiento.
Printing	Limita la capacidad que tiene un ensamblado para imprimir

Conjuntos de permisos

Permisos	Descripción del conjunto
FullTrust	Exime a un assembly de las comprobaciones de permisos CAS.
SkipVerification	Permite a un assembly eludir las comprobaciones de permisos, que puede mejorar el rendimiento, pero sacrifica la seguridad.
Execution	Permite a un assembly ejecutarse y no le otorga ningún otro permiso.
Nothing	No otorga permisos. ni siquiera les permite ejecutarse.
LocalIntranet	Otorga un conjunto abundante de permisos, incluyendo imprimir y tener acceso al registro de eventos. no permite acceder al sistema de archivos, excepto a través de los cuadros de diálogo, Abrir y Guardar.
Internet	Conjunto restringido de permisos. se puede ejecutar un ensamblado con muy poco riesgo.
Everything	Otorga todos los permisos.

¿Qué son los grupos de código? Los grupos de código de autorización que son dispositivos ensamblados asociados con conjuntos de permisos. Si un administrador desea conceder un conjunto de usuarios acceso a una carpeta, el administrador crea un grupo de usuarios, añade a los usuarios del grupo, y después asigna los permisos de archivos para el grupo.
Por ejemplo, cualquier código que se ejecuta a través de Internet debe ser un miembro del grupo de código Internet_Zone.

La autorización de control de grupos de usuarios está basado en ACL (Access control list- lista de control de acceso) distribuidas y asociadas a cada recurso, los grupos de código establecen el uso centralizado de autorización. Sin embargo, no se puede especificar los permisos individuales de un grupo de código. Un grupo de código debe estar asociado a un conjunto de permisos.

La Internet_zone asigna un conjunto de permisos de internet.

Grupos de código por defecto

Code Group	Evidencia	Conjunto de Permisos
My_Computer_Zone	Zone: My Computer	FullTrust
LocalIntranet_Zone	Zone:Local Intranet	LocalIntranet
Internet_Zone	Zone:Internet	Internet
Restricted_Zone	Zone:Untrusted sites	Nothing
Trusted_Zone	Zone:Trusted sites	Internet

¿Qué es la Política de Seguridad?
Una política de seguridad es una agrupación lógica de grupos de código y conjuntos de permisos. Puede contener ensamblados personalizados que definen otros tipos de políticas.
Las políticas de seguridad proporcionan a los administradores la flexibilidad para configurar opciones del CAS en múltiples niveles. Hay cuatro niveles de políticas configurables: empresa (enterprise), equipo (machine), usuario y dominio de aplicación.
El nivel de empresa es la política de nivel de seguridad más alta, se puede configurar mediante el servicio de directorio Active Directory. En el nivel equipo, se aplica a todo el código se ejecutan en un equipo determinado. Directiva de usuario es el tercer nivel, y define los permisos por usuario. Dominios de aplicación las tratamos en el capítulo 8.

Cómo funciona CAS con el sistema operativo de Seguridad?
CAS es completamente independiente de la seguridad del sistema operativo. De hecho, debe utilizar las herramientas diferentes para administrar CAS.
Al determinar si un assembly puede tomar una acción concreta, tanto CAS como la seguridad del sistema operativo se evalúan. Por ejemplo, si CAS otorga un acceso conjunto para escribir en el directorio C: \ Windows, pero el usuario no tiene ese permiso, el assembly no puede escribir en la carpeta.

Cómo utilizar la Herramienta de configuración de .Net Framework para configurar CAS? La herramienta de configuración. NET Framework proporciona una interfaz gráfica para la gestión la política de seguridad y las aplicaciones que utilizan servicios remotos. Tareas que se pueden realizar: La evaluación de un assembly para determinar de qué grupos de código que es miembro.

· Determinar los permisos que se le asignará a un assembly.
· Agregar nuevos conjuntos de permisos.
· Agregar nuevos grupos de código.
· Aumentar la confianza de un ensamblado.
· Ajustar la zona de seguridad.
· Restaurar los niveles de política.

Para mayor información de cómo configurar directivas de seguridad con el CAS, selecciones aqui

Como usar la herramienta de política de seguridad de código de acceso?
Podemos utilizar la herramienta Caspol.exe, para examinar y modificar la configuración de la máquina, el usuario y el nivel de la Enterprise de las políticas de seguridad de código de acceso. Esta proporciona una funcionalidad similar a la línea de comandos.

Algunas opciones más utilizadas en caspol

Opcion	Descripcion
-addfulltrust assembly_file	Agrega un assembly que implementa un permiso personalizado o una condición de pertenencia personalizada. El argumento assembly_file específica el ensamblado que se va a añadir. Este archivo debe estar firmado con un nombre seguro.
-addgroup parent_name membership_condition permission_set_name [flags]	Agrega un nuevo grupo de código. El argumento parent_name específica el nombre del grupo de código padre. El argumento membership_condition especifica la condición de pertenencia para este. El argumento permission_set_name es el nombre del conjunto de permisos que se asociará con el nuevo grupo de código.
-all	Indica que todas las opciones siguientes éste se aplica a la empresa, equipo, y la directiva de usuario actual.
-chggroup name {membership_condition \| permission_set_name \| flags}	Para cambiar el estado de un grupo de código, el conjunto de permisos, el nivel Final, etc. name: específica el nombre del grupo de código para cambiar. permission_set_name: específica el nombre del conjunto de permisos a asociarse con el grupo de código. membership_condition: condiciones para el grupo.
-enterprise	Indica que todas las opciones de la política de nivel empresarial. Los usuarios que no son administradores no tienen derechos para modificar la política de empresa, aunque pueden verla.
-execution {on \| off}	Activa o desactiva el permiso para ejecutar código antes de que se ponga en marcha.
-help	Muestra la sintaxis de comandos y opciones para caspol.
-list	Listas los grupos de código y permisos.
-listdescription	Muestra todas las descripciones de grupos de código de un nivel específico.
-listfulltrust	Enumera el contenido de la lista de confianza del nivel especificado.
-listgroups	Muestra los grupos de código de nivel especifico.
-listpset	Muestra los conjuntos de permisos del nivel especificado o todos los niveles
-machine	Indica que todas las opciones que se aplican a la política machine.
-quiet	Deshabilita temporalmente el mensaje que se muestra con una opción de hacer cambios de política.
-recover	Recupera la política de seguridad desde una copia de seguridad.
-remgroup	Quita el nombre de grupo de código especificado. Contiene otros grupos también los elimina a todos.

Para saber más información sobre cómo realizar configuraciones con Caspol, aquí.

Lección 2 – usando declarativas de seguridad para proteger Assemblies.
En algunas situaciones, la seguridad del CAS es tan restrictiva que la aplicación no tiene los permisos necesarios para las funciones más básicas. En otras, la aplicación tendrá más .
Se puede utilizar declarativa de demanda CAS para asegurar que tiene todos los permisos necesarios, pero ninguno de más.

Razones para utilizar las declaraciones de CAS del assembly
Hay tres razones principales:

· Para asegurarse de que en tiempo de ejecución no se ejecute la aplicación, sin permitir el acceso a los recursos necesarios. Se usa SecurityAction.RequestMinimum para declarar todos los permisos CAS que requiere la aplicación. Si un usuario intenta ejecutar la aplicación y la política de seguridad del CAS no otorga el permiso requerido, se produce una excepción. Los usuarios no podrían identificar el problema de la excepción, pero un administrador sí.
· Para crear un pequeño cajón de arena y asegurarnos de que un atacante no maneje la aplicación para hacer tareas no deseadas: tomar información del contenido de los archivos privados, destruir datos, multiplicación virus y gusanos.
· Para comprobar que la aplicación se puede ejecutar con permisos limitados CAS y se ejecutan en zonas de confianza parcial. Utilizando las declaraciones SecurityAction.RequestOptional, el tiempo de ejecución se otorgan sólo los permisos especificados.

Clases para los permisos CAS
CAS puede restringir el acceso a muchos tipos de recursos- archivos y carpetas, impresoras, acceso a la red:

PerformanceCounterPermission	Para acceder a los contadores de rendimiento.
PrincipalPermission	Para controlar el acceso de usuarios y de grupos. Se explica en el capítulo 12.
PrintingPermission	Para el acceso a las impresoras.
ReflectionPermission	Descubre información, en tiempo de ejecución, sobre un tipo.
RegistryPermission	Para Leer, escribir, crear o eliminar claves del Registro y sus valores.
SecurityPermission	Para Ejecutar, afirmar los permisos, permite llamar a código no administrado y omitir la comprobación.
ServiceControllerPermission	Para acceder a servicios en marcha o parados.
SiteIdentityPermission	Define un permiso de identidad para el sitio Web desde el que se origina el código.
SocketPermission aceptar	Para realizar conexiones en una dirección de transporte.
SqlClientPermission	Permite el Acceso a base de datos SQL.
StorePermission	Contiene los certificados X.509.
StrongNameIdentityPermission	Define el permiso de identidad para los nombres fuertes.
UIPermission	Permite el acceso de los usuarios a la interfaz. Necesarios para depurar una asamblea.
UrlIdentityPermission	Define el permiso de identidad para la dirección URL de donde se origina el código.
WebPermission	Para Realizar o aceptar conexiones en una dirección Web.
ZoneIdentityPermission	Define el permiso de identidad para la zona de donde se origina el código.

Tipos de declaraciones de permisos de assemblies
Todas las clases de permiso atributos definen la propiedad Action, que se especificará en tiempo de ejecución cuando se interprete el permiso, para establecer la propiedad Acción se usa uno de los tres miembros de la enumeración SecurityAction:

· SecurityAction.RequestMinimum requiere permiso para que el ensamblado se ejecute.
· SecurityAction.RequestOptional niega todos los permisos que no figuran en un SecurityAction.RequestOptional o en la declaración SecurityAction.RequestMinimum.
· SecurityAction.RequestRefuse Reduce los permisos asignados a la aplicación Se de. e utilizar este tipo de declaración para asegurar que la aplicación no tiene acceso a los recursos críticos de los que se podría abusar.

Cómo crear declaraciones de assemblies
Ejemplo de código que requiere acceso de lectura al archivo C: \ boot.ini. Si la política de seguridad no concede ese permiso a la asamblea, el tiempo de ejecución produce una excepción antes de ejecutarlo.

Lección 3 – Usando la seguridad imperativa y declarativa para proteger métodos
CAS puede ser utilizado tanto de forma declarativa, done el compilador comprueba la seguridad antes de que se ejecute el código, o imperativamente, donde el propio código realiza controles de seguridad.

Los tipos de solicitudes de permiso de los Métodos
Existen seis opciones para los permisos de imperativo y declarativo dentro de un método:

· Assert: se encarga de que en tiempo de ejecución se ignore el hecho de que los llamadores que no tenga el permiso especificado.
· Demand: hace en tiempo de ejecución se lance una excepción si algún llamador falta algún permiso especificado.
· Deny: causa que en tiempo de ejecución se reduzca el acceso del método mediante la eliminación del permiso especificado.
· InheritanceDemand : se encarga a de producir una excepción si el assembly que hereda de la clase no tiene el permiso especificado.
· LinkDemand: Causa que en tiempo de ejecución se lance una excepción si el llamador inmediato, pero no llamadores en la pila, la falta a un permiso especificado.
· PermitOnly se encarga de que en tiempo de ejecución se reduzca el acceso del método mediante la eliminación de todos los permisos excepto un permiso especificado.

Recomendaciones para la utilización de la solicitud de permisos de métodos
Consejos para elegir los métodos CAS a utilizar:

· Se debe usar la declaración SecurityAction.PermitOnly para limitar los permisos disponibles para cada método. Hay que listar todos los permisos que el método requiere.
· Usar la declaración SecurityAction.Deny para refinar los permisos disponibles de cada método.
· Se debe utilizar CodeAccessPermission.PermitOnly para reducir permisos cuando una sección de un método requiere menos permisos que el resto del método.
· Usar CodeAccessPermission.RevertPermitOnly para restaurar el permiso.
· Se debe usar CodeAccessPermission.Assert cuando se desea permitir que el código de confianza parcial llame a un método que requiere permisos de la persona.
· Usar CodeAccessPermission.Demand sólo cuando el ensamblado implementa una funcionalidad ustomized, que no se basa en una funcionalidad incorporada en el framework de .NET, tales como las llamadas a código no administrado.

Técnicas para Exigir permisos
Mediante una enumeración que contiene las opciones Demand y LinkDemand. La diferencia entre las dos enumeraciones y métodos es que Demand hace que el permiso se verifique para cualquier caller (llamador), mientras que LinkDemand comprueba sólo el llamador inmediato.

Como realizar demanda declarativa permisos CAS?
Para crear una petición declarativa, se debe utilizar la clase SecurityAction.Demand o SecurityAction.LinkDemand:
Ejemplo de dos métodos que utilizan FileIOPermissionAttribute (en System.Security. licencias) y WebPermissionAttribute (en System.Net) para verificar la declaración que los llamadores de los métodos, para que tengan acceso a archivos específicos y al sitio Web www.microsoft.com.

Si hacemos clases que otros desarrolladores pueden obtener y no queremos que esto suceda, se puede restringir el assembly mediante la enumeración SecurityAction.InheritanceDemand. Por ejemplo, para assemblies que solo tengan la firma en el directorio C: \ Certificados \ MyCertificate.cer:

Como demandar imperativamente los permisos CAS?
En las declaraciones CAS, hay un método CodeAccessPermission con el mismo nombre y la función que se utiliza para los permisos de imperativo. Se utilizan las enumeraciones SecurityAction para la seguridad declarativa y los métodos CodeAccessPermission de seguridad imperativa.
El ejemplo de cómo realizar las mismas comprobaciones declarativas CAS, pero con la comprobación imperativa:

Cómo relajar permisos y mejorar el rendimiento?
Uso de las demandas CAS mejora la seguridad, pero disminuye el rendimiento.
Una llamada CAS obliga en tiempo de ejecución a comprobar sistemáticamente el permiso de cada persona que llama. LinkDemand, es una manera de mejorar el funcionamiento del método de la demanda, pero se sacrifica seguridad.

Otra técnica es el método Assert, que hace eludir los controles de seguridad en tiempo de ejecución.
Por ejemplo, si crea un objeto RegistryPermission y se llama al método Assert, se debe conceder RegistryPermission. Si se llama a otro método que utiliza Demand para exigir RegistryPermission, este tendrá éxito si a la persona que llama se le han concedido los permisos RegistryPermission. Para utilizar Assert (declarativa o imperativamente) la sintaxis es la misma a otros tipos de declaraciones de CAS:
Declarativa:

Imperativa:

Para ver otros ejemplos sobre el manejo de permisos haz clic aquí.

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capítulo 10 – Instrumentación–Parte 2

2010-11-28T12:11:00.005-03:00

Lección 3- Monitoreando de la Performance

No importa lo bien que una aplicación se ha diseñado, si no funciona bien, no será bien recibida por los usuarios. De hecho, los problemas de rendimiento a veces pueden ser notablemente más problemático que los errores tradicionales, ya que son muy difíciles de corregir:

Interfaz de usuario con pantallas congeladas o bloqueos de aplicaciones.
Acceso a la red, conectividad de base de datos, entrada y salida de archivos muy lentas.

La comprensión de cómo cada una de estas obras las áreas es fundamental para escribir las aplicaciones funcionan bien. Sin embargo, una vez que se implementa una aplicación, la vida puede llegar a ser muy complicado.
El espacio de nombres System.Diagnostics proporciona las herramientas necesarias para evitar un enfoque ineficaz para la solución de problemas.

Información general sobre procesos
Un proceso es un trozo de memoria que contiene recursos. Es una tarea aislada realizada por el sistema operativo. Por lo tanto, un proceso posee uno o más hilos del sistema operativo.

La clase process (en namespace System.Diagnostics)
Una instancia de un objeto process puede referenciar a cualquier proceso del sistema operativo, d una maquina local o remota.

Enumerando procesos
Hay cuatro métodos principales para determinar qué procesos se están ejecutando en un momento dado o para identificar procesos específicos: el método GetCurrentProcess, el GetProcessById, el GetProcessesByName, y el método GetProcesses.
El más simple es el método GetCurrentProcess que asocia un process con el proceso activo y lo devuelve:

GetProcessById
Este método toma un id y retorna la información si esta es encontrad. En otra sobrecarga, se le pasa el id y el nombre de la máquina:

GetProcessByName
Recibe como parámetros el nombre del proceso y de la maquina:

Usando contadores de Performance
Las consideraciones de rendimiento tienen gran impacto en la aceptación de a aplicación a un usuario. Para asegurarse de que este problema no ocurra, .Net framework provee la clase PerformanceCounter.

Los objetos PerformanceCounter permiten la recoger y recuperar datos de una manera limpia y orientada a objetos.Los valores de un objeto PerformanceCounter se almacenan en el Registro de Windows. Las propiedades que identifican un objeto PerformanceCounter son los siguientes:

· Nombre de equipo
· Nombre Categoría
· Categoría de la Instancia
· Nombre de contador

La clase CounterCreationData
Sirve como un objeto contenedor de todas las propiedades que serán necesarios para crear un objeto PerformanceCounter. La clase CounterCreationData tiene tres propiedades.

Nombre	Descripcion
*CounterHelp*	descripción amable de un contador
*CounterName*	Nombre del contador
*CounterType*	Devuelve el PerformanceCounterType del contador

Para crear una nueva instancia de la clase CounterCreationData se debe declarar una nueva instancia del objeto, y setear cada propiedad de forma manual.

O con otra sobrecarga del constructor:

La clase PerformanceCounterCategory
El objetivo principal de la clase PerformanceCounterCategory es administrar y manipular objetos PerformanceCounter y sus categorías. Tiene cinco métodos estáticos:

Create	Crea una clase PerfomanceCounterCategory
Delete	Elimina una clase PerformanceCounterCategory
Exist	Determina si una PerformanceCounterCategory ya existe
GetCategories	listas de cada uno de los PerformanceCounterCategories de una máquina dada
ReadCategory	Lee todos los datos del contador y el rendimiento asociados a un determinado PeformanceCategory

Iniciando procesos
Para que un proceso inicie se llama al método Start. El constructor de la clase Process tiene cinco sobrecargas, de las cuales tres son para los escenarios sin líneas de comando:

La clase ProcessStartInfo.
Este código crea una instancia de la clase ProcessStartInfo para iniciar un proceso específico.

La segunda sobrecarga toma un solo parámetro de cadena que se corresponde con el nombre de la aplicación. Si la aplicación se instala como un programa, usted puede usar el nombre de la aplicación. De lo contrario, es necesario especificar el nombre de archivo completo.

La tercera sobrecarga toma el nombre del archivo, un valor String que corresponde al nombre del usuario de inicio de sesión de usuario, la contraseña de inicio de sesión System.Security.SecureString del usuario y el nombre de dominio.

Las clases StackTrace y StackFrame
La clase StackTrace permite ver el estado de la llamada en tiempo de ejecución un cierto punto.
Cada vez que un método es llamado, un stackframe se agrega y se inserta en la pila. Cada método posterior se inserta en la pila que se ejecutará en orden último en entrar, primero en salir.

Así, examinando la StackTrace y su StackFrames se tiene gran cantidad de información sobre el estado de la aplicación. Para ver una breve descripción de la clase StackFrame haga clic aqui.

Lección 4 – Detectando Manejadores de eventos
System.Management es un namespace que provee un conjunto de herramientas para monitorear el manejo del sistema, dispositivos y aplicaciones (a través de las herramientas de instrumentación para el manejo de Windows WMI).

Enumerando objetos Managenent
El objeto DirectoryObjectSearcher es el central de esta namespace, mediante programación puede acceder a los recursos a través de WMI. Este mecanismo es fácil de usar porque la imita la sintaxis del Lenguaje de consulta estructurado (SQL), que la mayoría de los desarrolladores ya están familiarizados.
Ejemplo de cómo ejecutar una consulta mediante el DirectoryObjectSearcher:
1. declarar una instancia de la clase ConnectionOptions, y establecer el nombre de usuario y contraseña.
2. Declarar una instancia de la clase DirectoryObjectSearcher.
3. Declarar un objeto ManagementScope, y establecer la ruta de acceso y la propiedad ConnectionOptions.
4. Crear un objeto ObjectQuery, y especificar una consulta para ejecutar.
5. Crear un ManagementObjectCollection, y configurarlo para que el valor de retorno sea el de la DirectoryObjectSearcher.

Enumeración de unidades lógicas
Para enumerar las unidades lógicas utilizando objetos del System.Management, lo principal que hay que hacer es especificar un objetivo, ej : consultar Win32_LogicalDisk y sus atributos de tamaño y el nombre será devuelto a través de un ManagementObjectCollection.

Enumerar los adaptadores de red

Utilizando la misma metodología, se puede enumerar todos los adaptadores de red en una máquina determinada, solo cambiando la consulta. (Se debe usar Win32_NetworkConfiguration en vez de la Win32_LogicalDisk).

Recuperar información sobre qué servicios están detenidos
Recuperación de información sobre los servicios de Windows es igual de fácil que obtenerla de otros recursos, se debe:
1. Crear un nuevo objeto ManagementObjectSearcher. Escuchar
2. Especificar una consulta.
3. Llamar al método Get de la ManagementObjectSearcher

Suscribirse a un manejador de eventos usando la clase ManagementEventWatcher
La clase ManagementEventWatcher permite saber la información de suscripción sobre los eventos que ocurren en el contexto de WMI. Pasos a realizar:

Crear un nuevo objeto ManagementEventWatcher.
Asociar un EventQuery objeto de la misma.
Llame al método WaitForNextEvent.
Detener las notificaciones.

.

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capítulo 10 – Instrumentación–Parte 1

2010-11-21T20:30:00.004-03:00

Lección 1 – Logueando eventos
Es casi imposible saber de antemano todas las situaciones que pueden surgir después de que se implementa la aplicación, la forma de averiguarlo es usando un event log.
Usando Microsoft Windows Events y logueandolos
Es común tener informes de problemas de los usuarios utilizando la terminología que los desarrolladores no entendemos.
Ej: hice clic en esa ventanita de acá, se me puso blanca y me salto un cartel….
La falta de comunicación hace de la comprobación de errores un proceso difícil. Una forma de controlar esto, es el registro de sucesos, estos proporcionan un mecanismo para que las aplicaciones registren las cosas que les suceden.
Esta característica tiene muchos beneficios. Al utilizar el registro de sucesos, los desarrolladores pueden guardar determinados aspectos del estado de una solicitud, incluyendo errores graves. Se pueden grabar casi cualquier cosa.
Visor de eventos de Windows XP:

Creando y borrando un Event Log
Para crear un event log. Net Framework provee la clase EventLog. Para usarla se debe referenciar el namespace System.Diagnostics:

Después de crear un EventLog y especificar el source (de donde toma los datos, en este caso Cap10), se puede ver su información en el visor de eventos de Windows después de ejecutar el codigo.
Borrar un Eventlog es igual de simple:

Escribiendo un Event Log
El método WriteEntry parece bastante simple, pero existen 10 sobrecargas de este método:

Además de leer logs personalizados, el objeto EventLog permite leer y escribir en Evenlogs existentes como los de seguridad y logs de sistema.
Ejemplo de cómo escribir dentro de estos: (se deben tener permisos de escritura)
Aplication Log:

SecurityLog:

SystemLog:

Leyendo un Event Log
Los objetos event logs tienen una propiedad Entries, que es una instancia de EventLogEntryCollection, esta nos permite iterar a través de ella y ver los EventLogEntry que contiene:

La forma de limpiarlo es llamando al método clear del objeto Eventlog.

Lección 2 - Depurando y la trazando
Escribiendo Salidas (Output)
Una función importante de los desarrolladores es recorrer el código y buscar errores. Aprender a utilizar eficazmente las herramientas disponibles para esta tarea es fundamental por muchas razones:

· Para comprobar que el código hace lo que se espera.
· Si usamos las clases Debug y Debugger se puede obtener un feedback para confirmar si funciona como lo planeado.
· Usando herramientas para localizar los errores después de que han surgido

Las dos clases fundamentales utilizados para la depuración, Debug y Debugger, se encuentran en el namespace System.Diagnostics.

La clase Debugger
Permite la comunicación con una aplicación debugeadora. Tiene múltiples miembros:
Metodos:

Nombre	Descripción
Break	detiene la ejecución del depurador
IsAttached	indica cuando el depurador está asociado a un proceso.
isLogging	indica si el depurador se encuentra en el registro.
Launch	lanza el depurador y lo asocia a un proceso
Log	envía un mensaje al depurador actual

Ejemplo del uso del método break dentro de una sentencia condicional:

Otro método importante en la clase debugger es el método Log, que envía información a un depurador asociado, si no se encuentra asociado a ninguno, no realiza nada.
Cuando usamos el método log, este escribe en cualquier objeto que escuche y este asociado al debugger.para usar este método se debe llamarlo e indicar el nivel, categoría y mensaje (en listener simple es el DefaultTraceListener):

La clase Debug
Aunque la clase Debugger es muy útil, que, sólo ofrece dos métodos (break y log) y hay momentos en que necesita más granularidad. En esos casos, la clase de debug se ajusta mejor
Metodos:

Nombre	Descripción
Assert	Evalúa una condición y muestra un mensaje si la condición es falsa.
Close	Vacía el búfer de salida y luego llama al método Close en cada uno de los oyentes (listeners) conectados.
Fail	Muestra un mensaje de error. Vacía el búfer de salida, y escribe la información en la colección Listeners.
Indent	Incrementa el nivelde incidencia. Este método es especialmente útil para dar formato.
Imprimir	Escribe un mensaje seguido de un terminador de línea para rastrear a los oyentes de la colección Listeners.
Unindent	Opuesto del método Incident. Disminuye el nivel de incidencia en una unidad.
Write	Escribe la información adjunta sobre depuración u objetos de la clase Trace escucha de la colección Listeners.
WriteIf	Lleva a cabo la misma acción que el método Write, pero lo hace sólo si la condición especificada se cumple.
WriteLine	Escribe información adjunta de los debuggers o de seguimiento de los Listeners.
WriteLineIf	Realiza la misma acción que el método WriteLine, pero lo hace sólo si la condición especificada se cumple

El método Assert
Uno de los beneficios del uso de estas clases es que permite llevar a cabo su aplicación y examinar la salida sin tener que pasar manualmente a través del código. Una de las mejores herramientas para ayudar a depurar es el método Assert. Se debe colocar el código con los métodos Debug.Assert con una condición verdadera o falsa. si la condición no es cierta, se romperá en el depurador automáticamente. Cuando se utiliza correctamente el metodo Assert, simplemente ejecuta la aplicación y se produce una notificación inmediata frente a un problema.
Ejemplo estamos usando un objeto IConfigurationSectionHandler y alguien ha eliminado la entrada en el archivo de configuración. Sin una afirmación de depuración, puede pasar 20 minutos tratando de localizar el objeto antes de darse cuenta de que alguien lo elimino.
Suponga que tenemos un archivo de configuración, pero los ajustes fueron eliminado:

Referenciando al namespace System.Diagnostics se podrá saber inmediatamente:

Si no se encuentran los valores, se mostrara un mensaje de aviso.
El método fail, es un método que causa que la clase debugger haga un break y muestre un mensaje:

En cada uno de estos escenarios, el cuadro de diálogo presenta tres opciones :
■ Abort: Detiene la ejecución del programa completo.
■ Retry : reintenta ejecutar el bloque de código nuevo.
■ Ignore: Salta la falla, y trata de reanudar la ejecución.

El método Write
Se llama seguido del mensaje que se quiere mostrar:

El método Writeif
Trabaja de forma idéntica al write, salvo lo realiza solo si se cumple una condición:

Los métodos WriteLine y WriteLineIf funcionan de manera similar a estos anteriores, salvo que además contienen un terminador de línea al final del mensaje.

El método Print
Funciona de forma similar a los métodos writes, solo que escribe si se encuentra enlazado a un objeto listener.

Método flush
Es usado para introducir todos los datos en un objeto listener. No necesita parámetros, solo se llama:

Atributos de debug
Son atributos que permiten especificar la forma en que la aplicación se debe comportar.
Un atributo, describe el comportamiento de un objeto y llamadas de este de antemano para saber cómo manejar la situación. Debido a esta capacidad, los atributos están particularmente bien adaptados a escenarios de depuración.
Atributos:

DebuggerBrowsableAttribute
DebuggerDisplayAttribute
DebuggerHiddenAttribute
DebuggerNonUserCodeAttribute
DebuggerStepperBoundaryAttribute
DebuggerStepThroughAttribute
DebuggerTypeProxyAttribute
DebuggerVisualizerAttribute

Ejemplo: una clase simple a la que se puede hacer referencia antes y después de agregar los atributos que acabo de mencionar, SoftwareCompany: con 3 propiedades públicas (CompanyName, CompanyCity y CompanyState) , tres variables privadas (_companyName, _companyCity y _companyState) y un constructor sobrecargado que permite pasar en cada uno de estos valores:

Si le pasamos datos:

Y le hacemos un breakpoint, vamos a observar los miembros públicos y los privados.

DebuggerBrowsableAttribute

Si en los miembros privados agregamos el atributo DebuggerBrowsableAttribute, y establecemos la enumeración DebuggerBrowsableState en nunca ( siempre Usando el namespace Sytems.Diagnostics), y volvemos a poner un breakpoint, al ejecutar la aplicación, se ve el siguiente cuadro:

La enumeración DebuggerBrowsableState
Valores:

Never	El elemento nunca esta visible
Collapsed	Muestra el elemento colapsado.
RootHidden	No muestra el elemento principal pero si los elementos hijos.

DebuggerDisplayAttribute
Colocando sobre el nombre de la clase el atributo DebuggerDisplay podemos formatear como queremos que se muestre el elemento principal:

Se vería de esta forma:

DebuggerHiddenAttribute y DebuggerNonUserCodeAttribute El propósito de estas, es que si se tiene un punto de interrupción establecido, en el momento de ejecutarlo es simplemente ignorado.

DebuggerStepperBoundaryAttribute
Se utiliza este atributo cuando algo creado por el diseñador contiene una o más propiedades o métodos de interés. Le permite ver una parte del código sin tener que ver todo lo demás.

DebuggerTypeProxyAttribute
Permite cambiar cómo un tipo determinado se muestra. Este atributo se usa normalmente cuando se tiene un tipo interno y desea tener control sobre cómo aparecen:

DebuggerVisualizerAttribute
Este atributo le indica al depurador que tiene un visualizador asociado para la clase dada.
Creación de agentes listeners Siempre se habló de la salida del depurador pero, ninguno de estos métodos tiene ningún valor sin estar asociado a un listener. Las dos clases principales más usadas son Trace y Debug que se utilizan de forma idéntica, la diferencia está en que trace se realiza en la compilación tanto en Release como Debug, mientras que de debug es sólo en debug.
Los métodos más usados son:

Nombre	Descripcion
AutoFlush	Para obtener o establecer si el objeto se vacía después de cada escritura.
Close	Vacía el búfer de salida, y cierra todos los listeners asociados
Fail	emite un mensaje de error con la información sobre este
Flush	Vacía el búfer y escribe la salida a todos los objetos listeners
Listeners	obtiene la colección de listeners que monitorea
TraceInformation	muestra mensajes de información de todo lo que sucede

Para ver el resto de sus métodos aqui.

Objetos listeners (oyentes)
Las clases Debug y Trace dependen de los objetos listeners, ya que estos son los que toman sus datos y los dejan analizar. De forma predeterminada, Visual Studio asigna un listener que envía los datos a la ventana de salida.

La clase DefaultTraceListener
Los oyentes pueden añadir de forma manual o mediante el archivo de configuración. Ejemplo de cómo añadir una DefaultTraceListener:

O en el archivo de configuración:

Clase TextWriterTraceListener
Es uno de los listeners más simples de usar y sirve para escribir la salida a un archivo de texto o un stream:

O por el archivo de configuración:

Clase XmlWriterTraceListener
Envía la información recibida, a un objeto TextWriter o un objeto Stream. Para ver un poco de información sobre sus métodos aquí. Se crea de la siguiente manera:

O en el archivo de configuración:
.

....................................................................................................................................................
2da parte >>
.....................................................................................................................................................

Capítulo 9 – Instalando y configurando aplicaciones–Parte 3

2010-11-17T07:55:00.004-03:00

Lección 4 - Administración de Configuración
Permite especificar qué versión del motor de ejecución de la aplicación, la base de datos a la que debe conectarse.

Obteniendo y almacenando configuraciones
El principal instrumento a través del cual se recuperan los valores de configuración es el objeto ConfigurationManager.
Usando la propiedad appSettings del objeto ConfigurationManager, se puede acceder a cualquier sección del archivo de configuración.

La última forma de obtener una sección del archivo de configuración de la aplicación es a través del método GetSection del objeto ConfigurationManager:
Lo único necesario es que dentro del archivo de configuración se debe declarar la porción ConfigSettings, dentro de este último crear un sectionGroup con su propiedad name con el nombre que deseamos y su tipo, luego se define el contenido de la sección:

Para recuperarlo es realiza de esta forma:

Aclaración: ValuesHandler es una clase que creamos para manejar Hashtables y se explica un poco mas adelante.
Devuelve un object que se debe castear a otro específico.

Para grabar los cambios de settings, solo se debe llamar al método Save o SaveAs del objeto Configuration.
Si no especificamos la propiedad del objeto ConfigurationSection, ForceSave , del SectionInformation como true, cualquier cambio que se hizo, sera ignorado al hacer Save o SaveAs.

Implementando Interfaces de Configuración
La clase System.Configuration tiene múltiples interfaces para realizar funciones específicas:

IConfigurationSectionHandler es usada con propósitos de librería.
ISettingsProviderService , es usado exclusivamente para soportar el building e tiempo de diseño o para mejorar los debuggers.
IApplicationSettingsProvider provee un propósito funcional más general.

Cuando se necesita un mayor grado de granularidad con nuestras clases, se puede utilizar la interfaz System.Configuration.IConfigurationSectionHandler, esta es depreciada en el framework 2.0 , es mejor utilizar ConfigurationSection.
Para implementar la interfaz IConfigurationSectionHandler se debe de crear un SectionGroup con la seccion ConfigSection del archivo de configuracion. Los objetos ConfigurationSection son guardados en la propiedad ConfigurationSectionCollection del objeto Configuration:

Una forma de manejar esto es:

Después de haber creado la sección, se la debe definir:
Para usar este tipo de flexibilidad es necesario implementar la interfaz IConfigurationSectionHandler (su método Create):

Y aparte una clase que nos ayude, que almacene HashTables y brinde un mecanismo para recuperar valores de la tabla:

Hay dos métodos principales para leer valores. ConfigSettings.GetConfig (obsoleta) y ConfigurationManager.GetSection.
Ejemplo de uso de ConfigurationManager.GetSection:

Una forma simple de realizar un ConfigurationSection

Ejemplo para obtener valores con una clase de ejemplo denominada ConfigHandler que hereda de ConfigurationSection.:

Y usando esa clase:

Otra interfaz muy útil es IApplicationSettingsProvider.
métodos:

GetPreviousVersion	Devuelve el valor de la versión previa de la aplicación
Reset	Resetea los settings de la aplicación con sus valores por default
Upgrade	Indica al proveedor que la aplicación tuvo un upgrade.

Esta interfaz provee los beneficios siguientes beneficios:

Ejecución de diferentes versiones de una aplicación
Mantener los valores de configuración de una aplicación cuando esta tiene un upgrade.
Reseteo a sus valores por defecto.

Factores que la benefician a diferencia de una clase que implementa IConfigurationSectionHandler:

Cada propiedad puede ser alcanzada por nivel de aplicación o usuario.(nivel de granularidad)
Valores que son alcanzados a nivel de usuarios son guardados de forma diferente a los alcanzados a nivel de aplicación.
Si el atributo Application es usado, se crea un archivo de configuración adicional. Sigue el estándar de convención de nombre de configuración, solo que usa el nombre de usuario de la computadora y agrega “.config “al final. Ej mi maquina: Vicrodg , nombre del archivo de configuracion Vicrodg.config
Esto es guardado en Windows Special Folder y puede ser accedido por la clase Application con Application.LocalUserAppDataPath
Su acceso es facilitado a través de LocalFileSettingsProvider.

Aclaración: a pedido de algunos voy a colocar el código de cada unidad, junto con el Pdf del resumen de cada capitulo. El código no es obligatorio bajarlo, se encuentra en la Iso publicada al comienzo del blog, pero para facilitar las cosas un poco mas, lo voy a modificar en todas las publicaciones . Saludos!

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capítulo 9 – Instalando y configurando aplicaciones–Parte 2

2010-11-16T11:48:00.002-03:00

Lección 2 - Creando un instalador
Se puede configurar dominios de aplicación para crear ambientes personalizados para assemblies.
El uso más importante de la modificación de la configuración (settings) por defecto dominio de aplicación es restringir los permisos para reducir los riesgos asociados a las vulnerabilidades de la seguridad. Un dominio de aplicación no sólo proporciona una unidad de aislamiento, sino que limita el daño que los atacantes pueden hacer si ellos hacen un exploit al assembly

Usando el instalador base
La principal herramienta del framework .NET para instalar aplicaciones, es la clase Installer. Las principales razones para utilizar installers son:

Brindan una buena apariencia a la aplicación.
Simplifica lo que tiene que hacer el usuario para usar el producto.
Permiten especificar configuraciones que la aplicación necesita para ejecutarse, permiten generar llaves de registro, iconos en el escritorio, etc.
Permite remover la aplicación sin dejar rastros en la PC.

La clase Installer es la clase base para crear instaladores personalizados. Hay 2 instaladores pre-definidos en el framework, AssemblyInstaller y ComponentInstaller.
La clase Installer tiene una propiedad llamada Installers (que en realidad es una instancia de InstallerCollection). Esta propiedad es útil porque permite agregar varios instaladores
a un assembly para que diferentes tareas aisladas se puedan ejecutar.
Para utilizar una clase derivada de Installer, se debe:

Heredar de la clase Installer
Sobreescribir los métodos Install, Commit, Rollback y Uninstall
Añadir RunInstallerAttribute a la clase y setearlo a true.
Colocar la clase derivada en el assembly con la aplicación para instalar.
Invocar los instaladores. Por ejemplo InstallUtil.exe para invocar los instaladores.

Comiteando una instalación (Committing an Installation)
Cuando se invoca la clase Installer, cada elemento de la colección se itera y los correspondientes métodos son llamados:

Se llama al método Install.
Si la instalación es correcta, se llama al método Commit.
Si hubo errores, se llama al método Rollback.
Si se quiere quitar la aplicación, se llama al método Uninstall.

Para crear una intalacion mediante programación, con el AssemblyInstaller o ComponentInstaller, son necesarios dos pasos:
1. Crear una instancia de cualquiera de los objetos.
2. Llame al método o métodos que corresponden a las acciones que desea que el instalador realice:

Realizando rollingBack a una aplicación (desinstalando)
Se realiza de la misma forma que lo anterior, pero en lugar del método install, se usa uninstall.

Lección 3 – usando las herramientas de configuración de .Net Framework 2.0
Configuration Tool es una herramienta visual que permite administrar cualquier aspecto referente a la configuración de un assembly. Esencialmente ayuda a 3 tareas:

Configurar y administrar assemblies localizados en el GAC
Ajustar el código para acceder a políticas de seguridad
Ajustar servicios remotos

Configuraciones de navegación
Lo primero que se necesita para usar una herramienta es abrirla, ya sea mediante el administrador de herramientas o mediante líneas de comandos:
Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc
Tenemos las siguientes opciones:

Administrar el Cache del Assembly
Configurar el manejador de assemblies
Configurar la política de seguridad de acceso a código
Ajustar los servicios remotos
Manejar aplicaciones individuales

Vamos a ver cada una de estas opciones y discutir lo que hacen.

Administrar la Caché de Assemblies.
Las siguientes acciones pueden ser tomadas mediante el uso de esta opción:
· Ver la lista de assemblies configurados (seleccionando la vista de lista de ensamblados en la caché del assembly, y lo mostrara con todo lo disponible en la GAC)
· Agregar un assembly a la cache de assemblies (seleccionar agregar un
assembly a la cache de assemblies y navegar hacia el assembly dado).

Configurar el manejador de assemblies
Las siguientes acciones pueden ser adoptadas mediante el uso de esta opción:
■ Ver List de las Asambleas configurado
■ Configurar un ensamblado

Cambiar una configuración
El proceso para cambiar una configuración, se realiza con los siguientes pasos:
1. En la opción del árbol de configuración de assemblies, seleccionar Configurar un assembly.
2. Un asistente aparecerá pidiendo que seleccionemos la ubicación del assembly.
3. Seleccionar el assembly que deseamos configurar.
4. Un cuadro de diálogo permite especificar las propiedades del assembly.

Otra área necesaria es la de opciones de seguridad:
· Abrir .net 2.0 configuration tool, seleccionar mi computadora, y elegir el nodo de directiva de seguridad.
· Cada nodo tiene códigos de seguridad, permisos, secciones y políticas de seguridad de acceso al código.

Para cada zona, se pueden ver los conjuntos de permisos (default Level) y si se quiere cambiarlos.

Pasos para crear un conjunto de permisos:

Abrir la herramienta de configuración y ampliar el icono de Mi PC, Runtime Security
Policy, and Machine nodes.
En Machine nodes, hacer clic en Conjuntos de permisos (Permission Set) y seleccionar Nuevo
Seleccionar el registro de la lista de permisos disponibles.

Hacemos clic en add (y aparece la sig ventana)

se deben insertar datos en la sección Key, tildar los permisos Read, Write y Create.

Para la creación de nuevos Code Group, se debe de entrar al nodo Code Groups.

Reseteando una configuración
En tiempo de ejecución seleccionar el nodo de política de seguridad y seleccionar la opción Reiniciar todos los niveles de la política. Aparecerá un cuadro de confirmación que le preguntará si realmente se quiere hacer esto.

....................................................................................................................................................
3ra Parte
....................................................................................................................................................

Capítulo 9 – Instalando y configurando aplicaciones–Parte 1

2010-11-11T12:49:00.002-03:00

Lección 1 - Opciones de configuración
Con respecto al desarrollo de aplicaciones, siempre hay una mejor manera de hacer las cosas. Un área que se debe evitar es hard-coding (se incrustan datos directamente en el código fuente, en lugar de obtener esos datos de una fuente externa) de variables. El Framework de .Net brinda varias herramientas para evitar este problema.
Antes de .Net Framework, los desarrolladores tenían 2 formas de manejar la configuración.

Setear las propiedades del appSettings (forma muy rígida).
Definir una configuración personalizada y construir las clases correspondientes para administrarlo. Pero se debe de escribir gran cantidad de código para realizar esto.

.Net Framework brinda una herramienta para configurar una aplicación en pocos minutos sin necesidad de escribir mucho código.

Configuración en .Net Framework 2.0
El namespace System.Configuration es la librería que sirve como repositorio de todas las clases que se usan para administrar la configuración.
Este namespace contiene las clases Configuration y ConfigurationManager.
Métodos y propiedades más comunes de la clase ConfigurationManager:

Nombre	Descripción
AppSettings	Devuelve el AppSettingsSection que aplica al objeto Configuration.
ConnectionStrings	Devuelve el objeto ConnectionStrings que aplica al objeto Configuration.
FilePath	Devuelve el path físico del archivo de configuración.
GetSection	Devuelve el especificado ConfigurationSection.
GetSectionGroup	Devuelve el especificado ConfigurationSectionGroup.
HasFile	Indica si el archivo de configuración existe.
NamespaceDeclared	Obtiene o establece un valor que indica si el archivo de configuración tiene un espacio de nombres XML.
Save	Este método escribe los settings de configuración contenidos en el objeto Configuration al xml.
SaveAs	Lo mismo que en save, solo que se especifica a qué XML.

Pasos para recuperar los valores de configuración:

Crear un objeto configuration.
Usar los métodos del ConfigurationManager con el prefijo “Open”, para abrir el archivo de configuración de la aplicación a la máquina.

El enumerador ConfigurationUserLevel tiene los siguientes valores:

None	Obtiene el objeto System.Configuration.Configuration que aplica a todos los usuarios.
PerUserRoaming	devuelve el roaming System.Configuration.Configuration que aplica al usuario actual
PerUserRoamingAndLocal	Devuelve el local System.Configuration.Configuration que aplica al usuario actual.

Se puede usar un ExeConfigurationFileMap para especificarle al runtime lo que se quiere hacer y dónde encuentra cada archivo de configuración.

Cuando llamamos a OpenMappedExeConfiguration o OpenMappedMAchineConfiguration, estamos informando al runtime la intención de utilizar un mapped file. Debemos asegurarnos de que el archivo de configuración exista y de que se tengan los suficientes permisos para acceder a este.

Configuraciones comunes (Common Settings)
El termino Common hace referencia a algunas áreas que determinan cómo las aplicaciones se van a ejecutar.
Ejemplo para correr la aplicación en una versión del Framework especificada (lo podemos encontrar en el app.config o web.config dependiendo del tipo de aplicación):

Hay ciertas restricciones respecto a las versiones:

- Si la versión del Framework en que fue construida la aplicación, se encuentra en la máquina, se utiliza esta versión.
- Si la versión del Framework no se encuentra en la máquina y nada fue especificado en el supportedRuntime. La aplicación va a correr en la última versión disponible en la máquina. Debería utilizar el Framework 2.0 incluso si la aplicación fue hecha en versiones inferiores.
- Si no se encuentra la versión del Framework, se usa lo que se indica en el supportedRuntime

Otro escenario común es el de usar un assembly compartido y verificar que este funciona con múltiples aplicaciones. Para acomodar esto se debe:

- Añadir una variable de entorno DEVPATH que apunte a donde se encuentra el assembly
- Setear el developmentMode en true de esta forma:

Una tarea común es especificar donde se encuentra una versión de un assembly. Para esto podemos usar el .Net Framework 2.0 Configuration Tool (lo vemos en la lección 3). O configurarlo manualmente de esta forma:

Otros valores comunes de configurar son las secciones de AppSettings y ConnectionStrings.

Para poder utilizar la variable de AppSettings se puede realizar de la siguiente manera:

Pero la manera correcta de acceder (sin producir warnings en el compilador) es a través del ConfigurationManager:

La clase AppSettings se puede enumerar (implementando la interface IEnumerable) para iterar sobre esta:

Usando el componente ConnectionStrings se puede realizar de la siguiente forma:

Se puede colocar clear al comienzo de la sección ConnectionStrings para eliminar cualquier otra conexión existente y luego especificar para cada ConnectionString:

- El nombre descriptivo de la coneccion.
- El providerName (el proveedor de datos que vamos a usar), por ej.: System.Data.OracleClient .
- El atributo ConnectionString con la cadena de conexión para conectarse a la base de datos deseada.

Para poder utilizarlo en el código de nuestra aplicación:

El ejemplo anterior usa la clase ConfigurationManager, que es utilizada en winforms o aplicaciones de consola. Para aplicaciones web (asp.net) se emplea la clase WebConfigurationManager (del namespace System.Web.Configuration) que es muy parecida a ConfigurationManager, salvo por 3 diferencias:

- El WebConfigurationManager tiene un método llamado GetWebApplicationSection que la otra clase no tiene, este método devuelve una sección del web.config (equivalente a GetSection).
- El método OpenMappedExeConfiguration del ConfigurationManager es reemplazado por OpenMappedWebConfiguration de la otra clase.
- El método OpenExeConfiguration del ConfigurationManager es reemplazado por OpenWebconfiguration de la otra clase.

Ejemplo de cómo utilizar el WebConfigurationManager:

Application settings(configuración de la aplicación)
Son los valores de configuración que se aplican a la aplicación: incluyen cadenas de conexión de base de datos, las direcciones URL de servicios Web, configuración remota, y otros. La forma de utilizar los ApplicationSettings, es la siguiente:

Y se utiliza de esta forma:
Ejemplo de una configuración de la aplicación llamada WebServiceURL, con una clase llamada SampleSettings.

Aclaración: nuevamente estos pasos solo son usados en VS2005, pero como nuestro fin es el de seguir con el contenido del libro… lo muestro igual. Más tarde voy a comentar como se realiza esto en VS 2008 o 2010 (mucho más fácil y corto, por supuesto )

Hay dos maneras de hacerlo, aunque una es mucho más sencilla que el otro. La primera es escribir esto a mano. Pero un espacio de más o algún error ortográfico puede causar que la aplicación funcione mal. El otro método es utilizar la clase Settings y aprovechar el diseñador. Se debe agregar un nuevo proyecto, y crear elemento del tipo de archivo de configuración (SettingsFile).
En vs2005:

Después de crearlo, aparece un cuadro de diálogo Configuración para crear y cambiar el nombre de las configuraciones, fijar su alcance, el valor por defecto:

Otra forma de almacenar y devolver valores es ApplicationSettingsBase que posee una colección de Key/Value. Lo único que se necesita para usar esta clase es heredar de ApplicationSettingsBase y decorar cada propiedad que mapee a los valores de configuración con su UserScopedSettings o ApplicationScopedSettings.

Uno de los mayores beneficios es la de configuración de componentes remotos (permite indicar dónde se encuentran ubicados los assemblies sin necesidad de recompilar o implementar nuevamente.
Ejemplo de la forma de registrar un componente:

Para los casos de un IIS, se debe de tener cuidado a la hora de la configuración, porque se tiene que señalar la máquina donde se encuentra y el puerto.

Acá les dejo un video que encontré, es bastante completo, está en inglés, pero muestra todos los pasos para crear Application settings en Vs 2008 / 2010

.

....................................................................................................................................................
2da parte >>
.....................................................................................................................................................

Capítulo 8- Dominios de aplicación y servicios–Parte 2

2010-11-10T10:44:00.005-03:00

Lección 3 – Creando servicios de Windows
La creación de servicios, permite correr un assembly en background (por detrás). Los servicios son ideales cuando se necesita monitorear algo, cuando el assembly necesita escuchar por conexiones de red que ingresan, o cuando se necesita ejecutar un assembly antes que el usuario se loguee.
Debido a su naturaleza, los servicios requieren seguridad especial y consideraciones de instalación.

Que es un servicio Windows?
Los servicios de windows son procesos que corren en el background, sin interfaz de usuario, y en su propia sesión de usuario. Es ideal para una aplicación que deba estar corriendo constantemente y no interactuar con el usuario.
La única forma de debuggear un servicio es instalarlo, iniciarlo y atachear un debugger.
Se debe crear el instalador de componentes para el servicio de aplicaciones. La instalación de componentes, instala y registra el servicio en el servidor y crea una entrada para este, con el Windows Services Control Manager.
Las aplicaciones de Windows Service corren en una situación diferente de la ventana interactiva del usuario no logueado. Una window station es un objeto seguro que contiene un Clipboard, un grupo de objetos de escritorio. Los mensajes de error deben ser logueados en el log de eventos de Windows en lugar de mostrarlos en la interfaz del usuario.
Los Windows Service application corren en su propio contexto de seguridad y son iniciados antes que el usuario se loguee a Windows. Se debe planear con cuidado qué cuentas de usuario debe correr con el servicio. Los servicios con mayores privilegios son los que tienen más ataques.

Como crear proyecto de Servicio?
Aclaración: visual studio 2010 ya no cuenta con las mismas plantillas que se explican en el libro, para saber cómo se realizan en la actualidad hagan clic aqui o en un post muy útil que encontré aca , pero con el fin de ver todo el contenido de la certificación, lo sigo explicando de esta manera.

1. Crear un proyecto usando el template de las aplicaciones de Windows services.

2. Escribir el código para los procedimientos OnStart, OnStop y otros que quieran redefinir.
3. Agregar los instaladores necesarios, por default, un service application contiene 2 links de instaladores, uno para el proceso y otro para el servicio asociado.
4. Crear el proyecto para instalar los servicios e instalarlo
5. Usar los servicios snap-in para iniciar nuestro servicio

Como implementar un servicio?
Después de crear el proyecto de servicio, se deben seguir los siguientes pasos para implementarlo:
1. Modificar la propiedad ServiceBase.Servicename (es usada para identificar el servicio).
2. agregar código en el metodo OnStart (este se llama cuando se inicializa el servicio). Si se desea ejecutar algo de forma mecánica, se puede usar el componente SystemTimers.Timer y este lanzara eventos periódicamente.
3. Adherir codigo al metodo OnStop para realizar acciones al momento de parar el servicio.
4. Opcionalmente se pueden sobreescribir OnPause, OnContinue y Onshutdown.

Como crear un instalados de proyectos para un servicio?
Para la instalación de un proyecto para un servicio se utilizan las clases ServiceInstaller y ServiceProcessInstaller.

· ServiceInstaller: define la descripción del servicio, su nombre, el nombre del servicio y tipo de inicio.
· ServiceProcessInstaller: define los settings del servicio.

Pasos para crear un instalador de servicios usando visual studio (2008, 2005):
1. Abrir la vista diseño del servicio, hacemos clic derecho en el diseño y elegimos Add instaler (agregar instalador) y se crea un ProjectInstaller.
2. Estableces la propiedad startype (del ProjectInstaller) como:

· Automatic: el servicio inicia automáticamente cuando la computadora comienza.
· Manual: el usuario debe iniciarlo manualmente.
· Disabled: el servicio no inicia, ni el usuario puede empezarlo

3. Agrega una descripcion y un displayName para el ServiceInstaller.
4. Specifica el contexto de seguridad, seteando las propiedades de la cuenta (Account property) del ProjectInstaller.

Los contextos de seguridad pueden ser:

· LocalService, corre en el contexto de una cuenta que actúa sin privilegios de usuario y tiene credenciales de anónimo.

· NetworkService, permite autenticar a otra computadora en la red.

· LocalSystem, el servicio corre con ilimitados privilegios y presenta credenciales a cualquier usuario remoto. Es de mucho riesgo.

· User(the default), causa que el sistema pida user name y password cuando el servicio es instalado

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capítulo 8- Dominios de aplicación y servicios–Parte 1

2010-11-09T14:58:00.005-03:00

Los dominios de aplicación permiten llamar a assemblies externos con la óptima eficiencia y seguridad.
Servicios son tipos especiales de assemblies que corren en el background (por detrás), no tienen interfaz de usuario y son controlados por herramientas especiales.

Lección 1 – Creando aplicaciones de dominio

A veces es necesario correr un assembly externo, pero cuando esto se realiza se puede caer un manejo ineficiente de recursos y en problemas de vulnerabilidad. Para evitar esto se crean dominios de aplicación.

Que es un dominio de aplicación?
Application Domain (dominio de aplicación) es un contenedor lógico que permite correr múltiples assemblies como un solo proceso, previniendo acceder directamente a la memoria de otros assemblies. Ofrece varias de las características de un proceso como: espacios separados de memoria y acceso a recursos, pero son más eficientes que estos, porque permiten a multiples assemblies correr en dominios de aplicación separados sin la necesidad de correr multiples procesos separados.

Un ejemplo de Application Domain es el IIS: si un sitio web es visitado por 10 personas, IIS va crear un dominio de aplicación para cada uno (ASP.NET corre 10 instancias separadas del assembly).
La mayoría del tiempo, en tiempo de ejecución dependemos del host para crear dominios de aplicación automáticamente para nuestros assemblies.

Se pueden configurar el comportamiento de los application domain usando herramientas como Internet Information Services Manager y el .NET Framework Configuration Tool.
Aspnet_wp.exe crea dominios de aplicación para aislar múltiples instancias de un assembly. Podemos crear nuestro propio application domain para llamar assemblies con riesgo de que el assembly pueda realizar una accion o acceder a cualquier recurso que no se ha especificado como permitido. Incluso, un Assembly puede almacenar varios Application Domain que almacenen assemblies.
Además de aislar un assembly ,los dominios de aplicación brindan confiabilidad y eficiencia:

Confiabilidad: para aislar tareas que pueden causar que un proceso termine. Si un appDomain se vuelve inestable, se descarga (unloaded) sin afectar el proceso. Esta técnica es útil cuando el proceso se debe correr por un largo periodo de tiempo sin volver a empezar, o cuando no comparte información.
Eficiencia: Si un assembly es cargado en el application domain por default, el assembly no puede ser descargado de memoria mientras el proceso esté corriendo. Esta técnica se usa para minimizar el trabajo de setear procesos de larga duración que ocasionalmente usan varios DLLs.

La clase AppDomain
En .Net , se usa el namespace System.AppDomain para manejar los dominios de aplicación, este contiene las siguientes propiedades y métodos:
Aclaración: coloco los que más se usan, pero es recomendable ver el link para conocer un poco más a esta clase.

ActivationContext	obtiene el activation context del actual application domain
ApplicationIdentity	Obtiene el identity de la aplicación en el appDomain.
ApplicationTrust	describe permisos y si una aplicación es confiable o no.
BaseDirectory	Obtiene el directorio base que el resolvedor de assemblies utiliza.
CurrentDomain	obtiene el actual ApplicationDomain del Thread.
DomainManager	Obtiene el administrador de dominios que fue provisto por el host cuando el appDomain fue inicializado.
Evidence	Obtiene el Evidence asociado al appdomain que es usado para políticas de seguridad.
ApplyPolicy	Devuelve el nombre del assembly después de que una política es aplicada.
CreateComInstanceFrom	Crea una instancia de un tipo de COM.
CreateDomain	Crea un nuevo appdomain.

Como crear un dominio de aplicación?
Para crear una appdomain, se debe llamar a una de las sobrecargas del método appDomain.CreateDomain

Como crear asemblies en un dominio de aplicación?
Crear un appdomain y cargar un assembly dentro de éste es igual de simple que lo anterior, se debe llamar al método ExecuteAssembly:

Como descargar un dominio de aplicación
Una de las ventajas de cargar assemblies en un dominio de aplicación es que se pueden descargar en cualquier momento para liberar recursos. Se realiza llamando al método AppDomain.Unload:

Lección 2 – Configurando dominios de aplicación
Se puede configurar dominios para crear entornos personalizados para assemblies. Lo más importante de modificar configuración por defecto es restringir permisos para reducir riesgos asociados con la seguridad.

Como usar un Applicaction Domain para lanzar assemblies con privilegios limitados?
Restringiendo los permisos de un dominio de aplicación se puede reducir el riesgo de que un assembly que llamemos realice alguna acción maliciosa.
Ejemplos de assemblies con privilegios limitados:
Defense-in-depth: es la seguridad principal para proveer múltiples niveles de protección, de esta forma se está protegido de una vulnerabilidad. Es muy importante cuando se ejecuta código externo.

Como proveer evidencias de hosteo para un assembly?
Cuando creamos un dominio de aplicación y lanzamos assemblies, tenemos completo control sobre la host evidence.
Evidence: es la información que se reúne en tiempo de ejecución sobre un assembly, para determinar que código agrupa. Su grupo de código, determina sus privilegios. Las evidencias más comunes incluyen carpetas o sitios web que el assembly corre e incluso firmas digitales.
Para proveer evidencia para un assembly, debemos crear un objeto system.Security.Policy.Evidence y después pasarlo como parámetro a una sobrecarga que tiene el application domain del metodo ExecuteAssembly.

Cuando se crea un objeto evidencia con el constructor que requiere 2 arreglos de objetos, uno representa los Evidence del host y el segundo, los del assembly. Un Evidence puede ser cualquier cosa, un string, un integer, una clase personalizada, etc.
La forma más simple de controlar permisos asignados a un assembly de un appdomain es pasarle la Zone evidence, de tipo System.Security.Policy.Zone y el enumerador System.Security.SecurityZone:

Como proveer evidencias de hosteo para un dominio de aplicación?
La técnica es similar a la de la evidencia para un assembly , usa una sobrecarga de AppDomain.CreateDomain que acepta un objeto Evidence (se debe referenciar a los namespaces System.Security y System.Security.Policy):

Como configurar las propiedades de un dominio de aplicación?
Se puede suministrar el common language runtime con información de configuración para un nuevo dominio de aplicación usando la clase AppDomainSetup.
Cuando uno crea su dominio de aplicación, la propiedad más importante es ApplicationBase.
Las otras propiedades del AppDomainSetup son usados por el host para configurar un particular appDomain. Cambiar las propiedades del AppDomainSetup no afecta a ningun AppDomain existente, solo a los que se crean después.

Acá les dejo el link para ver las propiedades y métodos de AppDomainSetup.

Para aplicar las diferentes propiedades a un dominio se debe crear un objeto AppDomainSetup y pasarla junto con el objeto evidence, al método AppDomain.CreateDomain.

Para examinar las propiedades del appdomain actual, se usa un objeto AppDomain.CurrentDomain.SetupInformation
.

....................................................................................................................................................
2da parte >>
.....................................................................................................................................................

Capítulo 7 – Threading (Manejo de Hilos)–Parte 2

2010-11-08T15:24:00.006-03:00

Lección 3 – Modelo de programación asíncrono.

Entendiendo la programación asíncrona
Permite que distintas partes de código sean ejecutadas en hilos separados.
En .Net Framework existen muchos métodos de la forma BeginXXX y EndXXX que trabajan de forma asíncrona para poder crear otro hilo que trabaje, mientras nosotros realizamos otras cosas en el programa.

Modelo Rendezvous

Hay 3 estilos de programación asíncrona

· Wait-Until-Done: este modelo permite empezar una llamada asíncrona y realizar otro trabajo. una vez que se realizó lo que se deseaba, se debe colocar una llamada para bloquearse mientras se espera que la llamada asíncrona esté completa.
Ejemplo:

Es del estilo de BeginRead y EndRead.

· Polling: muy parecido al anterior, solo que la forma de revisar si se ha completado la llamada asíncrona, es mediante el objeto IAsyncResult, se debe consultar a su propiedad IsCompleted, para ver si se terminó o no.

· Callback : El modelo callback necesita que especifiquemos un método a llamar e incluir cualquier estado que nosotros necesitemos en el metodo callback para completar la llamada

El parámetro stream, cuando se realiza la llamada asíncrona, es porque puede ser necesario pasar el filestream como estado.

Excepciones y APM (modelo de programación asíncrona)
Cuando se usa APM, pueden surgir muchas excepciones. Si ocurre una excepción dentro de la llamada asíncrona, ésta es mostrada cuando se llama a EndXXX (se debe realizar try/catch)

Usando ThreadPool
En muchos casos, crear threads propios no es necesario o sugerido, .Net te soporta un pool de hilos que pueden ser usados en muchas situaciones donde se necesitan crear hilos propios:

.Net mantiene un conjunto de threads que pueden ser reusados para la aplicación.es más rápido porque se reúsa solo lo necesario.

La clase ThreadPool soporta métodos no solo para encolar trabajos (queuing up work items), sino además para administrar el ThreadPool.
Métodos más importantes y usados son:

GetAvailableThreads	número de hilos disponibles para uso en el pool
GetMaxThreads	Número máximo de hilos que puede soportar este ThreadPool.
GetMinThreads	Mínimo de hilos que son creados en cualquier momento.
QueueUserWorkItem	Agrega un trabajo al thread pool para ser ejecutado en un hilo disponible.

Si quieren consultar un poco más sobre esta clase y ver otros métodos usados, se puede hacer clic aquí.

Limitando el número de threads en un ThreadPool
La clase ThreadPool soporta algunos métodos estáticos para limitar el mínimo y máximo de threads que se pueden usar.
Existen 2 situaciones donde se debe de cambiar el límite de hilos del ThreadPool: thread starvation,(supongo que la traducción seria, Inanición de hilos o falta de hilos) y aumentar velocidad de hilos.

Thread-starvation: cuando la aplicación necesita muchos hilos y sobrepasa la cantidad de threads que la ThreadPool contiene. Se usa ThreadPool.SetMaxThreads

Un completion port (puerto de finalización), es un hilo de nivel de kernel que es utilizado para hacer operaciones I/O a archivos. Normalmente hay más puerto de finalización que números de hilos administrados.

Elevar el número mínimo de hilos, puede incrementar la performance y permite que la aplicación cree threads mas rápido.
Se realiza de la misma forma que la anterior:

ThreadPool y WaitHandle (manejador de espera)
El threadPool también provee mecanismos para que los threads esperen manejadores (handles) y llamen métodos cuando reciban una señal:

Método llamado:

La clase SynchronizationContext

Existen diferentes modelos de hilos en Windows Forms que en ASP .NET.
Para tratar con estos modelos diferentes se debe trabajar con la clase SynchronizationContext, esta permite escribir código sin importar el modelo de hilos de la aplicación.
Para usar la clase SynchronizationContext, se debe crear una instancia, llamando a SynchronizationContext.Current
Después de esto se pueden realizar varias cosas:

1. Llamar al método Send, que ejecute un código y este se va a bloquear hasta que el código ejecutado retorne.

2. Ejecutar el método Post, llama a un código, encola el pedido y retorna inmediatamente si es posible.

Usando objetos Timer

Un timer es un objeto básico que se dispara una llamada asincrónica a un método basado en el tiempo.
Cuando se crea el Timer, se especifica un delegado TimerCallback que apunta a un método que se desea ejecutar cuando el Timer lo levante. Se debe especificar cuándo se quiere empezar, así como el tiempo entre firings (disparos). Por ejemplo:

Eso va a crear un timer que se ejecute al momento (o) y llame al Callback (con el método TimerTick que imprime Tick) cada segundo.

La clase timer también soporta el método Change que permite volver a especificar cuándo comienza y los intervalos de tiempo.

Infinite, significa que a partir de ahora, se detiene el timer cada un segundo

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capítulo 7 – Threading (Manejo de Hilos)–Parte 1

2010-11-04T18:15:00.001-03:00

El concepto básico de threading es el realizar múltiples operaciones de forma concurrente. Cada una de estas operaciones puede ser realizada en un hilo separado. Es muy útil cuando se tiene computadoras con múltiples procesadores. Cuando uno no utiliza threading en una aplicación, se está desaprovechando el procesador.
Lección 1 – Creando hilos
Se encuentra en el namespace System.Threading de .Net framework y tiene los tipos necesarios para crear y administrar hilos.
Hilos simples
Métodos y propiedades más importantes de la clase Thread:

IsAlive.	Indica si es hilo está ejecutándose actualmente
IsBackground.	Indica si el hilo está ejecutándose como background
IsThreadPoolThread.	Indica si el hilo se encuentra en el pool de hilos.
ManageThreadId.	Obtiene un identificador del hilo actual.
Name.	nombre asociado al hilo
Priority.	Prioridad del hilo
ThreadState.	Obtiene el estado del hilo
Abort.	Levanta un ThreadAbortException para indicar que el hilo debe de ser abortado
Interrupt.	Levanta un ThreadInterruptedException cuando un hilo está en estado bloqueado.
Join.	Bloquea el actual hilo, hasta que el hilo termine.
Start.	Setea el momento de ejecución.

Entre sus propiedades estáticas de Thread, estan:

CurrentContext.	Obtiene el actual ThreadContext relacionado al hilo actual.
CurrentPrincipal.	Obtiene el usuario asociado al hilo actual
CurrentThread	Obtiene el hilo que se ejecuta actualmente.
Abort	puede dejar un AppDomain con un estado no estable.
GetDomain	Obtiene el AppDomain asociado con el hilo.
GetDomainId.	Obtiene un identificador para el AppDomain asociado con el hilo.
ResetAbort	Cancela un pedido de Abort.
Sleep	Bloquea un hilo por cierto tiempo (en milisegundos)
BeginCriticalRegion	Indica el inicio de una región crítica.
EndCriticalRegion	Indica el fin una región crítica, donde si ocurre un Abort, puede dejar un AppDomain con un estado no estable.
ResetAbort	Cancela un pedido de Abort.

Creando un hilo
1. Crear un método que no devuelva valor (void)
2. crear un delegado ThreadStart y especificar el método creado en el paso 1.
3. Crear un objeto Thread y especificar el objeto ThreadStart creado en el paso 2
4. Llamar a Thread.Start para empezar la ejecución del nuevo hilo
Método

Al llamar al método start , se ejecuta el método trabajo simple , que imprime por pantalla la propiedad ManagedThreadId (prop numérica a cada hilo).

Usando hilos multiples (Multiple Threads)
Ejemplo de creación de múltiples hilos y empezarlos a todos en un mismo trabajo.

Por pantalla se ven hilos consecutivos, porque el método “trabajoSimple” es muy rapido:

Usando Thread.Join
El método Join de Thread nos permite esperar por un hilo. Es decir, hay que llamar al Join del hilo que se está ejecutando, para esperarlo.

Thread Priority
El enumerador ThreadPriority , indica la prioridad de cada thread, tiene los siguientes valores:
Highes, AboveNormal, Normal, BelowNormal, Lowest
Normalmente, cada hilo tiene su información asociada y ésta es usualmente propagada a nuevos hilos. Esta data incluye seguridad de información, settings de localización (como el Culture del thread) e información de transacción de SystemTransactions.

Pasando datos a un hilo
En la realidad cuando usamos los hilos, se necesita pasar información y eso se realiza mediante el uso de un delegado llamado ParameterizedStartThread, este delegado especifica un método que recibe un parámetro object y retorna void.

Para utilízalo como punto de partida de una llamada a un thread se debe crear un delegado ParameterizedThreadStart que apunte al método y usar la sobrecarga del método Thread.Start que un objeto como parámetro:

Se debe tener cuidado de que el objeto que se le pase sea un string como se espera. Sino levantar una excepción, ejemplo:

Parando hilos
El mecanismo primario para parar threads es usando el método Thread.Abort.
Cuando se llama a este evento, el sistema se prepara para lanzar la excepción ThreadAbortException (se produzca o no).

Se debe colocar Thread.BeginCriticalRegion y Thread.EndCriticalRegion esto le indica al sistema de hilos que se puede abortar el hilo, pero NO en esa zona. El código dentro de esta región, será ejecutado como si fuese un solo hilo.

Ejecución de contexto
Cada hilo tiene su informacion asociada y ésta es usualmente propagada a nuevos hilos (información de seguridad, localización, de transacción (SystemTransactions).
La clase ExecutionContext brinda métodos estáticos para controlar el flujo del contexto de la información.
Se puede suprimir el contexto con ExecutionContext.SuppressFlow, esto incrementa la performance, pero se pierde seguridad, cultura e información del contexto de transacciones.

Para restaurar el contexto, se puede llamar ExecutionContext.RestoreFlow o flujo.Undo():

Se puede llamar el método Run del ExecutionContext, que permite especificar código en ese thread e información de uso. Para usar el método Run, se debe tener una copia del ExecutionContext (se realiza con ExecutionContext.Capture ).

Lección 2- Compartiendo Datos
Uno de los mayores problemas al trabajar con threads es el compartir información entre múltiples hilos.

Evitando Colisiones

El problema clásico del contador, es que varios hilos pueden tener un mismo valor desde memoria y luego de eso, incrementarlo y registrarlo con el mismo valor.
Al compartir información, esto se puede resolver utilizando la clase Interlocked:
Métodos:

Add.	Suma 2 enteros en una operación atómica.
Decrement	Resta 2 valores en una operación atómica
Exchange	Intercambia 2 valores, de forma atómica.
Increment	Adhiere uno a un valor de forma atómica
Read.	Lee un número de forma atómica (64 bits).

Synchronization Locks

Permite sincronizar el acceso a los objetos en .Net. Para usarlo, se debe de colocar lock(this) en el método.
Clase:

Código para manejar la clase Contador2:

Se muestra por pantalla:

Para tener mucho mayor control sobre la sincronización, se puede utilizar la clase Monitor. Métodos:

Enter.	Crea un lock exclusivo para un objeto especificado.
Exit.	Libera el lock exclusivo para un objeto especificado.
TryEnter.	Crea un lock exclusivo para un objeto especificado, y soporta timeout
Wait.	Libera un exclusivo lock y bloquea el hilo actual hasta que este pueda re-adquirir el lock

Cuando se requiere una zona sincronizada, se puede modificar el código:

Aunque se resuelvan la mayoría de los problemas, se debe tener cuidado con los Deadlock (cuando dos piezas de código tratan de acceder al mismo objeto pero se bloquean entre ellos para obtener los recursos).

Otros métodos de sincronización
Además de la clase monitor, se poseen otros mecanismos de sincronización de objetos:
Clase ReadWriterLock: permite diferenciar entre las dos clases de código que usan los recursos. Bloquea el acceso a lectores y escritores por separado. Permite múltiples lectores para acceder a la información al mismo tiempo, pero solo un escritor puede obtener un lock en la info. Todos los lectores deben liberar su bloqueo antes de que un escritor pueda obtener un el suyo.
Ejemplo de cómo adquirir un reader lock:

Ejemplo de cómo adquirir un writer lock:

El ReaderWriterLock está diseñado para trabajar con las dos clases anteriores de bloqueo. También soportan pasar de un bloqueo de lectura a uno de escritura (UpgradeToWriterLock) y de este último volver al de lectura (DowngradeFromWriterLock).
El método UpgradeToWriterLock devuelve un LockCookie, es una estructura que el ReaderWriterLock utiliza para permitir el bloqueo escritor a ser bajado (downgraded) cuando se termina de escribir:

Sincronización con objetos Kernel de Windows
A nivel del sistema operativo hay 3 objetos kernel que permiten la sincronización:

Mutex: permite la sincronización a través de AppDomain y procesos frontera (boundaries).
Semáforo: es utilizado para dejar acceder a solo un número de hilos al recurso
Event: provee una forma de notificar a múltiples hilos que un evento ha ocurrido

Todos derivan de la clase WaitHandle, que tiene los siguientes métodos o propiedades:

Handle	Obtiene o establece el objeto de manejador del sistema nativo.
Close	libera todos los recursos utilizados por el actual objeto kernel
WaitOne	bloquea el hilo actual hasta que el objeto kernel es señalado

Clase Mutex
Provee el mecanismo de bloqueo, muy parecido al Monitor, solo que tiene esa característica especial (bloquear datos a través del AppDomain).
Ejemplo:

Para crear un mutex con un nombre con el que puede ser llamado después, es:

Y para obtenerlo:

Clase Semaphore

Es usada para acelerar el uso de recursos. Crea un objeto kernel que soporta un numero de slots válidos.
Creando un objeto semáforo, permite especificar el número de slots usados y el máximo permitido:

Cuando uno desea liberar slots, se puede hacer indicando la cantidad que se desea liberar

Se puede usar por medio de un nombre (de la misma forma que con mutex):

Clase Evento (Event)
Es un tipo de objeto kernel que posee 2 estados, On y off. Esos estados permiten a los hilos esperar hasta que un evento es señalado para hacer algo.
Hay 2 tipos de eventos: auto reset y manual reset.
Cuando un evento auto reset es señalado, el primer objeto esperando por el evento se vuelve al estado no señalado. Un evento de reset manual permite a los hilos que esperan por éste para volverse desbloqueados hasta que manualmente resetee el evento a estado no señalado.
Estos eventos son: AutoResetEvent y ManualResetEvent. Ambas clases heredan de EventWaitHandle. Cuando se crea una de esas clases, se especifica el estado de la señal del evento:

Como las clases anteriores, también permite colocar un nombre al evento:
.

....................................................................................................................................................
2da parte >>
.....................................................................................................................................................

Capítulo 6 – Gráficos

2010-11-02T16:19:00.004-03:00

Se puede usar gráficos para mejorar la interface de una aplicación, crear gráficos, reportes y editar imágenes.

Lección 1 - Dibujando gráficos

System.Drawing permite crear gráficos o modificar imágenes. Cambiar de tamaño una imagen, crear círculos, líneas u otras formas, hacer zoom a imágenes, adherir copyright a logos o textos, etc.

Clases:

Bitmap Encapsula un mapa de bits de GDI+, formado por los datos de píxel de una imagen de gráficos y sus atributos. Un objeto Bitmap es utilizado para trabajar con imágenes definidas por datos de píxel.

Brush Las clases derivadas de esta clase base abstracta definen objetos utilizados para rellenar el interior de formas gráficas, como rectángulos, elipses, gráficos circulares, polígonos y rutas.

Brushes Pinceles de todos los colores estándar. No se puede heredar esta clase.

ColorConverter Convierte colores de un tipo de datos a otro. Se tiene acceso a esta clase mediante TypeDescriptor.

ColorTranslator Convierte colores a y de estructuras Color GDI+. No se puede heredar esta clase.

Font Define un formato concreto para el texto, incluidos el nombre de fuente, el tamaño y los atributos de estilo. No se puede heredar esta clase.

FontConverter Convierte objetos Font de un tipo de datos en otro. Se tiene acceso a la clase FontConverter mediante el objeto TypeDescriptor.

FontFamily Define un grupo de tipos de letra que tienen un diseño básico parecido y algunas diferencias de estilo. No se puede heredar esta clase.

Graphics Encapsula una superficie de dibujo GDI+. No se puede heredar esta clase.

Icon Representa un icono de Windows, que es una pequeña imagen de mapa de bits utilizada para representar un objeto. Los iconos se pueden considerar como mapas de bits transparentes, aunque su tamaño lo determina el sistema.

IconConverter Convierte objetos Icon de un tipo de datos en otro. Se tiene acceso a esta clase mediante el objeto TypeDescriptor.

Image Clase base abstracta que proporciona funcionalidad para las clases descendentes Bitmap y Metafile.

ImageAnimator Da animación a una imagen que tiene marcos basados en tiempo.

ImageConverter ImageConverter es una clase que se puede utilizar para convertir objetos Image de un tipo de datos a otro. Se tiene acceso a esta clase mediante el objeto TypeDescriptor.

ImageFormatConverter ImageFormatConverter es una clase que se puede utilizar para convertir colores de un tipo de datos a otro. Se tiene acceso a esta clase mediante el objeto TypeDescriptor.

Pen Define un objeto utilizado para dibujar líneas y curvas. No se puede heredar esta clase.

Pens Lápices de todos los colores estándar. No se puede heredar esta clase.

PointConverter Convierte objetos Point de un tipo de datos en otro. Se tiene acceso a esta clase mediante el objeto TypeDescriptor.

RectangleConverter Convierte rectángulos de un tipo en otro tipo. Se tiene acceso a esta clase mediante TypeDescriptor.

Region Describe el interior de una forma gráfica formada por rectángulos y rutas. No se puede heredar esta clase.

SizeConverter SizeConverter es una clase que se utiliza para convertir un tipo de datos en otro. Se tiene acceso a esta clase mediante el objeto TypeDescriptor.

SolidBrush Define un pincel de un solo color. Los pinceles se utilizan para rellenar formas de gráficos, por ejemplo rectángulos, elipses, gráficos circulares y rutas. No se puede heredar esta clase.

StringFormat Encapsula información de diseño del texto (como interlineado y alineación), manipulaciones de presentación (como inserción de puntos suspensivos y sustitución de dígitos nacional) y características de OpenType. No se puede heredar esta clase.

SystemBrushes Cada una de las propiedades de la clase SystemBrushes es un objeto SolidBrush que es el color de un elemento de presentación de Windows.

SystemColors Cada una de las propiedades de la clase SystemColors es una estructura Color que es el color de un elemento de presentación de Windows.

SystemIcons Cada una de las propiedades de la clase SystemIcons es un objeto Icon de los iconos de todo del sistema de Windows. No se puede heredar esta clase.

SystemPens Cada una de las propiedades de la clase SystemPens es un objeto Pen que es el color de un elemento de presentación de Windows y es un ancho de 1.

TextureBrush Cada una de las propiedades de la clase TextureBrush es un objeto Brush que utiliza una imagen para rellenar el interior de una forma. No se puede heredar esta clase.

ToolboxBitmapAttribute Se puede aplicar un objeto. ToolboxBitmapAttribute a un control de manera que los contenedores, como el Diseñador de formularios de Microsoft Visual Studio, puedan recuperar un icono que represente el control. El mapa de bits del icono puede encontrarse en un archivo por sí solo o incrustado en el ensamblado que contiene el control.
El tamaño del mapa de bits que se incrusta en el ensamblado del control (o que se almacena en un archivo independiente) debe ser de 16 por 16. El método GetImage de un objeto ToolboxBitmapAttribute puede devolver la imagen pequeña de 16 por 16 o una imagen grande de 32 por 32 creada mediante un ajuste de escala de la imagen pequeña.

Como especificar el tamaño y ubicación de un control.
El uso más común de System.Drawing es especificar la ubicación de algún control, cuando se está creando de manera dinámica (por código).
Para realizarlo se crea un punto al que se le pasa dos parámetros (distancia desde arriba, distancia desde el lado izquierdo) para setear la propiedad Location del control.
Ejemplo

Una forma alternativa se puede setear directamente las propiedades left y top del control.

También es posible especificar el tamaño:

Como especificar el color de los controles
Para modificar los colores de un control, se puede utilizar la estructura Color de la siguiente forma:

Si es que se necesita especificar un color personalizado, se puede utilizar el método Color.FromArgb():

Como dibujar líneas y formas
Para dibujar en un formulario o en un control, se deben de seguir los siguientes pasos:
1. Crea un objeto Graphics llamando al método system.Windows.Forms.Control.CreateGraphics
2. Crear un objeto Pen
3. Llamar al miembro de Graphics para dibujar en el cotrol, usando el Pen.
Una vez que se ha creado el objeto graphics, se puede utilizar muchos métodos para mejorarlo como

Clear	Borra la superficie de dibujo y la rellena con el color de fondo especificado.
DrawEllipse	Dibuja una elipse definida por un rectángulo delimitador especificado por un par de coordenadas, un valor de alto y un valor de ancho.
DrawIcon	Dibuja la imagen representada por el Icon especificado en las coordenadas Señaladas.
DrawIconUnstretched	Dibuja la imagen representada por el Icon especificado sin transformar a escala la imagen.
DrawImage	Dibuja la Image especificada en la ubicación que se indique y con el tamaño original.
DrawLine	Dibuja una línea que conecta los dos puntos especificados por los pares de coordenadas.
DrawLines	Dibuja una serie de segmentos de línea que conectan una matriz de estructuras Point.
DrawPath	Dibuja un GraphicsPath.
DrawPie	Dibuja una forma circular definida por una elipse determinada por un par de coordenadas, unos valores de ancho y alto y dos líneas radiales.
DrawPolygon	Dibuja un polígono definido por una matriz de estructuras Point.
DrawRectangle	Dibuja un rectángulo especificado por un par de coordenadas, un valor de ancho y un valor de alto.
Drawrectangles	Dibuja una serie de rectángulos especificados por las estructuras Rectangle.
DrawString	Dibuja la cadena de texto especificada en la ubicación especificada y con los objetos Brush y Font especificados.

Para especificar cualquiera de esos métodos se debe proveer una instancia de la clase Pen. En el constructor de Pen (lapiz), se especifican el color y width en pixeles:

Métodos como Graphics.DrawLines, Graphics.DrawPolygon, Graphics.DrawRectangles, aceptan arreglos de puntos como parámetros, para crear figuras más complejas.

Como personalizar Pens?
Además de controlar el color y el tamaño del pen (lapiz), que se especifican en el contructor, también se puede controlar el patrón y su endcap. Endcap es el final de una línea, pueden ser utilizados para crear flechas.
Para crear un lapiz que dibuje líneas punteadas, se debería de setear la propiedad de Pen.DashStyle a uno de los siguientes valores:

· DashStyle.Dash (guion)
· DashStyle.DashDot (guion punto)
· DashStyle.DashDotDot (guion punto punto)
· DashStyle.Dot (punto)
· DashStyle.Solid. (solido)

Ejemplo

Tambien es posible utilizar Pen.DashOffset y Pen.DashPattern para definir patrones dash(guion).
Para crear flechas, uno debe de modificar las propiedade Pen.StartCap y Pen.EndCap, utilizando el enumerador LineCap, que tiene valores como:

· LineCap.ArrowAnchor
· LineCap.DiamonAnchor
· LineCap.SquareAnchor
· LineCap.Triangle
· LineCap.Flat
· LineCap.Round
· LineCap.RoundAnchor
· LineCap.Square

Ejemplo:

Como llenar formas?
La mayoría de los métodos de la clase grafics tiene también un método llamado fill que dibuja una forma (shape) y la rellena. Estos métodos requieren una instancia de la clase Brush, la cual es abstracta, entonces se debe de instanciar una clase hija:

System.Drawing.Drawing2D.HatchBrush	define un rectangular brush con un estilo hatch
System.Drawig.Drawing2D.LinearGradientBrush	encapsula un brush con un gradiente lineal.
System.Drawing.Drawing2D.PathGradientBrush	igual que el anterior, solo que provee un llenado más complejo
System.Drawing.SolidBrush	Define un Brush de un color simple.
System.Drawing.TextureBrush	define un Brush desde una imagen

Ejemplo:

Lección 2 – trabajando con imágenes
System.Drawing.Image es una clase abstracta que permite crear, cargar, modificar y grabar imágenes, como BMP, jpg o tif.
La clase Image es abstracta, por lo tanto se debe de crear una instancia usando Image.FromFile, el cual recibe como parámetro un path a la imagen, y Image.FromStream, que recibe un System.IO.Stream como parámetro.
También se pueden utilizar dos clases que heredan de la clase Image:
System.Drawing.Bitmap (para imágenes) y System.Drawing.Imaging.Metafile (para imágenes animadas).
Bitmap es la clase mas usada comúnmente para trabajar con imágenes. Los diferentes constructores de Bitmap, permiten crear un Bitmap a partir de una Imagen, archivo o stream, o sino crear un bitmap en blanco con un height (alto) y width(ancho) especificado. Bitmap contiene 2 metodos importantes que la clase Image carece:

GetPixel, el cual devuelve un objeto Color, con los colores de ese pixel.
SetPixel, setea el color de un pixel.

Como mostrar imágenes?
Para mostrar una imagen guardada en el disco, se debe utilizar Image.FromFile, crear un control PictureBox y usar la imagen para definir PictureBox.Background:
Por ejemplo, para mostrar una image:

Para colocar una imagen como el fondo de un form:

Como crear y guardas imagines?
Para crear una imagen nueva, se debe generar una intancia de la clase Bitmap (uno de los constructores que no requiere una imagen existente, con el método Bitmap.SetPixel o editar una existente usando Graphics.FromImage).
Para grabar una imagen, el Bitmap usa su método Bitmap.Save, ( que recibe como primer parámetro el nombre del archivo y como segundo el formato en que se desea almacenar la imagen).
Ejemplo:

Como usar Iconos?
Los iconos son bitmaps transparentes, de un tamaño especifico, para expresar el estado en Windows. Una forma simple de agregar iconos a un form es con los métodos Graphics.DrawIcon o Graphics.DrawIconUnstretched:

O

Se puede editar un Icono, llamando al método Icon.ToBitmap para crear un bitmap que puede ser editado.

Lección 3 – Formateando texto

Como adherir texto a gráficos?
Para agregar texto a una imagen, debemos:
1. Crear un objeto graphics
2. Crear un objeto Font
3. crear un objeto Brush (opcional)
4. Utilizar el método Graphics.DrawString y especificar la ubicación del texto.

Como crear un objeto Font?
La clase fonts tiene 13 sobrecargas de su contructor, el más simple es pasarle la familia de la fuente(string) ej: “arial”, el tamaño (float/int)y el estilo (fontStyle).
Ejemplo:

O pasándole un FontFamily

Y si necesitamos leer el tipo de fuente desde un string, se puede usar la clase FontConverter (no es muy recomendada porque puede generar errores)

Como escribir texto?
Después de crear un objeto font, se debe crear un brush para definir cómo se va a rellenar el texto. Para agregar el texto a una imagen se llama a Graphics.DrawString:

Como controlar el formateo de texto?
.Net framework brinda control sobre la alineación y dirección del texto usando la clase StringFormat.
Los miembros más importantes de StringFormat son:

Ejemplo de utilización de StringFormat:

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capítulo 5 – Serialización

2010-10-29T10:40:00.002-03:00

Muchas aplicaciones necesitan almacenar o transferir información almacenada en objetos. .Net tiene varias técnicas de serializacion: Binario, SOAP (Simple Object Access Protocol).

Leccion 1 – Serializando Objetos

Que es serialización?

Se implementa usando el NameSpace System.Runtime.Serialization, es el proceso de serializar y deserializar objetos que son almacenados o transferidos y luego reconstruidos. Se convierte el objeto en una secuencia lineal de bytes y viceversa.

Como Serializar un objeto?
Pasos para serializar objetos:

Crear un stream donde se almacenará el objeto serializado.
Crear un BinaryFormatter
Llamar al método Binaryformatter.Serialize para serializar el objeto y colocar el resultado en el stream.
En el método serialize, se le pasa como primer parámetro el Stream y como segundo el objeto a serializar.

Ejemplo:

Se crea un archivo y abriéndolo con NotePad se puede ver esto.

Como deserializar un objeto

Crear un stream para leer el objeto serializado.
Crear un BinaryFormatter
Crear un nuevo objeto donde almacenar lo deserializado.
Llamar al método BinaryFormatter.Deserialize y castearlo al tipo correcto.

Y por pantalla se muestra:

Como se pueden crear clases que se puedan serializar?

Para que una clase sea serializable, se debe agregar el atributo [Serializable] y esto serializa todo, incluso miembros privados. También es posible controlar la serializacion de manera eficiente dependiendo de los requerimientos. Si se desea que uno de los atributos no sea serializable, se le coloca al costado [NonSerialized] . Ejemplo:

 Si un elemento se puede calcular a partir de otros, agregando el atributo [NonSerialized], en

el proceso de deserializacion, no va a ser inicializado.

Pero seguramente vamos a necesitar que se calcule antes de que el objeto sea deserializado,

para eso debemos hacer que nuestra clase implemente la interfaz  IDeserializationCallback, el

método OnDeserialization(Object sender), el cual se llamará en el momento que el objeto se

deserialize.

Como proveer la compatibilidad de versiones?
Para superar limitaciones que pueden ser producidas por problemas de compatibilidad, existen 2 opciones. Implementar una serializacion customizada (explicada más adelante – lección 3) Aplicando el atributo para nuevamente agregar los miembros que pueden causar problemas de compatibilidad. El atributo OptionalField que no afectará el proceso de serialización. Pero si es que en el proceso de deserialización el miembro no fue serializado, el valor será dejado en null sin arrojar excepción. Ejemplo

Mejores prácticas para compatibilidad de versiones:

Nunca remover un campo serializado.
Nunca aplicar NonSerializedAttribute a un atributo que lo era en una versión previa.
Nunca cambiar el nombre o tipo de un campo
Si se adhiere un nuevo atributo, colocarle OptionalFieldAttribute
Si se remueve el atributo NonSerializedAttribute, colocarle OptionalFieldAttribute
Para los atributos opcionales, inicializar sus datos en Serialization callback.

Eligiendo un formato de serializacion

.Net Framework incluye dos métodos para formatear la información serializada, ambas implementan la interface IRemotingFormatter. BinaryFormatter (en NameSpace System.Runtime.Serialization.Formatters.Binary) es el formato en binario que se le da a nuestros objetos, se debería usar cuando uno conoce que todos los clientes a los que va a transferir el binario, tienen solo aplicaciones en .net framework. SoapFormatter (nameSpace System.Runtime.Serialization.Formatters.Binary.Soap) está basado en el formato en xml, la cual es la forma más confiable de transferir datos a través de la red. Debido a que es un xml, será abierto por cualquier aplicación. Se debe utilizar cuando se requiere portabilidad. Por a su complejidad, es menos eficiente que el BinaryFormatter.

Como usar SoapFormatter?
Se debe agregar el namespace System.Runtime.Serialization.Formatters.Binary.Soap y la forma de formatear con SoapFormatter es muy parecido a la de BinaryFormatter, solo se substituye la clase BinaryFormatter por SoapFormatter, aunque el archivo resultante es muy diferente.

De esta forma se ve el archivo creado:

Como controlar la serializacion SOAP?
Se pueden añadir algunos atributos para controlar el formateo de SOAP:

SoapAttribute	para señalar que el atributo va a ser serializado
SoapElement	para señalar que la clase va a ser serializada como un elemento XML.
SoapEnum	para enumeradores
SoapIgnore	para no considerar este campo al momento de la serialización
SoapInclude	cuando este tipo debe ser incluido cuando se generan esquemas.

Recomendaciones sobre la serializacion
Ante la duda, se debe colocar como serializable a clases que incluso no se serializarán en ese momento, porque en el futuro se pueden llegar a necesitar. Se debería deshabilitar la serialización para elementos que son calculados o temporales.

Lección 2 – Serializacion XML
XML es un estándar, un formato de documento basado en texto que puede ser leído por las computadoras. Al igual que HTML posee un formato que puede ser leido y entendido fácilmente por nosotros. Se pueden almacenar imágenes, música, archivos binarios, e incluso información de base de datos.

Porque usa la serializacion XML?
Serializacion en XML es usada cuando se necesita intercambiar un objeto con una aplicación que no esté basada en el framework .Net. Provee los siguientes beneficios:

Gran interoperabilidad: XML está basado en archivos estándares, y existen muchas librerías para que cualquier aplicación de diferentes sistemas operativos lo pueda usar.
Una administración más amigable: puede ser editado desde cualquier editor de texto.
Provee archivos más fáciles de leer: se describe por sí solo. Solo puede serializar datos públicos, no privados, No se pueden serializar grafos.

Como usar XML para serializar/deserializar un objeto?
Crear un stream, textwriter o un xmlWriter para almacenar los datos. Crear un XmlSerializer pasando el objeto que queremos serializar. Llamar al metodo XmlSerializer.Serialize (si queremos serializar) o XmlSerializer.Deserialize (para deserializar) El código es similar al estándar de serialización, por eso solo voy a colocar el código para serializar Xml. Ejemplo:

Como crear una clase que pueda ser serializada usando la serialización xml?

· Se debe especificar la clase como pública.
· Definir todos los miembros que se desean deserializar como públicos.
· Crear un constructor sin parámetros

A diferencia de los otros tipos de serialización, la clase no necesita tener el atributo “Serializable” para poder ser serializado como XML.

Como controlar la serialización XML?
Una clase que no tiene ningún atributo para la serialización en XML, se serializaría a XML donde cada uno de sus miembros es un elemento XML, por ejemplo:
<?xml version="1.0" ?>
   <Clase>
      <att1>valor</att1>
      <att2>otrovalor</att2>
</Clase>
Si estamos definiendo un esquema XML, es suficiente, pero si queremos realizar un documento XML, con estándares específicos, necesitamos agregar algunos atributos para controlarlo. Por ej. (los más usados):

XmlAttribute: permite que el campo, se vuelva un atributo en el momento de la serializacion, es decir estará de la siguiente forma
<Clase att1 = "valor">
...
</Clase>

XmlIgnore: permite ignorar un atributo para que no sea serializado (como [NonSerialized]).

XmlRoot: ("nombre"), sirve para especificar con otro nombre serializado a la clase que se piensa serializar.

Podemos tomar control sobre la serialización en XML, si implementamos la interfaz IXmlSerializable con sus métodos ReadXml y WriteXml para controlar el XmlReader y XmlWriter.

Como generar un esquema XML?
Un esquema Xml define la estructura de un documento Xml. Se puede utilizar la herramienta (xsd.exe) que permite generar un esquema personalizado o estándar(como clase) para las clases que se piensan serializar.

Como serializar un Dataset?
Las instancias de DataSet pueden ser serializadas a XML. Se serializa de la misma forma que los otros objeto, pero no provee un control de lectura que debería de tener. De forma alterna, se puede utilizar DataSet.WriteXml, DataSet.ReadXML y DataSet.GetXml. Ejemplo:

Lección 3 – Serialización personalizada

Controlando la serialización es posible asegurarnos la compatibilidad entre distintas versiones.

Como implementar la serialización personalizada?

Cuando se desea hacer una serialización customizada, se debe de implementar la interfaz ISerializable, el método GetObjectData, además un constructor para el proceso de serialización con los parámetros: SerializationInfo info, StreamingContext context. Del SerializationInfo (es de donde se obtienen los datos de la forma info.GetInt32("numero"))

Respondiendo a los eventos de serialización

.Net Framework soporta eventos de serialización binaria cuando usamos la clase BinaryFormatter. Hay cuatro eventos:

OnSerializing: antes de que se serialize
OnSerialized: después de la serialización
OnDeserializing: antes de que se dé la deserialización
OnDeserialized: después de la deserialización y de OnDeserializing

(Estos 4 eventos solo se realizan en la serialización binaria, no en SOAP ni en la customizada.)

Usando eventos es la forma más fácil de controlar el proceso de serialización.

Los métodos permite modificar los objetos antes y después de la serialización/ deserialización.

Para que un método responda a los eventos, debe cumplir con estos requerimientos:

aceptar como parámetro un StreamingContext.
Retornar void
Tener un atributo que concuerde con la definición del evento que se quiere interceptar.

Ejemplo:

Como cambiar la serialización basada en el contexto?

Generalmente cuando se serializa, el destino no interesa, pero a veces la serialización y deserialización depende del destino.

La estructura StreamingContext provee información acerca del destino de un objeto serializado para una clase que implementa la interface ISerializable.

StreamingContext tiene 2 propiedades importantes:

context.- Es una referencia a un objeto que posee la información deseada por el usuario.
State.- Es una serie de bits que funcionan como flags, pueden indicar:

CrossProcess.- La fuente o destino es un diferente proceso en la misma máquina.
CrossMachine.- La fuente o destino está en una diferente máquina
File.- La fuente o destino es un archivo
Persistence.- La fuente o destino es una base de datos, un archivo u otro.
Remoting.- La fuente o destino es remota a un sitio desconocido.
Other.- La fuente o destino es desconocida.
Close.- El objeto grafo está siendo clonado.
CrossAppDomain.- La fuente o destino es un diferente AppDomain.
All.- Es un contexto por default

Cuando uno construye su formateador, éste automáticamente setea su Context a null y su State a All.

Como crear un Custom Formatter?

Para crear un Custom Formatter, se debe implementar la interfaz IFormatter o IGenericFormatter.Tanto BinaryFormatter como SoapFormatter implementan solo la interfaz IFormatter. La clase FormatterServices provee métodos estáticos para ayudar con la implementación del Formatter.

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capítulo 4 – Colecciones y Genéricos–Parte 2

2010-10-28T11:42:00.004-03:00

Lección 4 – Usando colecciones especializadas

Son colecciones con propósitos muy específicos. Se encuentran en un namespace System.Collections.Specialized

Trabajando con bits
.Net framework trabaja con 2 colecciones de bita: BitArray y BitVector32
BitArray es una colección de tamaño variable (pero no dinamica) que puede almacenar valores lógicos (bool). Soporta operaciones a nivel de bits como and, not, or, Xor (o exclusivo).
BitVector32 ayuda a manipular bits en un integers de 32 bits. No es dinámico (no varía su tamaño), es de 32 bits así que puede manipular integers de 32 bits de forma individual.

Como usar un BitArray
Cuando se crea una instancia de la clase BitArray, se debe especificar su tamaño. Despues de creada, se puede cambiar de tamaño mediante la propiedad length.
No soporta add y remove.
Es importante cuando se quieren realizar operaciones lógicas. Ejemplo

Como usar BitVector32
La estructura BitVector32 es usado para manejar de manera individual bits de un numero largo, un entero de 32 bits. Fue diseñada para simplificar el uso de binarios como un bit individual de información. Tiene un método estático llamado CreateMask que es secuencial.
Si se llama sin parámetros, se crea la máscara para la primera estructura y llamándola secuencialmente con el último bit al que se le hizo las mascara, se va suplantando por la del próximo bit.

Como usar un BitVector32 para un paquete de bits
Esta estructura permite usar toda su capacidad para almacenar varios números pequeños y ahorrar espacio. Crear secciones que serán usadas para almacenar números de un cierto tamaño.
Entonces para almacenar valores se puede usar

Y para mostrarlos

Coleccionando strings

Clase StringCollection
Es una colección dinámica de tamaño cambiante, que solo almacena strings y su uso es igual al de un ArrayList:

Clase StringDictionary
Es una version de la colección diccionario fuertemente tipada, su uso es parecido al de una hashtable, salvo que tanto la llave (key) como el valor (value).

Colecciones Case-Insensitive (no sensible a mayúsculas y minúsculas)
En las colecciones se puede controlar la forma de comparar, Case-Sensitive o Case-Insensitive, usando CreateCaseInsensitiveHastable o CreateCaseInsensitiveSortedList.

De esta forma se toma como un mismo elemento y solo se modifica.

Colecciones de cultura invariante
La comparación es dependiente de las reglas de la cultura actual.
En muchos casos de aplicaciones web, se debería hacer que la colección no se vea afectada por la cultura. Para esto se utiliza el StringComparer, tanto para Hastable como para SortedList:

Clase NameValueCollection
Es similar a la clase StringDictionary, solo permite strings. Admite múltiples valores por key, así como también se puede buscar los elementos por índice o key.

Conosole.WriteLine devuelve ambos valores.

Lección 5 – Colecciones Genéricas (Generics)

Las colecciones genéricas están el namespace System.Collections.Generics, a diferencia de las colecciones normales estas pueden trabajar con un tipo de dato que le definimos cuando se la declara. Pueden usarse para crear colecciones más rápidas y type-safe que sus equivalentes no-genéricas.
Para inicializar una clase genérica se debe utilizar un parámetro adicional después del nombre de la clase, entre los caracteres “<” y “>” pasándole el tipo de datos con el que la colección deberá operar.
Ejemplo:

Los tipos genéricos y sus equivalentes no genéricos

En general el manejo de igual al de su compañera no genérica, la única que no tiene su análoga es la clase LinkedList.

Clase LinkedList
La nueva clase genérica LinkedList es una colección para almacenar ítems que conocen su propia relación en la lista, y permiten iterar sin tener acceso a la colección. Es decir, que únicamente teniendo un objeto de la colección, aunque no tengamos acceso a la colección directamente, podremos iterar en ella.

El método AddAfter añade un item después de un item dado.
El método AddBefore añade un item antes de un item dado.
El método AddFirst añade un item al principio de la colección.
El método AddLast añade un item al final de la colección.
La propiedad First apunta al primer item de la colección.
La propiedad Last apunta al último item de la colección.
La clase LinkedList colecciona objetos LinkedListNode.
La propiedad List devuelve la LinkedList a la que pertenece.
La propiedad Next devuelve el siguiente elemento de la colección a la que pertenece.
La propiedad Previous devuelve elemento anterior de la colección a la que pertenece.
La propiedad Value obtiene el contenido del LinkedListNode.

Capítulo 4 – Colecciones y Genéricos–Parte 1

2010-10-26T17:37:00.001-03:00

Lección 1- Coleccionando Ítems de datos
Las colecciones de datos son algunas de las herramientas más utilizadas a la hora de desarrollar una aplicación ya que nos permiten manipular información en memoria de una manera fácil y flexible.

Tipos de colecciones

Clase	Descripción
ArrayList	Una colección de objetos simples, basada en índices, su tamaño aumenta dinámicamente según se requiera.
BitArray	Administra una matriz compacta de valores de bit que se representan como valores booleanos, donde true indica que el bit está activado (1) y false indica que el bit está desactivado (0).
Hashtable	Es una colección de pares de clave y valor organizados en función del código hash de la clave.
Queue	Representa una colección de objetos de tipo "primero en entrar, primero en salir".
SortedList	Representa una colección de pares de clave y valor ordenados por claves a los que se puede tener acceso por clave y por índice.
Stack	Es una colección sencilla de objetos no genéricos LIFO ("último en entrar, primero en salir").
StringCollection	Una colección de strings que aumenta su tamaño dinámicamente.
StringDictionary	Colección de pares de nombres y valores de strings , que permiten ser recuperadas pasando el nombre o el índice.

La clase ArrayList es la más simple de las colecciones. Esta es una clase que representa una lista de datos (de cualquier tipo) que puede aumentar o disminuir su tamaño dinámicamente de una manera eficiente.
Para crear una instancia de este objeto, se debe utilizar la clase ArrayList incluida en el espacio de nombre System.Collections.

Agregando y removiendo Items
Para agregar un objeto se realiza mediante el método Add (inserta el nuevo elemento en la última posición), AddRange(pasándole un array de elementos), el método Insert (inserta en la posición indicada) o el InsertRange (se en lugar donde inserta los elementos y el array de elementos).

Agregando mediante AddRange:

Usando insert:

Para quitar elementos de la colección, se debe usar el método remove (pasando el elemento), removeAt(una posicion) o RemoveRange (el índice de donde se debe comenzar y la cantidad de elementos a borrar).

Las propiedades más utilizadas son: Count (para conocer la cantidad actual de elementos que contiene la colección) y Capacity (segunda indica la capacidad máxima actual de la colección para almacenar elementos.
La capacidad de la colección aumenta en caso de ser necesario cuando insertamos un elemento, se realiza un redimensionamiento automático.
Para copiar un ArrayList, se puede realizar mediante CopyTo()

Ordenando elementos
El método Sort es un método usado para ordenar los ítems de una colección (implementa la interface Icomparer, que solo tiene el método llamado Compare y este realiza comparaciones de cadenas en las que no se distingue entre mayúsculas y minúsculas)

Iterando a través de los elementos
Tanto los arraylist como las otras colecciones de este capítulo, soportan varias formas de iterar por su contenido.

Otra forma:

La clase ArrayList implementa la interface IEnumerator e IEnumerable. Podemos crear un IEnumerator asignándole el arreglo.GetEnumerator y manejarnos por este con todos los métodos que brinda la interfase IEnumerator.

Lección 2- trabajando con listas secuenciales

Las listas secuenciales son colecciones que deben ser tratadas de una forma metódica y usadas cuando nos interesa tener control sobre el orden en que los elementos son obtenidos de las mismas.
Las clases Cola (Queue) y Pila (stack) son usadas para almacenar datos de forma secuencial.

Clase Cola
Es una clase FIFO (primero en entrar, primero en salir, en inglés First Input First Output). Este comportamiento se puede asociar la Queue con la fila que se debe hacer en un supermercado cuando tenemos que pagar nuestros productos. En ese caso, el cajero atiende en el orden en que llegan las personas a la cola.
Ejemplo de manejo de una cola:

Clase Pila
La pila (Stack), es una colección LIFO (Last Input Fisrt Output, el ultimo que entre es el primero que sale) . Es parecido a una “pila” de platos en donde cada plato esta encima del otro y en caso de querer ingresar un plato a la pila, lo que se debe hacer es ponerlo encima del ultimo plato. Luego cuando se quiere sacar un plato de la pila, solo podemos coger el último plato.
Ejemplo de manejo de una pila:

Lección 3- Trabajando con diccionarios

Los diccionarios son una colección que permite almacenar pares de objetos, donde el primero es una llave (key) que debe ser único y el segundo es su valor (value).
Usando un diccionario

Para los casos básicos se usa un HashTable, que es un tipo específico de diccionario.
Los diccionarios sirven para colecciones pequeñas, en cambio los hashtable sirven para cuando la colección es grande.

Utilizando la sintaxis “[key]” (por ejemplo: tabla ["llave"]), es posible actualizar el valor contenido o si no existe en la tabla, se inserta este nuevo elemento.

Para iterar sobre un hashtable o dictionary, se puede hacer de la siguiente forma:

La clase Hashtable soporta un constructor que acepta un argumento de IEqualityComparer, este permite comparar clases usando el modo CaseInsensitiveComparer (no tiene en cuenta las mayúsculas y minúsculas).

Por lo tanto si escribimos Tabla["Algo"]= “Valor”; es lo mismo que Tabla["algo"]= “Valor”;
Métodos más utilizados:

Add	permite agregar un nuevo par llave/valor a la colección.
Remove	permite quitar un par llave/valor de la colección
Clear	permite borrar todos los ítems de la tabla.
ContainsKey	permite saber si la colección contiene un par cuya clave sea la que se le pasa como parámetro.
ContainsValue	permite saber si la colección contiene un par cuyo valor sea el que se le pasa como parámetro.

Usando la clase SortedList
La clase SortedList es un tipo de la clase diccionario que tiene pares de clave y valor ordenados por claves, su manejo es similar al de un diccionario.

Por lo tanto al mostrar por pantalla se va a obtener:

Diccionarios especializados:
ListDictionary: Funciona de la misma forma que un Hashtable, solamente que más eficiente para pocos datos, ya que Hashtable causa mucho overhead.
HibrydDictionary: es para cuando uno no conoce el tamaño de su arreglo y desea hacerlo de forma eficiente. Para gran volumen de datos se comporta como un Hashtable y para pocos como un ListDictionary.
OrderedDictionary: es como un HashTable pero ordenado, y de una forma particular que uno desee.

Tiene como propiedades: Item, para acceder a cierto índice.
Y como métodos Insert, para insertar en cierto índice un key/value. RemoveAt, remover tal elemento en tal índice.

....................................................................................................................................................
2da parte >>
.....................................................................................................................................................

Capítulo 3 – Buscando, Modificando y codificando texto

2010-10-26T12:27:00.003-03:00

Lección 1 – Formando Expresiones regulares
Una expresión regular es un conjunto de caracteres que pueden ser comparados con un string para determinar si este cumple con los requerimientos especificados en la expresión.
Soportan caracteres especiales y operadores, como por ejemplo: .
* ? + [ ] ( ) { } ^ $ | \.
Los más usados comúnmente son “^” para indicar el comienzo de la cadena, “$” para indicar el final, “?” para indicar un carácter opcional, “.”para indicar cualquier carácter y “*” para indicar un carácter repetido.

.	coincide con cualquier carácter individual
*	coincide con cero o más elementos anteriores
+	coincide con uno o varios elementos anteriores
?	coincide con cero o uno de los elementos anteriores
()	recuerda el contenido del paréntesis como elemento
[]	coincide con un elemento de la lista
-	crea un intervalo en una lista
\|	o
^	coincide con el principio del campo
$	coincide con el final del campo
\	usa caracteres de escape con cualquiera de los elementos anteriores

Como usar expresiones regulares para el pattern matching?
Para usar las expresiones regulares, se debe referenciar System.Text.RegularExpressions . Usando el método estático Regex.IsMatch se puede comprobar si una cadena cumple un patrón dado.
Ejemplo de expresión regular:
^\d{5}$
Significa
^ Comienzo del string, si es multilínea, va a matchear con cada línea
$ Fin del string, si es multilinea, va a matchear con cada línea
\d significa dígitos numéricos
{5} significa que debe haber cinco dígitos numéricos secuenciales.
A continuación un cuadro un poco más explicativo y con ejemplos…

Carácter	Significado	Ejemplo
\	Indica que el siguiente carácter normal debe ser considerado como especial. También se utiliza como carácter de escape para los caracteres especiales.	/\n/ encuentra un salto de línea. Si se desea buscar el carácter '\', habrá que utilizar /\\/
^	Se utiliza para encontrar el comienzo de una línea.	/a/ encuentra una 'a' en cualquier lugar, pero /^a/ haya una coincidencia con el carácter 'a' si se encuentra al comienzo de una línea.
$	Se utiliza para encontrar el final de una línea.
*	Encuentra coincidencia del caracter que le precede cuando aparece 0 o más veces en la cadena.	*/hola/** encuentra coincidencias en las cadena "hol", "hola" y "holaaaa".
+	Igual que el '*', pero cuando el caracter aparece 1 o más veces.
?	Igual que el '*', pero cuando el caracter aparece 0 o 1 vez.
.	Se utiliza para encontrar cualquier caracter que no sea un caracter de nueva línea.	/.sa/ encontrará coincidencias en las cadenas "casa", "cosa" y "cesa", pero no en "asa".
(x)	Encuentra coincidencias con 'x', y recuerda el patrón para su posterior utilización.
x\|y	Encuentra coincidencia si aparece el caracter 'x' o el caracter 'y'.
{n}	Encuentra coincidencia si hay exactamente n apariciones del caracter que precede.	Por ejemplo, /a{3}/ encuentra coincidencia en "holaaa", pero no en "holaa".
{n,}	Encuentra coincidencia si hay al menos n apariciones del caracter que precede.
{n,m}	Encuentra coincidencia si hay como mínimo n y com máximo m apariciones del caracter que precede.
[xyz]	Representa un conjunto de caracteres individuales.	/[aeiou]/ encuentra coincidencias con cualquier vocal. Si se utiliza el caracter '-' se pueden definir rangos. Por ejemplo, /[0-3]/ encuentra coincidencias si aparecen en la cadena los caracteres '0', '1', '2' o '3'.
[^xyz]	Representa un conjunto de caracteres individuales complementario. Encunetra coincidencias con aquellos caracteres que NO aparezcan en el conjunto. Al igual que en el caso anterior, con el '-' se pueden definir rangos.
[\b]	Encuentra coincidencia con el caracter de retroceso.
\b	Encuentra coincidencias con los límites de las palabras.	Por ejemplo, /\bola/ encuentra la cadena "ola" en "Viene una ola", pero no en "Viene una cola".

Las expresiones regulares son muy útiles para filtrar el input del usuario. Pueden ser usadas para machear con patterns complejos.

Ejemplo de dirección de e-mail.

Lo vamos a ir analizando de a poco…
Primero, una expresión regular delimita su inicio con /^ y su fin con $/. Por lo tanto tendría la forma:
/^ Expresión $/

Un email se compone de tres partes:
Nombre usuario + @ + servidor + dominio

Nombre de usuario y el servidor
Ambos deben empezar por una letra o número (\w) y por lo menos debe aparecer una vez (+), puede contener o no (?) Puntos y guiones (\ .-) y terminar con letras y números \w+. Esto se puede repetir cero o varias veces (los puntos, guiones y letras), por lo tanto se coloca entre ()*, para ambos casos quedaría:
\w+ ([\.-]?\w+)*

Dominio
Va al final, detrás de un punto y puede tener 2,3 o 4 letras ({2,3,4})
Además se pueden tener varios dominios seguidos (.com.ar) por eso debemos poner (+).
Su expresión regular queda:
(\.\w{2,3,4})+

Uniendo todo, la expresión regular final sería:
/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3,4})+$/

Aclaración: El tema es un poco más largo, pero creo que con el ejemplo anterior, la idea se entiende,
igualmente les recomiendo entren acá para ver que otros caracteres especiales se pueden usar, y otras opciones de configuración.

Lección 2 - Codificando y decodificando
Cada string y texto es codificado usando diferentes estándares de codificación.
Existen diferentes tipos de codificación:

ASCII: asigna caracteres para 7-bit bytes usando los números desde el 0 al 127. Al inicio no incluía los caracteres que no estaban en el alfabeto inglés (solo tenía letras del alfabeto ingles en mayúscula y minúscula, números, puntuación, y algún otro carácter especial de control).
ANSI: (de 8-bit byte) tuvo una solución para este problema y utilizo del 0 al 127 los códigos ASCII y los demás, desde el 128 al 255, para otros valores específicos del lenguaje elegido.
Unicode: es una codificación de páginas masiva, con miles de caracteres que soportan muchos lenguajes y scripts. No es de un tipo específico de codificación, existen varios tipos. El framework de .Net utiliza Unicode UTF-16 para representar caracteres y a veces UTF-8 internamente.

System.Text soporta las siguientes codificaciones:

UTF-32.- Utiliza UTF32Encoding para convertir desde y hacia un UTF-32
UTF-16.- Utiliza Unicode Encoding para convertir desde y hacia un UTF-16
UTF-8.- UTF8 Encoding
ASCII.- Codifica el alfabeto latino. Utiliza ASCII Encoding
ANSI/ISO.- Encoding

Usando Encoding Class (clases de codificacion)

Se puede usar el método Encoding.GetEncoding para devolver un objeto encoding para una especificada codificación.
Encoding.GetBytes convierte un string unicode a su representación en bytes en una codificación especificada.
Encoding.GetEncodings obtiene un arreglo de EncodingInfo que soporta el framework.

Como especificar el tipo de codificación cuando escribimos un archivo?
Para especificar el tipo de codificación cuando se escribe un archivo, se usa una sobrecarga de su constructor que acepta el objeto Encoding. Ejemplo:

Encoding es una enumeración que contiene opciones como: Default, UTF32, UTF7, UTF8, ASCII, etc.

Como especificar el tipo de codificación cuando leemos una archivo?
Se realiza de la misma manera, suplantando streamWhiter por StreamReader, el constructor del StreamReader posee una sobrecarga en donde se le debe pasar: nombre del archivo, tipo de codificación, y un parámetro de tipo bool, detectEncodingFromByteOrderMarks que detecta la codificación examinando los tres primeros bytes de la secuencia.

Ejemplo:

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capitulo 2 – Input/output (I/O) - Parte 2

2010-10-25T16:12:00.004-03:00

Lección 3 - Streams de compresión.

.Net dispone de dos algoritmos de compresión, Gzip y Deflate, ambos libres de patentes y estándares de la industria. Ambos están limitados a un máximo de 4GB de datos sin compresión.
La clase GzipStream permite comprimir datos a través de otro Stream usando el método de compresión GZIP.
La clase DeflateStream permite comprimir datos a través de otro Stream usando el método de compresión DEFLATE.
La diferencia entre estos dos es que Gzip almacena más información de los datos comprimidos para poder usarse con herramientas como gzip. Deflate tiene menos información y por ello es más efectivo.

Como comprimir datos con un compresión stream?

Se debe abrir el archivo que se va a comprimir y crear un archivo nuevo en el que se va a escribir.
Crear un GZipStream donde le paso el stream de destino, y el modo de compresión (en este caso Compress)

Para comprimir los datos con un DeflateStream solo se debe cambiar la parte donde se crea el GZipSteam por DeflateStream

Como descomprimir datos con un compresión stream?

Para descomprimir los datos con un DeflateStream solo se debe cambiar la parte donde se crea el GZipSteam por DeflateStream

Lección 4 -Trabajando con almacenamiento aislado (Isolated storage)
En la actualidad hay una gran cantidad de malware (virus, spyware, adware, gusanos, troyanos, etc.).
La utilización de un almacenamiento aislado permite que las aplicaciones que no son de plena confianza almacenen datos de una forma controlada por la directiva de seguridad del equipo. Crea un área exclusiva de almacenamiento para una aplicación o un componente, al que sólo esta puede obtener acceso. Por lo tanto, cada aplicación tiene su propia área de archivos asignada automáticamente , completamente aislada de otras aplicaciones.
La clase IsaolatedStorageFile: permite crear archivos y directorios en el isolated storage. Se encuentra en el NameSpace System.IO.IsolatedStorage.
IsolatedStorageScope es un enumerador que describe el scope (ambito) del almacenamiento aislado.
IsolatedStorageFileStream: es un stream utilizado para crear archivos en el isolated storage. Deriva de la clase filestream, por lo tanto tiene casi las mismas propiedades y manejos.

Como crear un almacenamiento?
Antes de grabar información en tu Isolated storage, se debe de determinar el ámbito donde se quiere guardar la información. Se puede elegir entre 2 métodos:
- Assembly/Machine.- Crea un almacenamiento para mantener la informacion que es específica para la llamada del assembly y de la máquina local. Ideal para crear datos a nivel de aplicación:

- Assembly/User.- Este método crea un almacenamiento que guarda información que es específica para la llamada del assembly y el usuario actual. Es útil para crear datos a nivel de usuario:

Leyendo y escribiendo información en un almacenamiento aislado
Se crea un objeto IsolatedStorageFileStream creando una instancia de la clase, especificando cual el nombre del archivo IsolatedStorageFile que se va a incluir dentro.

Después de crear el almacenamiento se puede manejar de la misma manera que un fileStream. Por ejemplo para escribirlo:

Cuando usamos IsolatedStorage no se puede verificar si un archivo existe ahí, esto se debe realizar, por ejemplo preguntando si un arreglo que contiene los nombres de los archivos del IsolatedStorage es mayor a 0:

Como usar directorios en un almacenamiento aislado?
En un isolated storage también tenemos permitido crear directorios, esto es mediante CreateDirectory y después de crear el directorio se pueden crear archivos, especificando el nombre, el FileMode a usar y el objeto de almacenamiento creado:

Para obtener los archivos que tiene ese directorio se realiza de la siguiente forma:

IsolatedStrorageFilePermission es una clase que encapsula los permisos que especifican el acceso al isolated storage.
Propiedades:

UsageAllowed	Obtiene o establece los tipos de permisos a los usuarios.
UserQuota	Obtiene o establece el tamaño de almacenamiento máximo por usuario.

Permitiendo el almacenamiento aislado
Para otorgar suficientes permisos, uno necesita demandar o pedir permisos. Para hacer que el framework se encargue de esto, se hace lo siguiente:

Se usa System.Security.Permissions.

Antes de la clase a la que se desea otorgar permisos, se debe colocar el atributo

Esto permite seleccionar qué assemblies requieren permisos, y si no los tiene, con este atributo, se hace el pedido.

....................................................................................................................................................
Bajar este capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capitulo 2 – Input/output (I/O)–Parte 1

2010-10-25T12:26:00.001-03:00

Las bases del sistema I/O incluyen acceder a archivos y carpetas del sistema, trabajar con streams de lectura y escritura, usar streams compresores y el almacenamiento aislado.

Lección 1 – Navegando con los archivos del sistema
Que son las clases del sistema de archivos?
Dentro de System.IO, hay un conjunto de clases que son usadas para navegar y manipular archivos, directorios y drivers.

Aclaración: cada clase y/o enumeración contiene miembros y métodos interesantes, recomiendo que si pueden hagan clic en los links para conocerlos.

FileSystemInfo es la clase base de todas las clases informadoras del sistema de archivos.

FileInfo provee la funcionalidad básica para manipular un archivo.
Como obtener información de un archivo?
Para obtener información de un archivo especifico, se puede realizar de esta manera:

Como copiar un archivo?
Una vez que tenemos el objeto fileInfo, este permite copiarlo usando CopyTo().

DirectoryInfo provee la funcionalidad básica para manipular un directorio.

Como enumerar archivos de un directorio?
Crear un objeto de tipo DirectoryInfo y llamar al método GetFiles().

DriveInfo provee la funcionalidad básica para obtener información acerca de una unidad.
La enumeración DriveType representa los distintos tipos de unidad que puede ser la clase DriveInfo.

Como enumerar drivers?
Crear un objeto DriverInfo e iniciarlo llamando al método estático DriverInfo.GetDrives();

Path sirve para manipular paths y debería usarse en lugar de intentar manipular un string manualmente.
Como cambiar la extensión de un archivo?
Usando Path.ChangeExtentension( path, extensión) cambia la forma en que se muestra la extensión de una cadena de ruta de acceso del archivo.

FileSystemWatcher puede usarse para monitorizar cambios en un directorio.
Como monitorear cambios en el directorio?
Se crea un objeto de tipo FileSystemWatcher, se registra a los eventos que se desean utilizar ej: created, y se cocola en true la propiedad EnableRaisingEvents (para poder levantar eventos)

Lección 2: leyendo y escribiendo archivos
Streams
Provee la funcionalidad básica para manipular flujos de datos de forma sequencial y aleatoria. Es la clase abstracta de todos los flujos de datos (streams). Un stream es una abstracción de una secuencia de bytes, como un archivo, una entrada/salida a un dispositivo o un socket TCP/IP.
Clases de streams:
FileStream: Provee la funcionalidad básica para abrir archivos tanto en lectura como en escritura. Ejemplo

MemoryStream provee la funcionalidad básica para crear flujos en memoria, como podría ser un archivo que aún no hemos guardado a disco.

CryptoStream Define una secuencia que vincula los flujos de datos a las transformaciones criptográficas. Es un stream donde se escribe el resultado de la encriptación de otro.

NetworkStream: proporciona métodos para enviar y recibir datos a través de sockets de Stream en modo de bloqueo.

GZipStream Proporciona los métodos y propiedades que permiten comprimir y descomprimir archivos sin perdidas.
Ejemplos:
Como comprimir un archivo?

Como descomprimir un archivo?

Que clases facilitan la lectura y escritura de datos?
Clase File: brinda la funcionalidad básica para abrir archivos streams de lectura y escritura.
Clase Directory: interface para manipular y crear directorios en los archivos del sistema.
Clases StreamReader y StreamWriter: proveen las funcionalidades básicas para leer y escribir información de una clase derivada de un stream. Estas clases se asumen como de un nivel más alto que FileStream.
Ejemplos

.....................................................................................................................................................
2da parte >>
.....................................................................................................................................................

Capítulo 1 (Fundamentos del Framework)–Parte 2

2010-10-24T22:35:00.003-03:00

Lección 3 – Construyendo clases
Una clase es un tipo de datos muy eficaz. Como las estructuras, las clases definen métodos y propiedades. Se pueden crear objetos que son instancias de una clase. A diferencia de las estructuras, las clases admiten herencia, que es una parte fundamental de la programación orientada a objetos.

Que es la herencia?
La herencia nos permite heredar de la clase padre, muchas propiedades y métodos útiles, los cuales también podemos sobrescribir, por ejemplo, si mi clase hereda ToString(), se puede sobrescribir este método, para que en el momento en que se imprima mi clase, imprima lo que nosotros definamos.
Ejemplo de clase Jefe que hereda de Empleado

Que es una Interface?
Las interfaces son un contrato, es similar a una clase base abstracta. define un conjunto de métodos (sin su implementación) y propiedades, que todos aquellos que hereden de ésta deberían de implementar. Una interfaz puede llegar a heredar de otra interfaz.

Interfaces más comunes

IComparable: define un método llamado CompareTo que permite comparar instancias de la clase que implementa esta interface. Es fundamental para poder ordenar instancias ya que para poder ordenar un conjunto de objetos es necesario poder compararlos entre sí.

IDisposable: define un método Dispose() que se utiliza para liberar recursos. Las clases que sean muy grandes o que trabajen con recursos que requieran ser liberados (unmanaged resources) deben implementar esta interface para asegurar la liberación de los recursos utilizados.

IConvertible: define métodos para convertir una clase en int, decimal, DateTime, boolean, etc. Para implementar esta interface es común utilizar la clase Convert que permite realizar conversiones estándar de un tipo a otro.

ICloneable: define el método Clone() que retorna una copia del objeto actual.
Hay dos formas de clonar:
• Shallow copy: realiza una copia superficial; si un objeto tiene referencias a otros objetos entonces realiza una copia de las referencias (no genera nuevos objetos). Se realiza utilizando el método MemberwiseClone() que recorre todas las variables de estado y las copia.
• Deep copy: realiza una copia completa del objeto, clonando las variables de estado de tipo Reference. Para ello requiere que todas las variables de estados sean ICloneable.

IEquatable: define el método Equals(T) donde T es el tipo de la clase que implementa dicha interface. A diferencia del método Equals(object) que todas las clases heredan de object, este método utiliza Generics por lo que no requiere un casting para hacer la comparación ya que la comparación se realiza únicamente en objetos del mismo tipo.

IFormattable: define el método ToString(string, IFormatProvider) para convertir un objeto en un string. Da muchísima más flexibilidad que el método ToString() definido en la clase object ya que formatea el string utilizando el objeto de tipo IFormatProvider que podría indicar el formato para establecer la cantidad de decimales y en la cultura podría indicar si se trabaja con la cultura actual o con otra. Ejemplo:
obj.ToString(“0.00”, CultureInfo.CurrentCulture);

Que son las clases parciales?
Especificando una clase como parcial permite dividir su definición en dos o más archivos de código fuente. Cada archivo de código fuente contiene una parte de la definición de clase y todas las partes se combinan cuando se compila la aplicación.

Genericos
Permiten definir un tipo sin especificar detalles. Cuando se trabaja con colecciones (Collections), es más óptimo que trabajar con lista de Objects, reduce la cantidad de errores en tiempo de ejecución por problemas de casteo (evita el casteo).

Uso de constraints (Restricciones)
Se usan para limitar los tipos que se pueden usar en los generics, para especificar que requerimientos debe cumplir.

Soportan 4 tipos:

Interface.	Permite solo tipos que implementen interfaces específicas para usar tus generics.
Base class.	Permite solo tipos que concuerden o hereden de una clase base específica.
Constructor.	Requiere que los tipos que usen tu generics implementen un constructor menos parametrizado.
Reference or value type.	Requiere que los tipos que usen tu generics sean una referencia o un tipo de valor.

Ejemplo:

Esto quiere decir que el parámetro solo pueden ser aquellos tipos que implementen Ifantasma.

Que son los Eventos?
Es un mensaje enviado por un objeto en señal de que a ocurrido una acción, la cual pudo ser causada por una interacción, un clic de mouse, o puede ser hecha por otro programa. El object que levanta el evento es llamado el Event sender, mientras que el objeto que captura el evento, es llamado receptor de evento (event receiver).

Que son los Delegados?
Es una clase que almacena una referencia a un método. Es equivalente a un puntero a una función de tipo seguro (type-safe).Muchas veces es utilizado para señalar un evento a un objeto. Para utilizarlo, se debe de asociar el evento con el manejador del evento.
Un ejemplo de cómo definir un delegado de nombre Deleg cuyos objetos puedan almacenar métodos que devuelvan un string y tomen como parámetro un int es:

Como responder a un evento
Se crea un método que responda al evento, debe coincidir con la firma del delegado.

Y un manejador de eventos (event handler) que indique cual método recibirá el evento.

Que son los Atributos?
Describen tipos, métodos o propiedades que pueden ser consultadas programáticamente usando una técnica llamada Reflexion. Derivan de System.Attribute y son especificados usando [].
Sus usos comunes:

Especificar qué privilegios de seguridad requiere una clase
Especificar privilegios de seguridad que permitan reducir el riesgo de seguridad.
Declarar capacidades, ej. soporta serializacion.
Describir el assembly con un título, descripción o notificación de copyright.

Ejemplo:
Para que una clase sea serializable se le debe añadir [Serializable],

Que es el Type Forwarding?
Type Forwarding es un atributo que permite mover un tipo a de un assembly, a otro assembly, de tal forma que no se deba recompilar los clientes que consuman el primer assembly.
Solo funciona con componentes referenciados por aplicaciones existentes
Ejemplo:

Lección 4- conversión entre tipos
Las conversiones de tipo nos permiten que una expresión de un tipo sea tratada como una expresión de otro, las conversiones pueden ser implícitas (widening) o explícitas (narrowing), estas últimas pueden fallar si el valor que se va a convertir excede el tamaño del tipo al que se va a cambiar.

Por ejemplo la conversión de un tipo int a long es implícita, sin embargo la conversión de un tipo long a un tipo int es explícita, esto debido a que un int puede ser expresado en formato long sin que haya perdida de datos, pero si intentamos convertir un numero long a int puede haber perdida de precisión y se necesita una conversión explícita, es como una forma de obligarnos a demostrar que estamos conscientes de que existe esa perdida.

Formas de realizar conversiones:

System.Convert, entre tipos que implementan IConvertible
tipo.ToString
tipo.Parse
tipo.TryParse y type.TryParseExact, convierte de string a un tipo base, retorna false si no es posible.

Que es boxing y unboxing?
Boxing: es transformar un tipo por valor a un tipo por referencia. Por ejemplo: de Point (un punto con coordenadas x e y ) a object.

Unboxing: se transforma tipo por referencia a un tipo por valor. Ejemplo: object a Point.

....................................................................................................................................................
Bajar esta capítulo en formato PDF Codigo Ejemplo
....................................................................................................................................................

Capítulo 1 (Fundamentos del Framework) - Parte 1

2010-10-24T21:42:00.000-03:00

Que es .Net Framework?

El Microsoft .NET Framework, es un componente de software incluido en los sistemas operativos Microsoft Windows. Provee soluciones pre-codificadas para requerimientos comunes de los programas y gestiona la ejecución de programas escritos específicamente para este Framework.

Su objetivo es crear un marco de desarrollo de software sencillo, reduciendo las vulnerabilidades y aumentando la seguridad de los programas desarrollados.

Lección 1- usando tipos por valor

Son los más comunes de .Net Framework. Hay 3 tipos de valor generales: pre-construidos, definidos por el usuario y enumeraciones (Todos se encuentran en System.Value y se almacenan en el Stack).

Tipos pre-construidos

Otorgados por .net Framework, son: los tipos numéricos (sByte, byte, int32, int64, single, double, decimal), carácter (char), lógicos (bool), etc.

Los tipos por valor tienen un constructor implícito (no es necesario usar new) .

Para declarar variables nulas (sin un valor asignado) se utiliza nullable:

O usando un signo de interrogación después del tipo de dato.

Si se declara una variable como nullable se puede usar HasValue y Value:

Tipos Definidos por el usuario

Son también llamados estructuras, son una composición de varios tipos

por valor relacionados. Por ejemplo: System.Drawing.Point.

Pueden contener constructores, constantes, métodos, campos, propiedades, índices, operadores, eventos, implementar una interface pero no pueden derivar de otra estructura o clase.

Su sintaxis es muy parecida a las clases.

Se debe usar una estructura cuando:

Nuestra instancia es menor a 16 bytes.
Representan un valor simple
No se va a modificar luego de su creación
No va a castear a un tipo por referencia

Enumeraciones

Deriva de System.Enum. Son campos literalmente estáticos, cada uno representa una constante, pueden ser de tipo byte, int32 o int64.

El propósito de las enumeraciones es simplificar el código y mejorarlo habilitando para el uso de símbolos en lugar de valores numéricos.

Lección 2 – Tipos de referencia

Los tipos referencia almacenan la dirección donde se encuentra su información (conocidos como punteros). Están almacenados en el stack mientras que su información se encuentra en el heap.

El heap es manejado por un proceso llamado garbage collector, que recupera la memoria eliminando los ítems que ya no están referenciados. Se ejecuta de forma indeterminada, pero se puede invocar con el método GC.Collect().

Los tipos por referencia más comunes son:

Object
String
StringBuilder
Array
Stream
Exception

String

Un string es una cadena de caracteres (texto). La clase String, nos provee métodos para manipular texto, por ejemplo: usando el método Replace() para reemplazar texto.

Los tipo System.String son inmutables, es decir, no se pueden modificar, cada vez que se le cambia el valor, abandona su antiguo valor y crea un nuevo System.String.

Para evitar esto, se puede utilizar los métodos de System.String como Concat, Join o Format. O también se puede utilizar StringBuilder que permite crear cadenas dinámicas.

String Builders (constructor de cadenas)

Es muy común el tener que trabajar con largas cadenas de texto. Habitualmente se trabajaba concatenando diferentes strings o reescribiendo el mismo string una y otra vez.

Con StringBuilder se mejora el rendimiento considerablemente, ya que cada vez que concatenamos a una String se crea un nuevo objecto string en memoria con el valor antiguo más el valor a concatenar.

El método Append de StringBuilder puede ser 300 veces más rápido que la concatenación de Strings, disminuyendo el uso del procesador (CPU) y evitando trabajo innecesario del servidor.

Ejemplo entre string y Stringbuilder:

El modo de hacerlo con un StringBuilder sería el siguiente:

Array (crear y ordenar arreglos)

Un arreglo es una estructura de datos que contiene un numero de variables llamados elementos del arreglo. Podemos acceder a dichos elementos a través de índices.

Los índices de arreglos en C# empiezan con Cero 0.
Todos los elementos del arreglo deben ser del mismo tipo.
Los arreglos pueden ser de cualquier tipo.
Derivan de la clase System.Array

Ejemplo de un arreglo de 5 enteros:

Ordenación de valores en un arreglo unidimensional.

Para ordenar los arreglos de tipos comunes se puede usar pasándole como parámetro nuestro arreglo (en este caso miArreglo).

Streams

Un Stream es utilizado para la lectura y escritura desde disco o alguna parte de la red, para manejarlos debemos usar System.IO.Stream.

Tipos :

FileStream: se utiliza para la lectura y escritura de archivos.
MemoryStream: para leer y escribir desde memoria.
StreamReader: lee información desde un stream
StreamWriter: te permite escribir en un stream

Ejemplo para escribir con un StreamWriter

Ejemplo para leer con StreamReader

Siempre se debe cerrar cualquiera de nuestro Streams al terminar de usarlo, con el método Close(); para que puedan otros ocupar dicho archivo.

Ejemplo para saber si una ruta existe

Como manejar excepciones

Las excepciones son eventos inesperados que interrumpen la ejecución normal de un ensamblado o un proceso (programa).Derivan de la clase Exception del namespace System. .NET Framework nos provee un modelo en el manejo en bloques try y catch, y (opcional) finally, que es para limpiar valores, o realizar algún método al final del proceso.

Ejemplo

Se pueden colocar varios catch para atrapar los errores luego de un try, pero siempre en orden desde el más específico al más general.

.....................................................................................................................................................
2da parte >>
.....................................................................................................................................................

Comenzando con 70- 536! (en español)

2010-10-22T12:49:00.002-03:00

Hola a todos! Hoy voy a comenzar a leer y resumir las unidades que hay que aprender para pasar el examen 70-536 (Microsoft .NET Framework 2.0 Application Development Foundation).

Me propuse ir colocando todos los días el resumen de cada unidad , así en el transcurso de tres semanas y un poco más (fin de semanas no toco nada…), se termina con el contenido del libro (son 16 capítulos) y solo quedaría practicar un poco más.
Pienso que de esta forma se puede mantener un ritmo buen de lectura y además comprometerse un poco, ya que el libro es la base del examen y está sólo en inglés… vamos a tener que ir haciendo un esfuercito…
El examen tiene 40 preguntas y dan alrededor de 240 minutos para rendirlo, además, por si tenemos algún problema al rendir, Microsoft está dando una segunda oportunidad de rendirlo.
Acá les dejo unos pdf’s y una Iso que les pueden ser útiles para estudiar… igualmente siempre es recomendable tener el libro oficial de manera impresa que sugiere Microsoft , que además incluye in Training kit para familiarizarnos con las preguntas que nos pueden llagar a tomar.
Bueno… a empezar con lo prometido! Espero nos sirva a todos.