February 2009 - Artículos
En el pasado evento de MAD.NUG, hice un comentario a los asistentes acerca de mi personal visión de hacia donde convergían los productos de Microsoft.
Indiqué que no lo había leído en ningún sitio ni que nadie me lo había dicho, simplemente era una idea que tenía basada en el sentido común y en la observación de las últimas acciones de Microsoft.
El caso es que hoy mismo poniéndome al día después de varias semanas de locos, me encuentro con una información del bueno de Somasegar que digámoslo de una forma presuntuosa (pero que no es así ni mucho menos), me da en parte la razón.
Microsoft trata de que sus productos, estén cada vez más acoplados con respecto a su colaboración. Cada uno se puede utilizar de forma independiente, pero la idea es que entre ellos existan canales de comunicación que permitan utilizar varios productos al mismo tiempo para sacar el máximo provecho de todos ellos.
En la entrada de Somasegar, se anuncia que aunque con Visual Studio es posible hoy día desarrollar aplicaciones para SharePoint, debemos para ello instalar las plantillas que nos permitirán realizar esas acciones.
En Visual Studio 2010, esas plantillas serán incorporadas por defecto para que un desarrollador de .NET, pueda crear aplicaciones para SharePoint. Plantillas de proyecto, de diseño, de despliegue, etc, con las cuales podremos desarrollar soluciones de listas de definición, instancias, definiciones del sitio, flujos de trabajo, modelos de BDC, tipos de contenido, etc.
Adicionalmente, se expondrá una API para fomentar que los desarrolladores creen herramientas de desarrollo y nuevas tecnologías.
Como colofón, Somasegar nos "pinta" un par de capturas de pantalla de Visual Studio 2010 donde podemos ver una de las delicias de desarrolladores, diseñadores y toda persona que se "pelee" con SharePoint, hablo de las mejoras del diseñador. Para muestra un botón:
Y si todo esto es poco, una de las cosas que más me han gustado es la posibilidad de navegar por el sitio de SharePoint directamente desde el Explorador de Servidores de Visual Studio 2010:
Alucinante.
Solo diré que tengo ganas de tener entre mis manos a Visual Studio 2010 con estas características para ver como se comporta...
Referencias:
Enlace Web: Información del blog de Somasegar
.jpg)
Me encuentro en un blog de Microsoft un interesante ejemplo de como utilizar el ensamblado System.Web.Caching en aplicaciones Windows para trabajar con objetos dentro de la caché, recuperarlos y detectar cuando están vacíos.
Algo que no indica la entrada a la que hago relación y que tampoco tiene más misterio, es que para eliminar un objeto de la caché, basta con utilizar el método Remove de la clase System.Web.HttpRuntime mediante el uso de System.Web.HttpRuntime.Cache.Remove(nombreClaveCache).
Pero ojo, ¿es bueno o recomendable utilizar este ensamblado en ambientes Windows? (más abajo una breve discusión sobre ello).
Un ejemplito de ese artículo pasado a C# y con la posibilidad de eliminar el objeto de la caché es el siguiente:
Tres controles Button y un control TextBox en un WinForm.
Referencia al ensamblado System.Web en el proyecto.
...
using System.Web.Caching;
namespace Cache
{
public partial class MainForm : Form
{
private const string CacheKey = "testcache";
private const double CacheDurationSeconds = 10;
...
private void button1_Click(object sender, EventArgs e)
{
DateTime cacheExpiration = DateTime.Now.AddSeconds(CacheDurationSeconds);
System.Web.HttpRuntime.Cache.Insert(CacheKey,
this.textBox1.Text,
null,
cacheExpiration,
System.Web.Caching.Cache.NoSlidingExpiration);
MessageBox.Show(this.textBox1.Text +
" has been inserted into the cache. It will expire at " +
cacheExpiration.ToLongTimeString());
}
private void button2_Click(object sender, EventArgs e)
{
object cacheValue = System.Web.HttpRuntime.Cache.Get(CacheKey);
if (cacheValue == null)
{
MessageBox.Show("Nothing in the cache");
}
else
{
MessageBox.Show(cacheValue.ToString() +
" - current time: " +
DateTime.Now.ToLongTimeString());
}
}
private void button3_Click(object sender, EventArgs e)
{
System.Web.HttpRuntime.Cache.Remove(CacheKey);
}
}
}
El caso es que este ejemplo funciona perfectamente, pero como decía al principio del mismo, ¿es una buena práctica utilizar este ensamblado específicamente preparado para ambientes Web en ambientes Windows?.
Según la Knowledge Base de Microsoft, el objeto System.Web.Caching.Cache no está preparado para ser utilizado en Microsoft .NET Framework 1.0 y .NET Framework 1.1.
¿Y en Microsoft .NET Framework 2.0?.
La respuesta es sí, sí está preparado, pero como todo... con precaución amigo conductor, porque aunque sí se puede usar, Microsoft no recomienda su uso como puede desprenderse de la KB comentada.
En su caso, Microsoft apuesta por Caching Application Block por su amplio grado de personalización.
Resumen
En resumidas cuentas, el uso de esta técnica en aplicaciones Windows, no es recomendable para aplicaciones desarrolladas en .NET Framework 1.0 y .NET Framework 1.1, pero sí podría ser utilizado en aplicaciones desarrolladas en .NET Framework 2.0, pero... con cuidadín.
Referencias:
Enlace Web: Acceso al artículo (en inglés)
Enlace Web: Msdn Microsoft - Información de System.Web.Caching (en inglés)
Enlace Web: Knowledge Base (System.Web.Caching.Cache no está preparado para utilizarse en .NET Framework 1.0 y 1.1) (en inglés)
Enlace Web: Caching Application Web (en inglés)
Creo que muchos conoceremos lo que es MSDN Magazine, una revista técnica de artículos muy variados, mucho de los cuales son bastante recomendables de leer.
Dentro de MSDN Magazine, podemos encontrar infinidad de secciones. Una de ellas es el motivo de esta entrada. Se trata de la sección CLR Inside Out.
En esa sección, se tratan artículos muy interesantes escritos normalmente por el equipo de trabajo del CLR de .NET, es decir, por aquellos que mejor conocen las entrañas de .NET a bajo nivel, por aquellos que conocen como funcionan aquello que mueve y gestiona una aplicación .NET.
Mi recomendación es acceder a dicha información, que puede resultar en algunas ocasiones muy útil por despejarnos dudas y aportarnos algo de luz en nuestros desarrollos.
Espero que te resulte de utilidad.
Nota: las traducciones de los artículos al español no son muy deseables a excepción de aquellos que han sido revisados y arreglados por personas de la Comunidad.
Referencias:
Enlace Web: Artículos de CLR Inside Out de Microsoft (en inglés).
Enlace Web: Último número de MSDN Magazine (en español).
Microsoft MSDN ha lavado la cara de su página Web de descargas y de búsqueda de descargas.
Ahora, la página es mucho más vistosa y moderna que la anticuada página que había hasta hace unas horas.
Mucho más sencilla de navegar.
Espero que la búsqueda sea más fiable, porque desde los últimos dos meses aproximadamente, la búsqueda fallaba muchísimo, quizás por la implementación de nuevas características que sí tiene esta nueva versión.
Referencias:
Enlace Web: Página web de descargas de Microsoft MSDN
En esta ocasión, voy a salirme una vez más de la tónica habitual de mi blog para comentaros una aplicación que en lo personal me ha agradado bastante.
Como muchos sabeis, soy un aficionado a la fotografía. Como aficionado a la fotografía, también me gusta tener mis mejores recuerdos bien guardaditos en mis DVD, CD, etc., y a veces, hacer o componer fotografías en álbumes digitales, fondos de pantalla y lo que se tercie.
El caso es que llevaba bastante tiempo buscando un Software que me permitiera hacer collages o similares de mis fotografías de forma fácil y rápida.
Microsoft sacó hace tiempo un programa para hacer collage de fotografías (AutoCollage). Software sacado por el departamento de Research en el Reino Unido creo recordar, que no está nada mal, pero que por un lado es de pago y por otro, hace un poco lo que le da la gana.
El caso es que en esta ocasión, os traigo un Software gratuito que permite hacer un collage de nuestras fotos, prácticamente como nos de la gana, ya que el programa es ampliamente parametrizable.
Se trata de una aplicación desarrollada en Java que en lo personal me encanta, y lo mejor, es que permite extraer la imagen resultante en varios formatos, Jpg, Png y Psd para trabajar con ella con Adobe Photoshop.
Si eres un amante de la fotografía y te gustaría hacer un regalo especial o tener un buen recuerdo, ten en cuenta este programa de nombre Shape Collage y programado por Vicent Cheung.
Referencias:
Enlace Web: Acceso directo a la página de descarga e información de Share Collage.
Enlace Web: Microsoft Research AutoCollage.
En esta ocasión voy a traer un problema que aún no sé porqué se ha dado, y una solución que ha sacado del atolladero.
El problema es que he desarrollado un servicio web con WCF 3.5 y éste lo he instalado en un Windows XP sin problemas.
Me he llevado el servicio web a un Windows Vista por aquello de probarlo en otro entorno de desarrollo, y ahí es dónde me he encontrado con un problema.
Verificado que tengo instalado IIS y que está correctamente instalado, he creado una aplicación IIS de mi servicio web y me he ido a la página web para ver la descripción del servicio (fichero wsdl).
El caso es que me he encontrado con un error que dice:
Error HTTP 403.14
Un simpático error que me ha dejado helado.
Tras pasarme un buen rato mirando la configuración y demás aspectos, me he tropezado (nunca mejor dicho) con la solución.
Me he puesto en el directorio de Microsoft .NET Framework 3.0 (C:\Windows\Microsoft.NET\Frameworks\Windows Communication Foundation\).
Allí, he escrito: ServiceModelReg.exe -i
Este comando ejecuta la herramienta de registro de ServiceModel.
Por lo que sea, el registro de WCF no debió ir del todo bien aunque no me indicara ningún error el día que lo instalé, pero estas cosas nunca se saben si es en el momento de la instalación o en otra acción que haya realizado en el sistema.
El parámetro -i permite registrar WCF y actualizar la raíz de la metabase de Internet Information Services (IIS) entre otras cosas.
El caso es que una vez ejecutada esta instrucción, todo funciona perfectamente.
Por cierto, mi Windows Vista es de 64 bits. Desconozco si tiene algo que ver, pero por si acaso...
Referencias:
Enlace Web: Información adicional sobre ServiceModelReg.exe.
En esta ocasión, os traigo un interesante libro electrónico (ebook) de casi 15 Mb de tamaño y 452 páginas escrito en inglés y que tiene por título Understanding Microsoft Virtualization Solutions.
El libro cubre todas las tecnologías de virtualización de Microsoft incluidas las últimas de Microsoft Windows Server 2008.
Espero que le resulte a más de una persona.
Referencias:
Enlace de descarga: Requiere registro con tu cuenta Passport (Live).
La siguiente entrada, tiene que ver con la compatibilidad de nuestros ensamblados o mejor dicho, con no romper la compatibilidad de nuestros ensamblado ante el planteamiento de modificaciones obligadas. El objetivo de no romper la compatibilidad de los ensamblados hacia atrás es algo que a veces resulta bastante complejo, sobre todo porque conviene tener un control de qué parte o partes del ensamblado o ensamblados vamos a cambiar, modificar, etc, y sobre todo, que impacto tienen esas modificaciones.
La solución que expongo en esta entrada es una de tantas, así que tampoco quiero que nadie la adopte como la ideal. A mí me resulta cómoda y me parece muy evidente, pero como dice el dicho, cada maestrillo tiene su librillo, y cada escenario puede obligarnos a cambiar de idea, así que cada uno que decida.
El caso es que muchas veces, desarrollamos un ensamblado con un conjunto de funcionalidades que son puestas ahí a veces de forma muy pensada y meditada, en otras ocasiones casi de mala manera, y así un montón de situaciones muy diversas. Lo más importante, es que las funcionalidades funcionen como esperamos y que sin pensarlo mucho más, decidamos tirar para adelante.
El problema surge cuando el día a día nos hace ver que la pequeña solución implementada para resolver nuestros grandes problemas, no está del todo bien, ya sea porque hemos metido la zarpa o por la razón que sea (excusas y culpas indemostrables hay siempre mil y una).
El caso es que vamos a suponer un ejemplo muy tonto de desarrollo.
Creamos un ensamblado llamado TestEnsamblado en versión 1.0.0.0, y cuyo código es el siguiente:
/// <summary>
/// Class to get the details of the a person.
/// </summary>
public class PersonDetails
{
/// <summary>
/// Constructor of the class.
/// </summary>
public PersonDetails()
{
}
/// <summary>
/// Constructor of the class.
/// </summary>
/// <param name="name">Name of the person.</param>
/// <param name="department">Department of the person</param>
public PersonDetails(string name, string department)
{
// Assign the name of the person
this.Name = name;
// Assign the department of the person
this.Department = department;
}
/// <summary>
/// Name property.
/// </summary>
public string Name { get; set; }
/// <summary>
/// Department property.
/// </summary>
public string Department { get; set; }
}
Hasta aquí perfecto.
Compilamos nuestro ensamblado y lo consumimos en nuestros desarrollos.
Tiempo más adelante, nos encontramos con que la clase PersonDetails debería ser llamada (por cuestiones varias que nos ha dejado sin dormir durante un par de días) EmployeeDetails, y que el campo Department se denominará ahora Area.
¿Cómo podríamos hacer los cambios en nuestro ensamblado TestEnsamblado 2.0.0.0 sin romper la compatibilidad hacia atrás con TestEnsamblado 1.0.0.0?.
Aunque hay varios refritos y cada uno utiliza el que le conviene o le convence, uno de ellos nos invita a incluir en la clase del ensamblado la etiqueta Obsolete que creará la marca de obsoleto a dicha clase antigua, dejando perenne a la nueva clase del ensamblado. De esa manera, un usuario que tiene una aplicación que utiliza el ensamblado 1.0.0.0, podría recompilar la aplicación con el ensamblado 2.0.0.0 sin problemas y seguir funcionando la aplicación. O al menos, esa es la teoría.
No obstante, un desarrollador nuevo que utilice el ensamblado 2.0.0.0 debe saber que si utiliza la clase "obsoleta", estará cometiendo un sacrilegio mediante el cual, Bill Gates podría aparecer vestido de 666 y hacer conjuras maléficas varias... vamos,... que sin exagerar ni delirar, lo suyo es no utilizar la clase marcada como obsoleta. Si se marca como obsoleta será para que vayamos acostumbrándonos a no usarla. Digo yo que es de sentido común.
Para llevar a cabo esta tarea, podríamos hacer las siguientes acciones.
En primer lugar, crear la nueva clase.
/// <summary>
/// Class to get the details of the a person.
/// </summary>
public class EmployeeDetails
{
/// <summary>
/// Constructor of the class.
/// </summary>
public EmployeeDetails()
{
}
/// <summary>
/// Constructor of the class.
/// </summary>
/// <param name="name">Name of the person.</param>
/// <param name="area">Area of the person</param>
public EmployeeDetails(string name, string area)
{
// Assign the name of the person
this.Name = name;
// Assign the department of the person
this.Area = area;
}
/// <summary>
/// Name property.
/// </summary>
public string Name { get; set; }
/// <summary>
/// Department property.
/// </summary>
public string Area { get; set; }
}
Y una vez hecho esto y sin querer complicar el asunto (formas diferentes de realizar lo que os voy a mostrar, herencia, etc etc etc), prepararemos la clase obsoleta para que no rompa la compatibilidad o al menos, para que la permita "tragar" adecuadamente en las aplicaciones que utilicen el ensamblado versión 1.0.0.0.
La clase obsoleta quedaría de esta forma:
using System;
/// <summary>
/// Class to get the details of the a person.
/// </summary>
[Obsolete("This class is obsolete; Please, use EmployeeDetails instead.")]
public class PersonDetails
{
private EmployeeDetails employeeDetails;
/// <summary>
/// Constructor of the class.
/// </summary>
public PersonDetails()
{
employeeDetails = new EmployeeDetails();
}
/// <summary>
/// Constructor of the class.
/// </summary>
/// <param name="name">Name of the person.</param>
/// <param name="department">Department of the person</param>
public PersonDetails(string name, string department)
{
employeeDetails = new EmployeeDetails(name, department);
}
/// <summary>
/// Name property.
/// </summary>
public string Name { get { return employeeDetails.Name; } set { employeeDetails.Name = value; } }
/// <summary>
/// Department property.
/// </summary>
public string Department { get { return employeeDetails.Area; } set { employeeDetails.Area = value; } }
}
Aún y así, cuando nos pongamos a trabajar con nuestra aplicación, es bastante probable que sin querer o por inercia, utilicemos la clase que hemos marcado como obsoleta.
El que una clase esté marcada como obsoleta, no nos impide utilizar la clase como vemos en la imagen anterior, ya que por defecto, solo muestra un aviso o warning.
Para lograr que el compilador nos marque un error y no un warning o aviso cuando utilizamos la clase obsoleta PersonDetails, deberemos cambiar al principio de la definición de la clase la siguiente instrucción:
/// <summary>
/// Class to get the details of the a person.
/// </summary>
[Obsolete("This class is obsolete; Please, use EmployeeDetails instead.", true)]
public class PersonDetails
{
...
Marcando el valor true en Obsolete, forzamos a que la aplicación que utilice la clase obsoleta, marque un error y no compile.
Esto es muy útil para evitar que se utilice la clase obsoleta dentro del desarrollo de nuestra aplicación, pero... ¿qué ocurre si actualizamos el ensamblado y nuestra aplicación ya utilizaba la versión 1.0.0.0?.
Es decir,... supongamos que generamos nuestro ensamblado como TestEnsamblado v1.0.0.0.
Creamos el proyecto consumidor de nuestro ensamblado TestEnsamblado v1.0.0.0.
La aplicación funciona perfectamente. La implantamos y cerramos esa petición de funcionalidad.
Más adelante y en el tiempo, decidimos crear un nuevo proyecto de nuestros ensamblados y en concreto TestEnsamblado v2.0.0.0. Aquí podríamos hacer un branch o lo que haga falta, tampoco vamos a complicar mucho la historia ahora mismo.
A la clase obsoleta la marcamos con el atributo true como hemos visto anteriormente para que impida que ningún desarrollador pueda juguetear accidentalmente con la clase obsoleta. Además, tenemos previsto eliminar la clase obsoleta para TestEnsamblado v3.0.0.0, así que marcar a Obsolete como true tiene su sentido.
En otro orden de cosas, nos aseguramos de que la firma del segundo ensamblado es la misma que la del primer ensamblado. No queremos romper compatibilidades.
Creamos un nuevo proyecto consumidor de nuestro ensamblado y por "accidente" utilizamos la clase obsoleta. Compilamos o pulsamos F5, y el entorno nos indica un error impidiéndonos el uso de esta clase obsoleta,... pero... ¿os acordais que habíamos desarrollado una aplicación que utiliza TestEnsamblado v1.0.0.0 y que está en producción?. ¿Qué pasaría si sobreescribiéramos el ensamblado TestEnsamblado v1.0.0.0 con TestEnsamblado v2.0.0.0?.
Imaginemos que hemos agregado además de la nueva clase TestEnsamblado v2.0.0.0, un par de modificaciones que resuelven un par de bugs detectados.
¿Sobreescibimos el ensamblado?. Recordemos que el uso de la clase obsoleta, arroja en Visual Studio un error por estar marcada con el atributo true.
Pues efectivamente, no pasa nada de lo que "lógicamente" podríamos pensar, es decir, acepta sin rechistar TestEnsamblado v2.0.0.0 y se ejecuta sin problemas, sin embargo, en el entorno de desarrollo sí se queja.
Adicionalmente, también podemos utilizar el atributo Obsolete, no solo en clases, sino también en métodos, funciones, etc.
Esto es justamente lo que nos permite "jugar" con nuestros ensamblados, actualizarlos, modificarlos, y no romper compatibilidades, asunto éste más frecuente de lo que la mayoría cree.
Eso de amputar código de los ensamblados como Pedro por su casa, como que no, todo requiere un poco de meditación y planteamiento lógico (que muchas veces es el menos lógico) antes de cortar por lo sano.
Espero que os haya gustado.
Saludos.
.NET es un mundo. De eso creo que nadie duda.
Los que estamos embarcados en esto desde que aparecieran las primeras betas (2000-2001) nos sentimos especialmente cómodos, pero tenemos esa "cosita" en el cuerpo (al menos yo) por ayudar a los demás a subirse al tren. Un tren que lleva en marcha mucho tiempo y al que se le van acoplando vagones y más vagones de diferentes colores, algo que a muchos les desconcierta y a veces, hasta agobia.
No obstante, somos muchos los que intentamos que todos los programadores se sientan cómodos con .NET y sepan elegir la parte o partes del tren donde se podrían sentir más cómodos, y así, aparecen materiales que a veces despierta inefrenablemente la curiosidad de uno.
Eso es lo que me ha pasado con la pequeña recopilación que os traigo. Una pequeña recopilación de materiales que espero despierte el gusanillo a quienes tienen ese "miedo" por avanzar... más bien sería miedo de por donde pegar el mordisco al pastel,... porque lo que es pastel sabemos que hay y mucho.
De más reciente a menos... o tratando de organizar el material de alguna forma, os indico:
1. Por un lado, el Azure Services Training Kit.
45 Mb de información extraídas del PDC 2008 sobre Azure Services. ¿Todavía no has "toqueteado" Azure Services?. Pues con esta ayuda lo podrás hacer sin problemas.
2. Sin embargo, no solo de Azure Services vive el hombre, así que siguiendo con la documentación del pasado PDC, tenemos la posibilidad de entrenarnos con el material de entrenamiento de Visual Studio 2010 y de Microsoft .NET Framework.
En este caso, casi 27 Mb de material tienen la culpa. El "inconveniente" en este caso, es que tendremos que tener la máquina virtual de Visual Studio 2010 CTP.
Aún y así, podremos "juguetear" con cosas como C# 4.0, Visual Basic 10, F#, Parallel Computing, AJAX 4.0, ASP.NET MVC Dynamic Data,... al menos es interesante creo yo.
3. Y con todo esto, como no, un clásico. No es que esté anticuado, pero si te estás metiendo con Visual Studio 2008, entonces deberías echar mano al Training Kit de Visual Studio 2008 y Microsoft .NET Framework 3.5.
Apenas 126 Mb de fichero descargable donde nos meteremos de lleno con cosas como LINQ, C# 3.0, Visual Basic 9, ASP.NET AJAX, CardSpace, Silverlight,... y un largo largo etcétera.
4. Tampoco debemos dejar de lado al Training Kit de Microsoft .NET Framework 3.5 Enhancements. Un fichero de casi 33 Mb con información y material de ASP.NET, ADO.NET, etc.
5. Pero si tus dudas están vinculadas con REST, AJAX, Web 2.0 y WCF, entonces a lo mejor lo que te interesa es echarle un vistazo a unos Virtual Labs que nos tendrán ocupados durante unos 90 minutos más o menos.
Es un tiempo largo, pero merece la pena.
6. De todos los modos, los Unit Test son muy importantes,... y claro,... mejor si tenemos unas guías. Para ayudarnos, tenemos la posibilidad de trabajar con los laboratorios virtuales de validación de aplicaciones a través de pruebas unitarias.
7. Aún y así, se que muchos desarrolladores aún estamos embarcados en versiones previas de Visual Studio. Incluso es muy posible que no hayas dado el salto a Visual Studio 2008, por lo que también te sugiero mirar las novedades de Visual Studio 2008 antes de que te metas en él.
Merecer, merece la pena,... ahora bien,... como todo... depende.
8. ¿Y respecto a las implementaciones?. Hace unos días, en el último evento de MAD.NUG, surgió la problemática de qué versión de .NET Framework instalar en los servidores, de si los clientes siguen queriendo aplicaciones en .NET Framework 2.0 por "si acaso"... etc.
Esas preguntas darían para mucha discusión, pero tratando de alumbrar un poco el túnel, y sin tratar de abordar los temas particulares,... me he encontrado con una entrada interesante sobre la instalación de .NET Framework 3.5 en los servidores...
El enlace a la entrada que encontré en el blog de Allam os la pongo más abajo.
9. Como colofón, me gustaría mostraros el sitio de Microsoft denominado Ramp Up, que aglutina un conjunto de recursos gratuitos sobre desarrollo (Visual Basic 6, SharePoint, Visual Studio 2005, Visual Studio 2008, etc) para hacer las delicias del más exigente.
Y ahora... el material...
Referencias:
1. Enlace Web: Azure Services Training Kit.
2. Enlace Web: Visual Studio 2010 y .NET Framework 4.0 Training Kits.
3. Enlace Web: Visual Studio 2008 y .NET Framework 3.5 Training Kits.
4. Enlace Web: Microsoft .NET Framework 3.5 Training Kit Enhancements.
5a. Enlace Web: Virtual Labs de REST, Ajax, Web 2.0 y WCF.
5b. Enlace Web: Documento Pdf de los Virtual Labs de REST, Ajax, Web 2.0 y WCF.
6a. Enlace Web: Virtual Labs de validación de aplicaciones a través de pruebas unitarias.
6b. Enlace Web: Documento Pdf de los Virtual Labs de validación de aplicaciones a través de pruebas unitarias.
7. Enlace Web: Lo nuevo de Visual Studio 2008 (especialmente para desarrolladores de .NET que no han dado el salto).
8. Enlace Web: Enlace sobre la necesidad o no de instalar Microsoft .NET Framework 3.5 en los servidores.
9. Enlace Web: Enlace a Microsoft Ramp Up.
(Imagen: Diagrama del .NET Access Control)
Pluralsight ha elaborado un conjunto de Microsoft .NET Services Whitepapers que están en fase de elaboración y que ya pueden ser descargados como versión CTP de Diciembre de 2008.
Las guías en inglés, cubren los ámbitos de Introducción a Microsoft .NET Services, el .NET Access Control Service, el .NET Service Bus, y el .NET Workflow Service.
Todos los documentos están en formato Microsoft Word.
Referencias:
Enlace de descarga: Documentos - CTP Diciembre 2008.
Enlace Web: Información de Pluralsight sobre los whitepapers.