IIS 7.0 Beta 3 sale con una licencia Go-Live

Esta semana lanzamos IIS 7.0 Beta 3 como parte de la release de Windows “Longhorn” Server. IIS 7.0 es la mayor release de IIS en la historia del producto, y viene con muchas mejoras para la pila de los servidores web de Microsoft. En este artículo y este post encontraréis una lista de unas cuantas de esas mejoras que nos aporta.

Nuevas características en IIS 7.0 Beta 3.

Esta semana, la release de IIS 7.0 beta 3 nos trae un montón de nuevas características y capacidades más allá de las que venían con la release de Windows Vista. Entre otras están:

  • Configuración compartida en granjas de servidores: Ahora podéis configurar vuestros servidores centralizando toda la configuración, código y contenido en una granja de servidores (haciendo que sea mucho más fácil de escalar y administrar). Aquí podeis ver cómo usar esta nueva característica.
  • Delegar la administración remota: Podéis usar la herramienta de administración de IIS7 para administrar remotamente servidores web sobre HTTP/SSL. Los administradores pueden ahora bloquear y delegar configuraciones para administradores de sitios – habilitando un control más fino sobre quién administra los sitios en la máquina (ideal para escenarios de hosting).
  • Aislamiento automático del pool de aplicaciones: IIS 7.o hace mucho más facil el acceso y el aislamiento del pool de aplicaciones de los procesos en el servidor web. Esto es ideal para escenarios de hosting, así como para escenarios de empresas donde queráis tener un aislamiento completo y sandboxing entre aplicaciones.
  • Soporte interno para FastCGI para PHP y otras extensiones: además de permitir una gran extensibilidad para .NET, IIS7.0 ahora trae incluido suporte para extensiones FastCGI – haciendo realmente fácil de usar con frameworks dinámicos para servidores web como PHP.
  • Nuevo servidor FTP: El nuevo servidor FTP de IIS 7.0 incluye soporte para la publicación segura con FTP/SSL, soporte para host header FTP, soporte para una herramienta integrada de administración, y soporte para sistemas de autenticación empotrados (usando el mismo modelo de proveedores que el sistema de membership que ASP .NET.

Aseguráos de leer el post de Bill Staples para aprender más sobre todas las características anteriores.

Licencia Go-Live de IIS 7.0

Después de meses de test de stress en nuestros laboratorios, creemos que IIS7 está listo para afrontar despliegues de clientes. Para facilitar esto, Microsoft ofrecen una licencia especial Go-Live para IIS7 y Windows Server “Longhorn” Beta3. Esto os permitirá desplegar servidores IIS en entornos de producción inmediatamente (nota: Hemos desplegado www.microsoft.com en esta build).

Podéis aprender más sobre la licencia Go-Live de IIS7, así como saber cómo descargaros gratuítamente Windows Server “Longhorn” Beta 3 aquí.

Como alternativa, podéis registraros para obtener una cuenta de hosting en IIS7 Beta en alguno de los web hosters que han desplegado IIS7 Beta 3. Podéis conocer los detalles de sus ofertas aquí.

Espero que sirva.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner.

Intellisense de Javascript en Visual Studio "Orcas"

En Febrero escribí un post llamado Mi primer vistazo a Orcas (inglés). Comentaba alguna de las mejoras para el desarrollo web que iban a venir con Visual Studio “Orcas”. Si no lo habéis leído, hacedlo.

Una de las característica más esperada es el soporte para intellisense de JavaScript en Visual Studio Orcas (esta feature también funciona con la edición Visual Web Developer Express).

Si alguna vez os habéis sentido frustados por tener que escribir cada línea de Javascript, os gustará que Visual Studio “Orcas” traiga soporte completo para el intellisense de Javascript en los archivos .aspx, .html, así como en archivos externos .js.  Tanto soporte para Javascript como para código cliente de ASP .NET AJAX.

Podéis leer algunas de las características para Javascript de Visual Studio Orcas en estos dos post del blog del equipo de herramientas web para Visual Studio:

Como Wally escribió recientemente, una de las cosas “chulas” del intellisense de Javascript en Visual Studio “Orcas” está diseñado para funcionar “out of the box”. Es decir, no tenéis que ejecutar ninguna herramienta en vuestros archivos Javascript para que funcione el intellisense. Ni siquiera teneis que escribir vuestro código javascript de ninguna forma especial para que funciones. Si escribís vuestros códigos de javascript en un archivo externo, obtendremos soporte intellisense en Visual Studio automáticamente.

Commentarios para documentación de Javascript opcional.

Visual Studio nos permite además, opcionalmente, añadir comentarios para la documentación en vuestros códigos/librerías que pueden facilitar el trabajo del motor de intellisense, así como permitir a los desarrolladores aportar documentación en los comentarios que el motor del intellisense del VS puede coger y usarlo para resúmenes, validación y descripciones.

Por ejemplo, si añadimos este comentario resumen XML en nuestro código:

Visual Studio mostrará automáticamente el detalle del resumen, así como ayuda en línea mientras escribimos los valores de los parámetros:

Formato de documentación en los comentarios de Javascript.

Bertrand Le Roy del equipo de ASP .NET escribió un post que cuenta en detalle el formato de los comentarios de Javascript para la documentación que usan tanto ASP .NET AJAX y Visual Studio “Orcas”. Entre otras cosas, incluye detalles sobre:

  • Cómo añadir resúmenes de los detalles de las clases, métodos y parámetros.
  • Cómo localizar la documentación en Javascript.
  • Cómo indicar que un archivo Javascript externo requiere (o referencia) otro archivo externo y asume que los métodos y clases de aquél están al alcance cuando el primer archivo Javascript se usa (esto es increíblemente útil cuando usamos cualquier librería de AJAX).

Os recomiendo que el hechéis un vistazo aquí.

El ASP.NET AJAX Control Tookit también tiene un MSBuild que podéis añadir a vuestros proyectos web para poder obtener esta documentación en vuestros archivos Javascript cuando compiláis un proyecto en modo release. Ésto os permite mantener versiones debug/descripción de vuestros Javascripts en tiempo de desarrollo, y entonces poder tener un puente para generar versiones optimizadas para descargas efficientes en tiempo de ejecución.

Espero que sirva.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner

Parche público para VS para el problema de "Index was outside the bounds of the array"

Hace dos semanas escribí sobre algunas actualizaciones para algunos problemas al compilar ASP .NET 2.0. Podéis leerlo aquí.

En los comentarios de ese post mucha gente preguntaba sobre un problema que habían encontrado con el SP1 de Visual Studio cuando usan el comando “Publish Website” con un projecto web confiugardo para usar el servidor de desarrollo con una “/” como parte del directorio virtual (una técnica sobre la que ya escribí).

Específicamente, los que se han instalado el SP1 de Visual Studio 2005 han reportado que se han encontrado un error “Index was outside the bounds of the array” durante la publicación:

Desafortunadamente, este bug volvía a aparecer con el SP1 de VS 2005.

Las buenas noticias son que hemos publicado otro parche para este problema que os podéis descargar aquí. Omar Khan también a posteado sobre los detalles de este error y parcheado en el blog de MSDN WebDevTools (os recomiendo que os subscribáis).

Importante: La gente me pregunta muchas veces si deben instalar estos parches ántes de que observen el bug. Estos parches son para sistemas muy concretos, y no se le realizan pruebas a toda la linea de producto. Así, que sólo recomiendo que se lo instalen aquellos que hayan observado el error en su sistema.

Si tenéis problemas instalando el parche o si seguís con el error despues de instalarlo, contactad con el soporte de producto de Microsoft. Las llamadas al soporte de producto de Microsoft son gratuistas si están relacionadas con un bug de un producto. Podéis encontrar cómo contactar aquí.

Espero que sirva.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner

Nueva característica de “Orcas”: Sintaxis de consultas

El mes pasado empezé una serie de post cubriendo alguna de las nuevas características de VB y C# que vendrán con las nuevas versiones de Visual Studio y del .NET Framework. Aquí teneis los links a los primeros tres post de esta serie:

El post de hoy cubre otra nueva característica fundamental: Sintaxis de consultas.

¿Que es la sintaxis de consultas?

La sintaxis de consultas (en inglés, Query sintax) es un convenio de declaraciones para expresar consultas usando los operadores estándares de LINQ. Aporta una sintaxis que aumenta la claridad a la hora de escribir consultas en el código, y puede ser más facil de leer y escribir correctamente. Visual Studio provee un intellisense y chequeo en tiempo de compilación para la sintaxis de consultas.

Ejemplo de sintaxis de consultas:

En los post anteriores de esta serie, enseñé cómo declarar una clase “Person” de la siguiente forma:

Podemos usar el código de abajo para instanciar una colleción List<Person> con valores de gente, y usar la sintaxis de consultas para construir una consulta de LINQ sobre la colección y obtener aquellas personas cuyo apellido empieze por la letra “G”, ordenados por el nombre (ascendentemente):

La expresión anterior es semánticamente equivalente al código de abajo, donde usamos métodos de extensión de LINQ y expresiones lambda explicitamente:

Los beneficios de usar la sintaxis de expresiones es que acaba siendo más facil de leer y escribir. Esto es especialmente cierto ya que la expresión se vuelve más rica y es más descriptiva.

Sintaxis de consultas – Entendiendo las frases From y Select:

Toda expresión sintáctica en C# empieza con un “form” y termina con “select” o “group”. La palabra “form” nos indica qué datos queremos consultar. La palabra “select” nos indica qué datos queremos devolver, y qué condiciones deben cumplir.

Por ejemplo, veamos otra vez la consulta sobre la colección List<Person>:

En el código de arriba el trozo “from p in people” nos está indicando que queremos lanzar una consulta LINQ sobre la colección “people”, y que usaremos el parámetro “p” para representar a cada elemento de entrada que estamos consultando. En realidad, el nombre del parámetro “p” es irrelevante – podría haberlo llamado “o”, “x”, “person” o de cualquier otra forma.

El trozo “select p” nos indica que queremos devolver una secuencia IEnumerable de objetos Person como resultado de la consulta. Esto es así ya que la colección “people” contiene objetos de tipo “Person”, y el parámetro “p” representa a objetos Person de esa colección. El tipo de dato devuelto por esta expresión es del tipo IEnumerable<Person>.

Si en lugar de devolver objetos Person, quisiéramos devolver sólo el nombre de la colleción de gente, podríamos reescribir la consulta de la siguiente forma:

Fijaos que en el código anterior no estoy diciendo “select p”, sino que estamos diciendo “select p.FirstName”. Esto indica que no quiero devolver una secuencia de objetos Person – sino una secuencia de string – calculados a partir de la propiedad FirstName de los objetos Person. Por tanto, el tipo devuelto por esta expresión es del tipo IEnumerable<string>

Ejemplo de sintaxis de consultas sobre una base de datos.

La belleza de LINQ es que podemos usar la misma sintaxis sobre cualquier tipo de datos. Por ejemplo, podemos usar el nuevo mapper relacional de LINQ to SQL que viene con “Orcas” para modelar la base de datos de ejemplo de SQL “Northwindw” con clases de la siguiente forma (por favor, ved mi video para aprender cómo hacer esto.)

Una vez que hayamos definido el modelo de clases anterior (y su mapeado a/desde la base de datos), podemos escribir una expresión sintáctica para ver todos los productos cuyo precio por unidad sea mayor de 99 $.

En el código de arriba estamos indicando que queremos lanzar una consulta LINQ sobre la tabla “Products” en la clase NorthwindDataContext creada por el diseñador ORM de Visual Studio “Orcas”. El “Select p” indica que queremos devolver una secuencia de objetos Product que cumplan la condición. El tipo de dato que devuelve esta expresión es del tipo IEnumerable<Product>

Como en el ejemplo anterior de List<Person>, el compilador de C# traducirá nuestra consulta en un método de extensión (usando expresiones Lambda como argumentos). En el caso del código anterior con el ejemplo de LINQ to SQL, las expresiones lambda se convertirán en comandos SQL y se evaluarán en el servidor SQL (de forma que sólo las tuplas de la tabla Products son devueltas a nuestra aplicación). Los detalles del mecanismo que permite esta conversión lambda->SQL los podéis encontrar en mi post sobre expresiones lambda en la sección sobre árboles de expresiones lambda.

Sintaxis de consultas – Entendiendo las frases Where y OrderBy

Entre las sentencias “form” y “select” podemos usar la mayoría de los operadores de LINQ para filtrar y transformar los datos que estamos consultando. Dos de las sentencias más comunes que usareis serán “where” y “orderby”. Éstas manejan el filtrado y el ordenado de los resultados.

Por ejemplo, para devolver una lista ordenada alfabéticamente por el nombre de las categorías de la base de datos Northwind – filtrando sólo aquellas categorías que tienen más de cinco productos asociados – podríamos escribir la siguiente expresión que usa LINQ to SQL para consultar nuestra base de datos:

En la expresión anterior hemos añadido la sentencia “where c.Products.Count >5” para indicar que sólo queremos devolver los nombres de categorías que tengan asociados más de cinco productos. Esto usa las ventajas ofrecidas por el mapeado hecho por  ORM de LINQ to SQL entre los productos y categorías de nuestra base de datos. Además hemos añadido la sentencia “orderby c.CategoryName descending” para indicar que lo queremos ordenar en orden descendiente.

LINQ to SQL generará la siguiente SQL cuando consulte la base de datos usando nuestra expresión:

<

p align=”left”>SELECT [t0].[CategoryName] FROM [dbo].[Categories] AS [t0]
WHERE ((
    SELECT COUNT(*)
    FROM [dbo].[Products] AS [t1]
    WHERE [t1].[CategoryID] = [t0].[CategoryID]
)) > 5
ORDER BY [t0].[CategoryName] DESC

Fijáos en lo listo que es LINQ to SQL ya que sólo nos devuelve la columna que necesitamos (la CategoryName). También hace todo el filtrado y ordenado en la base de datos – lo que lo hace muy eficiente.

Sintaxis de consultas – Transformando datos con projecciones.

Uno de los puntos que hicimos antes era que la sentencia “select” indica qué datos queremos devolver, y en qué forma debería estar.

Por ejemplo, se tenemos una sentencia “select p” como la anterior – donde p es de tipo Person – debería devolver una secuencia de objetos tipo Person:

Una de las capacidades realmente poderosas de LINQ y la sintaxis de consultas es la abilidad de dejarnos definir nuevas clases que están separadas de los datos que están siendo consultados, y entonces usarlas para controlar la forma y la estructura de datos que son devueltos por la consulta.

Por ejemplo, imaginemos que definimos una nueva clase “AlternatePerson” que tiene una sola propiedad “FullName” en lugar de dos separadas “FirstName” y “LastName” como en la clase “Person” que teníamos:

Podríamos usar la siguiente expresión de LINQ para conslutar la colección de List<Person> original, y transformar los resultados para que sean objetos de la clase AlternatePerson:

Fijáos en cómo podemos usar la sintaxis en la inicialización de objetos de la que hablé en el primer post de esta serie para crear una nueva instancia de AlternatePerson y poner sus propiedades dentro de la sentencia “select”. Fijáos también cómo estamos asignando a la propiedad “FullName” concatenando las propiedades “FirstName” y “LastName” de nuestra clase original Person.

Usando projecciones sintácticas con una base de datos.

Esta característica de proyección es increíblemente útil cuando trabajamos con datos obtenidos de un proveedor remoto de datos como una base de datos, nos permite indicar de forma elegante qué columnas debe comprobar nuestro ORM de la base de datos.

Por ejemplo, supongamos que usamos el proveedor del ORM LINQ to SQL para modelar la base de datos “Northwind” en clases:

Con la consulta LINQ de abajo, le estamos diciendo a LINQ to SQL que queremos una secuencia de objetos “Product”:

De todas las columnas necesarias para generar la clase Product deberían ser devueltas por la base de datos como parte de la consulta de arriba, y la SQL original ejecutada por el ORM LINQ to SQL sería algo como lo de abajo:

SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID], [t0].[CategoryID],
              [t0].[QuantityPerUnit], [t0].[UnitPrice], [t0].[UnitsInStock],
              [t0].[UnitsOnOrder], [t0].[ReorderLevel], [t0].[Discontinued]
