Viernes: Code Tips

Tip #1: Como saber con que usuario estamos corriendo:

WinForms:

   1:  using System.Security.Principal;

   2:  ...

   3:  ...

   4:    WindowsIdentity identity = WindowsIdentity.GetCurrent();

   5:    string userName = identity.Name;

Web:

   1:  using System.Security.Principal;

   2:  ...

   3:  ...

   4:   

   5:     IPrincipal userPrincipal = HttpContext.Current.User;

   6:     WindowsIdentity identity = userPrincipal.Identity as WindowsIdentity;

   7:   

   8:     string userName = identity.Name;

Tip #2: Como imprimir los atributos y sus valores (getters/setters) de una clase usando Reflection:

   1:   /// <summary>

   2:          /// Despliega los atributos de una clase y su valor

   3:          /// </summary>

   4:          private void desplegarAtributos(object clase)

   5:          {

   6:              if(clase != null)

   7:              {

   8:                  Type objectType = clase.GetType();

   9:                  PropertyInfo[] propertyInfo = objectType.GetProperties();

  10:   

  11:                  Console.WriteLine();

  12:                  Console.WriteLine("\tNombre de la clase: {0}", clase);

  13:   

  14:                  Console.WriteLine();

  15:                  foreach (var info in propertyInfo)

  16:                  {

  17:                      object foo = info.GetValue(clase, null);

  18:                      Console.WriteLine("\t\t{0} = {1}", info.Name, foo);

  19:                  }

  20:              }

  21:          }

Regresando a lo básico: Versiones de .NET

Una de las cosas que confunen a varios de los desarolladeres de .NET/C# es la nomenclatura de versionamiento que utiliza Microsoft para el framework de .NET.

Algunas personas me han preguntado sobre 'la versión' de .NET y sus diferencias, y decidi escribir esta entrada de blog.

Para poder comprender la nomenclatura de .NET, tenemos que entender las piezas individuales por las cual esta conformado el framework:

El framework de .NET esta conformado por:

• CLR: Common Language Runtime. la maquina virtual que corre nuestros programas, el corazón de .NET
• Compilador de C#: Convierte nuestro codigo en binarios/assemblies para correr bajo el CLR.
• Clases base: forma el API de programacion core de .NET
• WinForms/ASP.NET/ADO.NET: APIs principales que corren encima de las clases base.

La versión 1.1 de .NET por ejemplo, esta compuesta por versiones del CLR, Compilador, Clases base y SWF/ASP.NET/ADO.NET

La versión 2.0 de .NET también consta de versiones nuevas de los componentes arriba mencionados. Es por eso que decimos que .NET 1.1 y .NET 2.0 son versiones diferentes.

 Ahora, aquí es donde se pone interesante. La version 3.0 de .NET esta conformada por los siguientes componetes:

• el CLR de .NET 2.0
• el compilador de C# de .NET 2.0
• las clases base de .NET 2.0
• WinForms/ASP.NET/ADO.NET de .NET 2.0

y  tres nuevos APIs principales:

• WCF: Windows Communication Foundation aka Indigo
• WPF: Windows Presentation Foundation aka Avalon
• WF: Windows Workflow

Entonces como podemos ver, una nueva versión del framework no necesariamente cambia la versión del CLR o del compilador!

Es por eso que el cambio de .NET 1.1 a .NET 2.0 fue mayor que el cambio de .NET 2.0 a .NET 3.0

Versión del Framework	Numero de Versión	Vistual Studio	Incluida en Windows	CLR	C#
1.0	1.0.3705.0	Visual Studio .NET		1.0	1.0
1.1	1.1.4322.573	Visual Studio .NET 2003	Windows Server 2003, XP SP2	1.1	1.0
2.0	2.0.50727.42	Visual Studio 2005		2.0	2.0
3.0	3.0.4506.30		Windows Vista, Windows Server 2008	2.0	2.0
3.5	3.5.21022.8	Visual Studio 2008	Windows 7, Windows Server 2008 R2	2.0	3.0
4.0 Beta1		Visual Studio 2010 Beta		4.0?	4.0?

Como podemos ver, la versión del CLR (la maquina virtual que corre nuestras aplicaciones) no ha cambiado desde .NET 2.0

Si, es muy confuso! La buena noticia es que con .NET 4.0, Microsoft parece que va a estandarizar de nuevo las versiones del framework, CLR/DLR, y compilador, todo esto en una nueva versión de VS.NET 2010

Referencias:

• http://www.hanselman.com/blog/HowToSetAnIISApplicationOrAppPoolToUseASPNET35RatherThan20.aspx
• http://en.wikipedia.org/wiki/.NET_Framework
• http://www.infoq.com/news/2008/04/dotnet-framework-versions
• http://blogs.msdn.com/rmbyers/archive/2008/10/26/clr-4-0-advancements-in-diagnostics.aspx

Nuevos features the C# 4.0 (incluido en .NET 4.0)

Hay dos features nuevos de C# 4.0 que en mi opinión son muy útiles: Optional Parameters y Named Parameters

Antes, si queríamos tener un método que aceptara diferente numero de parámetros teníamos que hacer sobrecarga (overload) del método:

1:  // Crea un respaldo del archivo, nombres default

2:  private void CrearArchivoRespaldo() 

3:  {

4:      //..

5:  }

1:  //Crea respaldo del archivo de entrada, especificando el nombre del respaldo

2:  private void CrearArchivoRespaldo(string archivoRespaldo)

3:  {

4:      //..

5:  }

1:  //Crea un respaldo del archivo de entrada, especificando el nombre del archivo de

2:  //entrada y nombre del archivo de respaldo

3:  private void CrearArchivoRespaldo(string archivoOriginal, 

4: string archivoRespaldo)

5:  {

6:      //..

7:  }

Terminábamos con varios métodos, y mas código que mantener.

Me ha tocado ver un método (codigo legacy) sobrecargado mas de 18 veces, con diferentes listas de parámetros y diferente orden!

En C# 4.0 podemos utilizar parámetros opcionales en nuestros métodos.

Ahora, podemos nombrar nuestros parámetros de la siguiente manera:

1:  //Crea un archivo de respaldo

2:  private void CrearArchivoRespaldo(string archivoEntrada =

3: "c:\\input.txt", string archivoRespaldo="c:\\archivo.txt.bak)

4:  {

5:      //..

6:  }

Al mandar llamar CrearArchivoRespaldo() sin parametros, tomara los valores asignados.

También podemos llamar CrearArchivoRespaldo() de la siguente manera:

1:  CrearArchivoRespaldo(archivoEntrada:"C:=\\foo.txt", 

archivoRespaldo:"c:\\bar.bak")

Como podemos ver, estamos utilizando el nombre del parámetro en la asignación.

De esta manera nos ahorramos la sobrecarga de los métodos, y ganamos un poco de claridad al declarar los nombres de nuestros parámetros al llamar el método.

Este es uno de mis features favoritos de C# 4.0 ! :-)

Para mayor referencia:  http://code.msdn.microsoft.com/csharpfuture/Release/ProjectReleases.aspx?ReleaseId=1686

Como detectar la versión instalada de .NET

Hace poco me vi en la necesidad de verificar la versión instalada de .NET  y ver si se encontraba instalado el Service Pack 2 para .NET 2.0.

La manera recomendada es buscando la siguiente llave del registry:

     HKLM\Software\Microsoft\NET Framework Setup\NDP\v2.0.50727\SP

Con el siguiente codigo podemos obtener la version y Service Pack:

   1:  using Microsoft.Win32;

   2:  ...   

   3:  ...

   4:  const string name = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v2.0.50727\";

   5:     

   6:  RegistryKey subKey = Registry.LocalMachine.OpenSubKey(name);

   7:     

   8:  var version = subKey.GetValue("Version").ToString();

   9:  var servicePack = subKey.GetValue("SP").ToString();

Hay mas información en esta pregunta de StackOverflow :

http://stackoverflow.com/questions/199080/how-to-detect-what-net-framework-versions-and-service-packs-are-installed

Test

Esto es una prueba.

Prueba de codigo:

   1:  1:  //Crea respaldo del archivo de entrada, especificando el nombre del respaldo

   2:  2:  private void CrearArchivoRespaldo(string archivoRespaldo)

   3:  3:  {

   4:  4:      //..

   5:  5:  }