lunes, diciembre 13, 2010
Charla sobre PowerShell
domingo, octubre 31, 2010
Introduccion a LINQ Parte 3.4 (Arquitectura)
Artículos relacionados
Parte 1, Parte 2, Parte 3.1, Parte 3.2, Parte 3.3
En esta oportunidad hablaremos sobre las Expresiones Lambda en C# y VB.
Podemos decir que las expresiones lamba son le evolución natural de los métodos anónimos incluidos en C# 2.0. Esto nos permite utilizar una sintaxis mas compacta al momento de escribir nuestro código. Veamos un par definiciones del sitio de Microsoft:
"Una expresión lambda es una función anónima que puede contener expresiones e instrucciones y se puede utilizar para crear delegados o tipos de árboles de expresión"
"Una expresión lambda es una función sin nombre que calcula y devuelve un solo valor. Se pueden utilizar las expresiones lambda dondequiera que un tipo de delegado sea válido"
Creo que la forma mas sencilla de entender este concepto es mediante un ejemplo que muestre la evolución de los cambios en la sintaxis de los lenguajes hasta llegar a las expresiones lambda.
C#
VB
En el código anterior podemos ver la definición de un delegado que recibe un tipo Int, Integer y retorna un tipo bool, Boolean, esto servirá para poder sustituir cualquier función que tenga esa firma en el procedimiento Mostrar Números. Y definimos dos funciones una que indica si un numero es par y la otra si es mayor a 5. Ahora veamos como se invocaría dicho método usando los delegados. (C# 1.0 y VB 7.0)
C#
VB
Recientemente se introdujo el concepto de funciones anónimas, que permiten eliminar la necesidad de definir el delegado especifico y en su lugar usar un delegado genérico. ( esto se puede aplicar en ambos lenguajes). Ejemplo:
C#
VB
En C# 2.0 se introdujo el concepto de métodos anónimos como un medio de escribir bloques de instrucciones insertados sin nombre que se pueden ejecutar en una invocación de delegado (no se necesita definir previamente el delegado). Ejemplo:
C#
Finalmente esto se puede escribir utilizando expresiones lambda de la siguiente forma:
C#
VB
Como pueden ver las expresiónes lamda permiten una sintaxis mas compacta y pueden contener instrucciones como en el ejemplo anterior o expresiones, de aquí surge el concepto de arboles de expresión que tocaremos en la siguiente entrega y veremos como se aplican todos los conceptos que hemos visto en las consultas LINQ.
Pueden descargar el código fuente aquí.
Hasta la proxima.
lunes, octubre 18, 2010
Introducción a LINQ Parte 3.3 (Arquitectura)
Artículos relacionados:
Parte 1, Parte 2, Parte 3.1, Parte 3.2
En esta ocasión hablaremos sobre Tipos Anónimos y Métodos de Extensión.
Tipos Anónimos
Son una forma abreviada de inicializadores de objetos que permiten omitir la especificación del tipo cuando se inicializan objetos o colecciones temporales. Por ejemplo en el articulo anterior utilizamos la clase LineaProducto, podríamos omitir la especificación del tipo y por ende eliminar la necesidad de la definición de la clase. Los tipos anónimos son tipos esenciales para las proyecciones de LINQ, las cuales permiten incorporar el equivalente en LINQ de una lista de campos en una consulta SQL (mediante la instrucción SELECT).
veamos un ejemplo:
C#
VB
El compilador infiere el tipo de las tuplas, por lo que los objetos resultantes son strongly typed definidos así: IEnumerable<<int, int, decimal>> y IEnumerable(of VB$AnonymousType_0 (of Integer, Integer, Decimal)) respectivamente.
Métodos de Extensión
Estos permiten agregar métodos propios a tipos previamente definidos, incluso si estos son sealed en C# o NotInheritable en VB. Por ejemplo el tipo string / String es sealed y tiene varios métodos accesados por (.) como stringTest.Lenght() o “esto es un test”.Lenght(). El compilador trata estas sentencias como si fueran miembros de una librería de funciones como Length(stringTest) o Length(“esto es un test”).
Por ejemplo el método length genera una excepción si el valor es null o nothing. Seria útil tener un método LengthNullable() que retornara int?, Integer? o Nullable(of Integer) que eliminaría la necesidad de revisar si el valor es null o Nothing antes de invocar al método Length. Veamos como se puede hacer utilizando métodos de extensión.
C#
Los métodos de extensión deben ser definidos como public static anteponiendo la instrucción this al primer argumento del método el compilador sabe que es un método de extensión, el segundo argumento es el tipo al que aplica el método para este ejemplo string y el tercero es el nombre de la instancia. Los métodos de extensión tienen soporte para IntelliSense.
VB
De acuerdo a la documentación de Visual Studio 2008 se pueden aplicar métodos de extensión a los siguientes tipos Clases, Estructuras, Interfaces, Delegados y Arreglos.
Hasta la próxima.
Revisar el estado de los Jobs de SQL Server con PowerShell
Una tarea muy común de todo DBA es revisar el estado de los Jobs de SQL Server, para esto podemos utilizar el siguiente script en PowerShell. (La lista de servidores se carga a partir de un archivo te texto “sqlservers.txt”). Espero les sea de utilidad.
# Carga el assembly [System.Reflection.Assembly]::LoadWithPartialName('Microsoft.SqlServer.SMO') | out-null # Obtiene la lista de servidores SQL $sqlservers = Get-Content "$Env:USERPROFILE\sqlservers.txt"; # Revisa los Jobs Write-Host "Revision de Jobs de SQL Server" Write-Host "==========================================================" Write-Host " " foreach($sqlserver in $sqlservers) { $srv = New-Object ('Microsoft.SqlServer.Management.Smo.Server') $sqlserver Write-Host "Server -- $sqlserver" Write-Host "========================================================" $jobs = $srv.JobServer.Jobs | Where-Object {$_.IsEnabled -eq $TRUE} | Select Name,LastRunOutcome, LastRunDate foreach($job in $jobs) { $colour = "Green"; if ( $job.LastRunOutcome -eq "Failed"){ $colour = "Red"; } Write-Host -ForegroundColor $colour $job.Name $job.LastRunOutcome $job.LastRunDate } Write-Host }
viernes, octubre 15, 2010
Introducción a LINQ Parte 3.2 (Arquitectura)
Artículos relacionados:
Continuando con los cambios a los lenguajes para soportar LINQ veremos algunas formas de inicializar objetos, arreglos y colecciones.
Inicializadores de Objetos
para este ejemplo crearemos una clase utilizando propiedades automáticas (otra de las nuevas funcionalidades de C# 3.0) y después compararemos la forma de inicializarla anteriormente con la forma simplificada de hacerlo ahora.
C#
en la versiones 1.0 y 2.0 se inicializaba de esta forma.
en la versión 3.0 quedaría así.
VB
en la versión 8.0 se inicializaba así.
en la versión 9.0 quedaría así.
Inicializadores de Arreglos
veamos un ejemplo inicializando un arreglo de objetos tipo LineaProducto
C#
VB
en VB 9.0 no es posible utilizar inicializadores de objetos para inicializar arreglos, sin embargo se pueden asignar elementos creados por inicializadores de objetos a un arreglo de esta forma
Inicializadores de Colecciones
Esto se aplica a las colecciones que soportan la interface IEnumerable y tienen un método .Add
C#
VB
En la siguiente entrega hablaremos sobre los métodos de extensión.
Hasta la próxima.
miércoles, octubre 13, 2010
Introducción a LINQ Parte 3.1 (Arquitectura)
Artículos relacionados:
Ahora veamos en detalle las extensiones hechas a los lenguajes para soportar LINQ:
Variables Implícitas (Inferencia de Tipos):
Permite inferir el tipo de variable en base a su inicialización.
Ejemplos:
C#
VB
Al ejecutar estas instrucciones podemos notar que la variable nombre es de tipo string, que la variable cantidad es de tipo int y numeros es un arreglo tipo int. Esto nos indica que NO son variables dinámicas (esto ya es soportado en el framework 4.0 ) sino que son variables tipadas pero inferidas por el compilador. Lo que se puede apreciar en el IL generado.
ahora veamos como se aplica esto en una consulta basada en LINQ
C#
VB
las variables numeros y query infieren su tipo en base a la expresión asignada, hay que notar especialmente la variable query que almacena una consulta linq (query expression) de allí la necesidad de soportar inferencia de tipos en los lenguajes.
Hasta la próxima.
martes, julio 13, 2010
Introducción a LINQ parte 2 (Arquitectura)
En esta ocasión veremos los conceptos en los que se basa LINQ y los cambios que se han hecho en VB y C# para darle soporte.
La mayoría de nosotros hemos usado lenguajes de un dominio específico ( DSLs – Domain-Specific Languages). Estos son lenguajes diseñados para un dominio específico como procesadores de palabras (macros), bases de datos relacionales (SQL), WebBrowsers (Javascript), etc. Gran variedad de estos lenguajes son implementados a través de generadores de código gráfico y wizards. Las herramientas que liberó Microsoft para Visual Studio 2005 y Visual Studio 2008 para dominios específicos como Aplicaciones Web, SmartClients, Mobile se basan en el concepto de DSLs. (Software Factories)
Por ejemplo SQL es un lenguaje para un dominio especifico que tiene que ver con la manipulación de datos en una base de datos relacional, y para este hay varios sabores o implementaciones como T-SQL (Microsoft), PL/SQL (Oracle), a estos lenguajes se les denomina DSQLs.
El problema con todos estos lenguajes es que en la gran mayoría de los casos las aplicaciones que desarrollamos necesitan de alguna manera manipular datos almacenados en algún motor de base de datos por lo que debemos conocer SQL y nuestro lenguaje de propósito general como VB o C# y traducir nuestras sentencias del lenguaje de programación a “otro lenguaje”. Lo que nos resta productividad y nos causa problemas. De allí que el grupo de LINQ se enfocó en tratar de resolver este problema.
Como lo describió el arquitecto de C# “LINQ es un modelo de programación para consultar, transformar y agrupar cualquier tipo de dato que comúnmente se manipula en una aplicación intensiva de datos , ya sea un objeto, relacional o XML”.
Aunque LINQ no es un DSQL, existen varias implementaciones de LINQ para dominios específicos como:
LINQ to Objects:
La implementación default, que permite hacer consultas a objetos en memoria.
LINQ to SQL:
Para consultas de SQL Server, incluye un diseñador DSL gráfico y una herramienta O/RM.
LINQ to DataSet:
Para consultar ADO.Net DataSet tipados y no tipados.
LINQ to XML:
Para consultar documentos XML.
LINQ to Entities:
Para consultar EntitySets definidos en un Entitity Data Model en Entity Framework.
LINQ es el responsable de las extensiones hechas a los lenguajes en Visual Studio 2008. En el siguiente artículo veremos en detalle los cambios hechos a C# 3.0 y VB 9.0 por el momento menciono la lista de cambios:
- Variables Implícitas
- Inicializadores de Objetos
- Inicializadores de Arreglos
- Inicializadores de Colecciones
- Tipos Anónimos
- Métodos de Extensión
- Expresiones Lambda
- Operadores Estándar de Consulta
- Expresiones de Consulta
- Arboles de Expresión
LINQ también se basa en características de C# 2.0 y VB 8.0 como:
- Tipos Genéricos
- Métodos Anónimos
- Iteradores
Hasta la próxima.
Introducción a LINQ (Language Integrated Query)
Vamos a dividir esta serie de artículos en 3 partes:
1. Arquitectura e implementación
2. Ejecución (LINQ to Objects)
3. Operadores avanzados y expresiones
Breve Historia de LINQ
Para comenzar hablemos un poco de historia. Los conceptos de LINQ se originan en lenguajes de programación funcional como Haskell, que se basa en el cálculo lambda (otros lenguajes funcionales conocidos son LISP, APL, Erlang, ML y Scheme). Podemos decir que los lenguajes imperativos como C# o VB procesan las acciones para realizar una tarea en una serie de pasos, en lugar de ejecutar una secuencia de pasos los lenguajes funcionales evalúan expresiones. En estos lenguajes el desarrollador especifica lo que debe realizar el programa no como debe hacerlo.
Por ejemplo SQL es un lenguaje de consultas que emula a un lenguaje funcional, una sentencia SQL define las tuplas que se quieren obtener o actualizar, y el motor de base de datos decide como realizar las tareas solicitadas.
El cálculo lambda es una aproximación matemática formal para definición de función, aplicación y recursión, y es referido en Haskell y otros lenguajes funcionales como funciones lambda. Haskell y otros lenguajes funcionales manejan conceptos como funciones, closures, inferencia de tipos, lazy evaluation, monads (un método flexible para combinar operaciones I/O con lazy evaluation). En el Microsoft Research se trabajó en lenguajes experimentales como X#, Xen y finalmente CѠ ( c-omega). El objetivo de este lenguaje era reducir el ROX (Relational-to-Objects-to-XML) impedance mismatch agregando conceptos y operadores del dominio relacional y XML como una extensión a C#. Microsoft libero una versión preliminar del compilador de CѠ a mediados del 2004.
Algunos miembros del equipo de X#/Xen/CѠ se unieron al grupo que trabajo en LINQ ,en el cual Anders Helsberg (Arquitecto de Pascal, Delphi, J++, C#) quería añadir “operadores de secuencia” a C# para que los desarrolladores los aplicaran a colecciones que implementaran el tipo genérico IEnumerable<T> . Erick Meijer, uno de los diseñadores de Haskel98 y llamado creador de LINQ, comenzó a hacer propaganda sobre el presente y futuro de las versiones de LINQ en algunas conferencias técnicas.
La primera versión preliminar salió en septiembre de 2005 durante el PDC 2005. En septiembre de 2006 se lanzo la CTP. y en la versión CTP de enero de 2007 de VS2008 (orcas) se incluyó un add-on para el compilador de Visual Studio. La versión RTM de VS2008 no incluyó significantes cambios a LINQ. La versión final de Visual Studio 2008 SP1 incluyo la versión 3.5 del .Net Framework con soporte para EF, EDM y LINQ en Agosto de 2008.
jueves, mayo 13, 2010
Obtener estadísticas de buzones en Exchange 2007
Una tarea muy común de un administrador de Exchange es el control de espacio utilizado por los buzones de correo, les indico un comando que les da esa información en MB o GB ordenado por el mayor.
$_.TotalItemSize.Value.ToMB()}},ItemCount
$_.TotalItemSize.Value.ToGB()}},ItemCount
miércoles, mayo 12, 2010
Cambiar el UPN para un usuario/dominio Exchange 2007
domingo, abril 18, 2010
Recursos para comenzar con Visual Studio 2010
Recientemente se realizo el lanzamiento de Visual Studio 2010, próximamente estaré compartiendo con ustedes sobre lo nuevo en Acceso a Datos y WCF. Para comenzar, les recomiendo estos enlaces.
Visual Studio 2010 Professional Whitepaper
Visual Studio 2010 and .NET Framework 4 Training Kit
Saludos.