FROM [dbo].[Products] AS [t0]
WHERE [t0].[UnitPrice] > 99

Si no necesitamos/queremos todas las columnas en algunos escenarios, podríamos definir una nueva clase “MyProduct” como la de abajo, que tenga un subconjunto de propiedades de las de “Product”, así como una nueva propiedad – “TotalRevenue”- que la clase Product no tiene (nota: para los que no estén familiarizados con C#, el Decimal? indic que la propiedad UnitPrice es un valor nullable:

Podríamos usar la capacidad de proyección para “encajar” los datos que quiero devolver de la base de datos usando una consulta como la siguiente:

Esto indica que en lugar de devolver una secuencia de objetos “Product”, lo que queremos son objetos “MyProduct”, y que sólo necesitamos tres propiedades para llenarlos. LINQ to SQL es lo suficientemente listo para ajustar la SQL original para devolver aquellas tres columnas que necesitamos de la base de datos:

SELECT [t0].[ProductID], [t0].[ProductName], [t0].[UnitPrice]
FROM [dbo].[Products] AS [t0]
WHERE [t0].[UnitPrice] > 99

Sólo por fanfarronear, podríamos calcular la cuarta propiedad de la clase MyProduct – “TotalRevenue”. Queremos que este valor sea la cantidad de unidades que hemos vendido de ese producto. Este valor no se guarda en ninguna parte como una columna precalculada en la base de datos Northwind. Tendríamos que hacer un join entre las tablas “Products” y “Order Details” y sumar todas las tuplas de Order Detail asociadas al producto dado.

Lo chulo es que podemos usar el método de extensión de LINQ “Sum” para aprovechar la asociación de Products con OrderDetails y escribir una expresión lambda para la multiplicación como parte de mi sintaxis de consulta para calcular este valor.

LINQ to SQL es lo suficientemente listo para usar la siguiente SQL para hacer el cálculo en la base de datos:

SELECT [t0].[ProductID], [t0].[ProductName], [t0].[UnitPrice], (
        SELECT SUM([t2].[value])
        FROM (
                 SELECT [t1].[UnitPrice] * (CONVERT(Decimal(29,4),[t1].[Quantity])) AS [value], [t1].[ProductID]
                 FROM [dbo].[Order Details] AS [t1]
                 ) AS [t2]
        WHERE [t2].[ProductID] = [t0].[ProductID]
        ) AS [value]
FROM [dbo].[Products] AS [t0]
WHERE [t0].[UnitPrice] > 99

Sintaxis de consultas – Entendiendo la ejecución retrasada, y el uso de ToList() y ToArray()

Por defecto, el resultado de una expresión sintáctica es una variable del tipo IEnumerable<T>. En los ejemplos de arriba os habréis dado cuenta que todas las expresiones devuelven IEnumerable<Product>, IEnumerable<string>, IEnumerable<Person>, IEnumerable<AlternatePerson> e IEnumerable<MyProduct>.

Una de las principales características de la interface IEnumerable<T> es que los objetos que las implementen pueden retrasar su ejecución hasta el momento en que el desarrollador intente iterar sobre los valores (esto es posible gracias al constructor “yield” que fue introducido en C#2.0 en VS 2005). LINQ y las expresiones sintácticas usan esta característica, y retrasan la ejecución de las consultas hasta la primera vez que se itere sobre los resultados. Si nunca se itera sobre una IEnumerable<T>, entonces, la consulta nunca es ejecutada.

Por ejemplo, consideremos el siguiente ejemplo LINQ to SQL:

La base de datos será avisada y los valores necesarios para calcular nuestros objetos Category serán obtenidos no cuando se declara la expresión – sino la primera vez que intentemos iterar sobre los resultados (en la flecha roja).

Esta ejecución retrasada es muy útil porque nos permite crear escenarios muy potentes donde podamos encadenar multiples consultas LINQ y expresiones juntas. Por ejemplo, podríamos usar el resultado de una expresión dentro de otra – y retrasando la ejecución permitimos a un ORM como LINQ to SQL optimizar toda la sentencia SQL que se lanzará en el árbol de expresiones. Veamos unos ejemplos de cómo usar esto en otro post más adelante.

Cómo evaluar una expresión imediatamente.

Si no queremos retrasar la ejecución de las consultas, y queremos hacerlo inmediatamente, podemos usar los operadores ToList() y ToArray() para devolver una List<T> o un array con los resultados.

Por ejemplo, para devolver una lista genérica List<T>:

y para devolver un array:

En ambos casos la base de datos será consultada inmediatamente.

Resumen:

La sintaxis de consultas nos permiten obtener ciertas características declarativas para expresar consultas usando los operadores standar de LINQ. Nos ofrece una sintaxis muy fácil de entender y que funciona con casi cualquier tipo de datos (cualquier colección en memoria, arrays, XML, o sobre proveedores de datos remotos como bases de datos, servicios web, etc). Una vez que se nos haga familiar esta sintaxis, podemos aplicarla inmediatamente en cualquier lugar.

En un futuro no muy lejano terminaré con al última parte de esta serie de post – que cubrirá la nueva característica de tipos anónimos. Y luego veremos cómo usar todas estas características en el mundo real (especialmente usando LINQ contra bases de datos y archivos XML).

Espro que os haya servido.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner.

Actualización del Tookit para publicación de bases de datos.

Hace unos meses posteé sobre la nueva herramienta de publicación para Sql Server desarrollada y publicada por el equipo de Sql Server. Podéis saber qué ofrece y cómo usarala en estos dos post.

Esta herramienta está disponible para descarga gratuita y hace super fácil crear un script .SQL que sea capaz de recrear nuestras bases de datos (incluyendo los esquemas, procedimientos almacenados, y los datos actuales). Cuando está instalada haciendo simplemente clic con el botón derecho en una base de datos en Visual Studio o en Visual Web Developer nos mostrará un asistente que nos guiará para crear el script:

Podremos subir este script, por FTP por ejemplo, a nuestro servidor y ejecutarlo (el segundo post de arriba muestra una técnica que podemos seguir si no tenemos permisos de administración en la máquina remota). Otra forma  es usando el soporte para servicios web integrado que viene con el wizard de publicación para exportar y copiar directamente la base de datos a través de Internet en nuestro servidor remoto.

Actualización de SQL Server Database Publishing Tookit V1.1

A comienzos del mes el equipo de SQL lanzó la versión V1.1 de esta herramienta. Podéis descargarla aquí.

Esta acualización incluye las siguientes mejoras:

  • Añade la posibilidad de seleccionar objetos/tablas individuales para publicarlo con el asistente (sin tener que crear o regenerar todo en la base de datos ).
  • Mejora el rendimiento hasta en un 30-40% en el scripting y en la publicación.
  • Mejora la usabilidad cuando publicamos a través de Internet en un host remoto.
  • Corrige algunos fallos reportados en los foros de CodePlex.

Os recomiendo que lo miréis. Si estáis hosteando vuestras aplicaciones remotamente, esta herramienta puede ser de mucha utilidad.

Gracias.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner

Trabajando con Datos en ASP.NET 2.0

Se han publicado una tonelada de artículos y tutoriales sobre trabajar con datos en ASP.NET 2.0. En este post destacamos algunos de ellos.

Serie de tutoriales sobre trabajo con datos en ASP.NET 2.0.

Scott Mitchell acaba de terminar de escribir su serie de  tutoriales sobre Trabajo con Datos en ASP.NET 2.0 para el sitio www.asp.net . Esta serie de tutoriales contiene más de 75 tutoriales sobre datos (y más de 750 páginas de contenido). Hay versiones disponibles tanto para VB como para C#, y podéis descargar los artículos en PDF. Si aún no los habéis leído, podéis hacerlo aquí.

Aquí tenéis la tabla de contenidos y los enlaces a los artículos publicados (en inglés):

Scott tiene 18 tutoriales más en la serie que serán publicados dentro de poco, y tratan sobre:

  • Caching. (4 tutoriales)
  • Datos y el Site Map Provider (1 tutorial)
  • Trabajando con Batched Data (incluyendo transacciones; 4 tutoriales).
  • Capas de acceso a datos avanzadas (9 tutoriales).

Podéis suscirbiros al RSS para enteraos de las actualizaciones cuando se publiquen estos tutoriales.

Usando los controles DataSource de ASP.NET 2.0

Además de publicar estos artículos en www.asp.net. Scott Mitchell también está escribiendo artículos geniales sobre datos y el uso de controles DataSource para el sitio www.4GuysFromRolla.com.

Si no habéis visitado www.4GuysFromRolla.com, os recomiendo que os paséis por allí. (tienen toneladas de contenidos buenos, y libres). También podéis subscribiros a su RSS de artículos aquí (si eres un desarrollador ASP.NET deberías hacerlo).

 Aquí tenéis un “puntero” a los artículos actuales sobre la serie de controles DataSource de ASP.NET 2.0 de la web 4GuysFromRolla:

Subsonic 2.0 Beta 3

Subsonic 2.0 Beta 3 está disponible para descarga. Subsonic es una genial herramienta (y libre) que os ayuda a crear rápidamente webs guiadas por datos (data driven web). Incluye un constructor DAL que nos permite crear colecciones fuertemente tipadas y un modelo de objetos para nuestros datos (lo construye en tiempo de compilación basándose en el esquema de nuestro website), así como una base muy rica para crear la interfaz de usuario (IU) sobre nuestros datos.

Jon Galloway tiene un pequeño resúmen de algunas de las nuevas características de Subsonic que podéis ver aquí.

Si vais a venir a las conferencias del MIX en dos semanas, aseguraos de saludar a Rob Conery, es el arquitecto jefe de Subsonic. También estará en un panel de Open Source junto a Miguel de Icaza (de Mono) y otros.

Buenas prácticas de NHibernate con ASP.NET, edición 1.2

Billy McCafferty ha actualizado su artículo “NHbiernate Best Practices with ASP.NET” este mes. Podéis leer la última versión aquí.

Este artículo cubre alguna de los temas principales en los que pensar cuando construyamos una capa de datos empresarial usando esta implementación para .NET de un ORM (totalmente libre). Echadle un vistazo al libro NHibernate in Action que será publicado en Julio.

Espero que sirva.

Scott.

Traducido por: Juan María Laó Ramos.

Parche para algunos problemas de compilación de ASP .NET

A lo largo del último año hemos encontrado y corregido unos cuantos bugs de compilación de ASP.NET 2.0 que la gente ha ido encontrando.

Las causas de estos bugs son variadas – pero la causa principal normalmente está relacionada con tener los proyectos estructurados con una forma particular de dependencias circulares entre las páginas, y normalmente se disparan cuando ocurren cambios masivos de archivos en el sistema (por ejemplo: un antivirus actualiza todas las marcas de tiempo de los archivos a la vez).

Mensajes de error típicos:

Los mensajes de error que se exponen son ejemplos de los tipos de execpiones que podríamos ver si te das con uno de estos problemas de compilación:

Unable to cast object of type ‘ASP.masterpage_master’ to type ‘ASP.masterpage_master’.

O: 

Could not load file or assembly ‘App_Web_e9dbmaj, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null’ or one of its dependencies. The system cannot find the file specified.

O:

Compiler Error Message: CS0006: Metadata file ‘C:WINDOWSMicrosoft.NETFrameworkv2.0.50727Temporary ASP.NET Filescms.web44e73607b028acb3App_global.asax.fakktchx.dll’ could not be found

O:

System.InvalidOperationException: The resource class for this page was not found. Please check if the resource file exists and try again

Solución para estos incidentes:

Si tienes una aplicación que empieza a mostrarte estos errores, podrías applicar una solución inmediata que la soluciona abriendo el web.config de tu aplicación y poner el atributo batch=”false” en la sección <compilation>:

<configuration>    <system.web>
       
<compilation debug=”false” batch=”false”></compilation>
   
</system.web></configuration>  

Esto le dice a ASP.NET que compile los archivos .aspx/.ascx dinámicamente en assembiles separados. Esto evita la incidencia sobre referencias circularres que disparan la excepción.

También lo podéis solucionar temporalmente borrando los archivos de la cache “Temporary ASP.NET Files” siguiendo estos pasos:

  1. Clic en el botón de inicio, y clic en ejecutar, escribimos “iisreset /stop” y hacemos clic en OK.
  2. Abrir la carpeta:   “C:windowsMIcrosoft.netframeworkv2.0.50727Temporary ASP.NET Files”
  3. Borrar todos los archivos y subdirectorios.
  4. Clic en el botón de inicio, clic en ejectuar, escribir “iisreset /start” y clic en ok.

 Más detalles sobre esto lo podéis encontrar en  Microsoft KB #934839.

Parche para corregir estos problemas disponible para descarga.

Como alternativa para aplicar la configuración de antes, podeis descargaros y aplicar un parche que soluciona etos problemas.

El enlace directo para desargar este parche lo tenéis aquí.

Podeis encontrar otras parches para Visual Studio y .NET Framework aqui.

Importante: Mucha gente me pregunta si deberían instalar esos parches proactivamente (antes de que vean el error). Siempre que no lo hagan – ya que estos parches están diseñados para un problema muy concreto , y no están testeados para un producto completo. Así que, os recomiendo que apliquéis este parche si tenes ese mismo problema.

Contactando con el soporte de productos de Microsoft.

Si tenéis algún problema instalando el parche o si, una vez instalado, seguís con el mismo problema, querréis contactar con el soporte de productos de Microsoft para que os ayuden a corregirlo. Las llamadas que hagáis son gratuitas si están relacionadas con un bug del producto. Podéis encontrar los detalles de cómo contactar con ellos en esta página (os informará sobre el teléfono al que llamar por país).

La mayoría de las versiones de Visual Studio vienen también con varios tickets para soporte gratuito (por ejemplo: VS Pro de MSDN Premium viene con 4 tickets por subscripción). Podéis usar estos tickets para obtener ayuda con .NET o Visual Studio (por ejemplo: para buscar bugs o problemas de rendimiento en vuestro propio código, o para aprender cómo usar una característica del framework o el IDE).

Hay muchos ingenieros increíbles en el soporte de productos de Microsoft y es muy fácil trabajar con ellos si tenéis algún problema. Aquí tenéis algunos blogs de ellos y los recomiendo muy mucho que os subscribais a algunos de ellos:

Si tenéis algún problema que no seais capaces de solucionar o tenéis un problema con una aplicación en producción para la que necesitéis ayuda inmediata, llamad al soporte de producto de Microsoft y tendreis a algunos como los de arriba para coger un debugger y os ayudarán a averiguar qué está pasando.

Gracias,

Scott

Traducido por: Juan María Laó Ramos. Microsoft Student Partner.

Imagine Cup 2007

¡Este año, el mayor concurso de

desarrollo de software, en Sevilla!

Los cinco mejores equipos de España se enfrentarán por representarnos en Corea en la final Internacional.

 

Jueves, 12 de abril de 2007, Salón de Actos de la ETSII

<

p align=”center” style=”background:#d6e3bc;text-align:center;margin:0 0 10pt” class=”MsoNormal”>09:30 – Registro.
10:00 – Bienvenida.
10:15 – Presentaciones 5 Proyectos finalistas.
13:15 – Conferencia “La Dieta Tecnológica del Futuro”.
14:15 – Entrega de premios.
14:30 – Fin

Registrate en: http://msevents.microsoft.com

El EventID es 1032335057

¡Plazas limitadas, hasta llenar aforo!

Nueva característica de "Orcas": Expresiones Lambda

El mes pasado empezé una serie de post sobre las nuevas características de C# y VB que vienen con las release de Visual Studio y el .NET Framework “Orcas”. Aquí están los dos primeros post:

 El post de hoy cubre otra caracterísitca fundamental: Expresiones Lambda

¿Qué son las Expresiones Lambda?

C#2.0 ( que venía con VS 2005) introdujo el concepto de métodos anónimos, que permitía escribir bloques de código donde se esperaban delegados.

Las Expresiones Lambda aportan una sintaxis más concisa y funcional para escribir métodos anónimos. Son extremadamente útiles cuando escribimos peticiones LINQ – permiten una forma muy compacta de escribir funciones que puedan ser pasadas como argumentos para una evaluación posterior.

Ejemplo de Expresiones Lambda:

En el post sobre Métodos de extensión, demostramos cómo podemos declarar una clase simple, “Person” como sigue:

Os mostramos cómo podemos instanciar una colleción List<Person> con valores, y usar los nuevos métodos de extensión “Where” y “Average” de LINQ para obtener un subconjunto de personas de la colección, así como calcular la media de edad de la gente de dicha colección:

Las expresiones subrayadas en rojo, son Expressiones Lambda. En el ejemplo de arriba usamos la primera expresión lambda para especificar el filtro a usar para obtener a las personas, y la segunda expresión lambda la usamos para especificar el valor de los objetos Person para calcular la media.

Explicaciones de las expresiones Lambda.

La forma más sencilla para conceptualizar las expresiones lambda es pensar en ellas como formas de escribir métodos breves en una linea. Por ejemplo, el ejemplo anterior, podría haberlo escrito usando métodos anónimos de C# 2.0 de la siguiente forma:

Los dos métodos anónimos de arriba reciben un objeto de tipo Person como parámetro. El primer método anónimo devuelve un booleano (indicando si su apellido es Guthrie). El segundo método anónimo devuelve un entero (int) (que devuelve la edad de la persona). La expresión lambda que usamos más arriba funciona de la misma forma – las dos expresiones reciben un tipo Person como parámetro. La primera lambda devuelve un booleano, y la segunda lambda devuelve un entero.

En C# una expresión lambda es escrita, sintácticamente, como una lista de parámteros, seguido del token “=>”, y seguido por una expresión o un bloque de sentencias para que se ejecuten cuando se invoque la expresión

params =>expression

Así, cuando escribimos la expresión lambda:

p=>p.LastName==”Guthrie”

estamos indicando que la expresión lambda que estamos definiendo recibe un parámetro “p”, y que la expresión del código que se va a ejecutar devuelve el valor p.LastName que sea igual a “Guthrie”. El echo de que llamemos “p” al parámetro es irrelevante – podria haberlo llamado “o”, “x”, “foo” o cualquier nombre que hubiese querido.

Al contrario que con los métodos anónimos, que requieren declaraciones de los tipos de los parametros explícitamente, las expresiones Lambda permiten omitir los tipos de los parámetros dejando que se infieran basándose en su uso. Por ejemplo, cuando escribo la expresión lambda p=>p.LastName==”Guthrie”, el compilador infiere que el tipo del parámetro p será del tipo Person porque el método de extensión “Where” estaba trabajando con una collección List<Person>.

Los tipos de parametros Lambda pueden ser inferidos tanto en tiempo de compilación y por el motor de intellisense de Visual Studio (esto significa que tenemos soporte completo de intellisense cuando estamos escribiendo expresiones lambda). Por ejemplo, cuando escribimos “p” vemos cómo Visual Studio “Orcas” nos muestra en el intelisense que sabe que “p” es del tipo “Person”.

Nota: Si queréis declarar explícitamente el tipo del parametro de una expresión Lambda, podeis hacerlo declarando el tipo del parámetro ántes del nombre del parámetro de la siguiente forma:

Avanzado: Árboles de expresiones lambda para desarrolladores de frameworks.

Una de las cosas que hace que las expresiones lambda sean muy útiles desde el punto de vista de un desarrollador de frameworks es que pueden ser compiladas como cualquier otro delegado (en forma de un método basado en IL) o como un objeto árbol de expresiones que pueden ser usados en runtime para analizar, transformar u optimizar la expresión.

De expresiones lambda a código delegado.

El método de extensión “Where” de arriba es un ejemplo de compilar una expresión lambda a un código delegado (significando la compilación a IL que es llamado en forma de delegado). El método de extensión “Where” para filtrar cualquier colección IEnumerable como el de arriba puede ser implementado usando el método de extensión de abajo:

Al método de extensión Where() de arriba se le pasa un parámetro de filtrado del tipo Func<T,bool>, que es un delegado que con un sólo parámtero del tipo “T” devuelve un booleano que indica cuándo se cumple la condición. Cuando pasamos una expresión Lambda como parámetro al método de extensión Where(), el compilador de C# compilará la expresión lambda a un delegado en IL (donde el tipo <T> será Person) para que nuestro método Where() pueda llamarlo para evaluar si se cumple la condición.

De expresiones Lambda a arbol de expresiones.

Compilando expresiones lambda a código delegado funciona muy bien cuando queremos evaluarlas con objetos en memoria como nuestra colección List de arriba. Pero consideremos casos donde queramos consultar datos de una base de datos (el código siguiente fué escrito usando el mapper de “Orcas” LINQ to SQL)

Aquí estamos obteniendo una secuencia fuertemente tipada de objetos “Product” de la base de datos, y estamos expresando un filtro usando expresiones lambda para el método de extensión “Where()”.

Lo que no queremos es obtener todas las filas de productos de la base de datos,  introducirlos en una colección en local y ejecutar el método de extension Where() para objetos de memoria. Esto sería muy ineficiente y no sería escalable con grandes bases de datos. En lugar de eso, nos gustaría usar el ORM LINQ to SQL para traducir el filtro lambda en una expresión SQL, y ejecutar el filtro en la base de datos. De esa forma sólo se devolverán aquellas filas que cumplan el filtro ( y será mucho más eficiente).

Los desarrolladores de frameworks pueden conseguir esto declarando los parámetros de sus expresiones lambda del tipo Expression<T> en lugar de Func<T>. Esto hará que la expressión lambda sea compilada como un arbol de expresiones que podamos ponerla aparte y analizarla en tiempo de ejecución:

Fijaos cómo cogemos la misma expresión lambda p=>p.LastName == “Guthrie” que usamos ántes, pero esta vez asignada a una variable Expression<Func<Person,bool>> en lugar de a un tipo Func<Person,bool>. Entonces, cuando se genere el IL, el compilador asignará un arbol de expresiones que podremos usar como desarrolladores de framework para analizar la expresión lambda y evaluarla cuando queramos (por ejemplo, podríamos elegir los tipos, nombres y valores declarados en la expresión).

En el caso de LINQ to SQL, podría cojer este filtro lambda y traducirlo en una SQL estándar para ejecutarla contra una base de datos (logicamente “SELECT * FROM Products WHERE UnitPrice<55”).

Interfaz IQueryable<T>

Para ayudar a los desarrolladores de frameworks en la construcción de providers de datos, LINQ aporta la interfaz IQueryable<T>. Implementa los métodos de extensión, operadores estándar de LINQ, y aporta una forma más eficiente de implementar el procesado de un complejo árbol de expresiones (por ejemplo: algo parecido al siguiente caso, donde usamos tres métodos de extensión diferentes y dos lambdas para obtener 10 productos de la base de datos:

Para leer algunos post sobre cómo construir un proveedor para LINQ con usando IQueryable<T>, pasaros por estos post:

Resúmen.

Afortunadamente el post de arriba nos dá un entendimiento básico de cómo hay que pensar y usar las expresiones lambda. Cuando se combina con los métodos de extensión de LINQ, nos ofrece una forma muy rica de consultar e interactuar con cualquier tipo de datos conservando el soporte en tiempo de compilación e intellisense.

Con el soporte de Expresiones en arbol que nos dan las lambdas y la interfaz IQueryable<T>, los desarrolladores de frameworks pueden construir proveedores de datos que se ejecutarán rápida y eficientemente sobre las fuentes de datos (tanto bases de datos, archivos xml, objetos en memoria, servicios web, sistemas LDAP, etc).

En las próximas semanas completaré esta serie de post cubriendo los nuevos conceptos de lenguajes desde un nivel teórico, y luego hablaré sobre algunos ejemplos muy prácticos usando esos conceptos (especialmente usando LINQ contra bases de datos y archivos XML).

Espero que sirva.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner.

Trucos: Habilitar SSL en IIS 7.0 usando certificados firmados por nosotros

SSL permite que los navegadores se comuniquen con un servidor web sobre un canal seguro para evitar que nadie pueda “escuchar” la comunicación, interceptar y falsificar mensajes. Deberíamos usar SSL en las páginas de login donde los usuarios introducen sus nombres de usuario y contraseñas, así como en todas las web de un sitio que puedan ser “sensibles” (por ejemplo: páginas que muestren información financiera o personal).

Configurar SSL en Windows con versiones anteriores de IIS ha sido siempre un quebradero de cabeza. Hay que saber cómo instalar y administrar un certificado, y luego asociarlo a un sitio web, seguro que es algo que la mayoría de desarrolladores web no saben cómo habilitar.

Las buenas noticias son que IIS 7.0 hace radicalmente fácil configurar y habilitar SSL. IIS 7.0 además trae soporte de fábrica para crear nuestros propios certificados de forma sencilla para habilitar rápidamente un sitio web SSL para desarrollo o para test.

Con IIS 7.0 podemos habilitar un sitio web ya creado con SSL en tan sólo 30 segundos. El siguiente tutorial muestra cómo hacer eso.

Paso 1: Crear un nuevo sitio web.

Empezaremos creando un nuevo sitio web con la nueva herramienta de administración de IIS7.0. Esta herramienta de adminstración ha sido reescrita completamente a partir de la versión anterior (que fué escrita usando código manegado con Windows Forms), y provee una organización más lógica de características web. Da una experiencia de administración con una interfaz gráfica (GUI) para todas las configuraciones de ASP.NET e IIS:

SSLIISStep0

Para crear un nuevo sitio, clic con el botón derecho en el nodo “Web Sites” en el árbol del lado izquierdo y elegir la opción “Add Web Site” del menu contextual. Añadimos los detalles necesarios para crear el nuevo sitio web:

SSLIISStep1

Una gran característica de IIS7 en Windows Vista es que podemos tener un número ilimitado de sitios web en una caja (las versiones anteriores de IIS en clientes Windows sólo nos permitía un sitio). La limitacion de 10 peticiones simultaneas en las versiones de IIS para clientes Windows no existe ahora en IIS7.

Paso 2: Crear un certificado propio.

Antes de enlazar reglas SSL a nuestro sitio, necesitamos importar e instalar un certificado de seguridad para usarlo en el enlace SSL.

Los certificados se administran en IIS7 haciendo clic en el nodo root del árbol de la izquierda, y seleccionamos el icono “Server Certificates” en el lado derecho:

ssliisstep3

Esto nos mostrará una lista de todos los certificados registrados en la máquina, y nos permitirá importar y/o crear otros nuevos.

Opcionalmente, podemos irnos a una entidad emisora de certificados como Verisign y comprar un certificado para importarlo con esta herramienta de administración. O podermos crear nuestro propio certificado para que funcione como un certificado de prueba que podamos usar para el desarrollo y las pruebas en nuestro sitio. Para hacer esto, tenemos que hacer clic en el link “Create Self-Signed Certificate” en la parte derecha de la herramienta de administración:

ssliisstep4

Metemos el nombre para usar el certificado (por ejemplo: “test”) y hacemos clic en ok. IIS7 creará automáticamente un nuevo certificado encriptado y lo registrará en la máquina:

Paso 3: Habilitar los enlaces HTTPS para nuestro nuevo sitio.

Para habilitar SSL en nuestro nuevo sitio web, seleccionamos el nodo del web side en el árbol de la izquierda, y hacemos clic en link “Bindings”del menú “actions” del lado derecho de la pantalla:

Esto nos mostrará un cuadro de dialogo que nos mostrará todas las reglas de enlace que dirigen el tráfico a este sitio (significando las combinaciones de cabeceras host/direcciones ip/puerto para el sitio):

Para habilitar SSL en el sitio, haremos clic en el boton “Add”. Esto nos mostrará otro cuadro de dialogo  para añadir soporte para el protocolo HTTPS. Podemos seleccionar el certificado que hemos creado de la lista desplegable del diálogo, para indicar que queremos usar ese certificado cuando encriptemos contenido sobre SSL:

Hacemos clic en OK y ya tenemos habilitado SSL para nuestro sitio:

Paso 4: Probando nuestro sitio.

Añadimos una página “default.aspx” al sitio, e intentamos abrirla con el navegador escribiendo https://localhost/default.aspx (usamos “https” en lugar de “http” para indicar que queremos conectarnos a través de SSL).

Si usamos IE7, vereis el error de anti-phising:

No os alarméis si os pasa esto – tan sólo es el IE que nos advierte que un certificado creado por nosotros es sospechoso. Hacemos clic en el link “Continue to this website” para saltarnos este aviso de seguridad e ir al sitio. Encontraremos nuestra pagina default.aspx  corriendo sobre SSL:

Y ya está echo. 🙂

Apendice: Últimas notas sobre SSL.

  • La herramienta de administración de IIS7 tiene un nodo de configuración “SSL Settings” que podemos seleccionar para cada sitio, directorio o archivo que nos permite controlar cuándo, ese recurso particular (y por defecto a todos sus hijos), requiera peticiones SSL para ejecutarse. Esto es muy útil para páginas como login.aspx, cuando queremos garantizar que los usuarios metan sus credenciales cuando el canal esté encriptado. IIS 7 bloqueará a todos lo navegadores que intenten acceder a menos que lo hagan sobre SSL.
  • En una pagina ASP.NET, podemos saber programáticamente, cuándo la petición actual está usando SSL chequeando la propiedad Request.IsSecure (devolverá “true” si la petición viene por SSL).
  • Podemos poner el atributo “requireSSL” en la sección de configuración de <forms> en el web.config para tener el sistema de autentificación por formulario de ASP.NET y asegurarnos que las cookies sólo se usan en sitios con SSL. Esto evita el riesgo de que un hacker intercepte una cookie de autentificación en una página sin SSL, e intente usar el “ataque por repeticion” desde una máquina diferente para suplantar la identidad de un usuario.

 Para más información de IIS/, leeros mi anterior post sobre IIS7. También echadle un vistado a la web www.iis.net.

Para leer mas sobre mis post sobre trucos, visitad mi página sobre trucos

Espero que sirva.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner.