November 2009 - Artículos

Hola a todos! Finalmente tuve el placer de dar no una, sino dos sesiones en las ALM Sessions 09. No era la idea inicial, pero mi compañero Juan Carlos finalmente no pudo dar la de Surface, así que la di yo (y es que por suerte o por desgracia me encanta hablar).

La primera sesión fue precisamente la de Surface, en el track de Diseño y UX. La intención inicial era haber traído la surface que tenemos en raona, pero por temas logísticos fue imposible… Así que tuve que dar una presentación sobre Surface sin Surface que es como una noche de fiesta sin lig… esto, que le falta algo, vamos. Intenté explicar un poco que es la Surface, y el cambio de paradigma que supone desarrollar para ella. Mostré el emulador que viene con el SDK de Surface (que os animo a todos a probar) y vimos algunos de los controles de dicho SDK. Finalmente exploramos el futuro que nos espera con WPF 4 unificando la programación multi-touch en Surface y en Windows 7.

La segunda sesión, en el track de arquitectura, versó sobre TDD. Intenté explicar que es TDD, pero sobre todo por que usar TDD sin entrar en detalles sobre el como hacer pruebas unitarias (lo que daria para varias sesiones). Luego mencioné los pequeños cambios que trae VS2010 para hacernos llevadera la tarea de realizar TDD (recordad las sabias palabràs del Capità Enciam: los pequeños cambios son poderosos) y empecé a desarrollar una clase usando TDD, intentando hacer énfasis en los pensamientos que uno tiene gracias a usar TDD. Me quedé un poco corto de tiempo y tambien me comentaron que la combinación de colores que tengo en mi VS2010 será muy cómoda para programar pero muy mala para proyectar… Disculpas por si no pudisteis ver bien el código por culpa de los colores :(

 

En fin, que más puedo deciros: yo me lo pasé en grande durante todo el evento: dando sesiones, escuchándolas, hablando y conociendo a gente… ah si! y también comiendo y bebiendo jejejee… :)

Os dejo las presentaciones de ambas sesiones.

Un saludo y nos vemos en la próxima movida!!! ;)

con no comments
Archivado en: ,,,

Una capacidad de la que no se habla mucho es de TxF, que apareció junto con Vista: es la capacidad de tener transacciones sobre ficheros NTFS. Esas transacciones pueden afectar a uno o a varios ficheros… y no solo eso: gracias al poder de DTS podemos coordinar una transaccion TxF con otros tipos de transacciones como SQL Server o MSMQ!

Como pasa con muchas de las características avanzadas de windows, sólo se puede usar en .NET a través de p/invoke (si obviamos C++/CLI claro)… vamos a ver un ejemplo!

Primero creamos una clase que contenga todas las definiciones de los métodos Win32 que vamos a usar:

public static class NativeMethods
{
public const uint GENERIC_READ = 0x80000000;
public const uint GENERIC_WRITE = 0x40000000;
[DllImport("kernel32.dll", SetLastError = true)]
public static extern SafeFileHandle CreateFileTransacted(string lpFileName,
uint dwDesiredAccess, uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition,
uint dwFlagsAndAttributes, IntPtr hTemplateFile, IntPtr hTransaction, IntPtr pusMiniVersion,
IntPtr pExtendedParameter);

[DllImport("ktmw32.dll", SetLastError = true)]
public static extern IntPtr CreateTransaction(IntPtr lpTransactionAttributes, IntPtr uow,
uint createOptions, uint isolationLevel, uint isolationFlags, uint timeout, string description);

[DllImport("ktmw32.dll", SetLastError = true)]
public static extern bool CommitTransaction(IntPtr transaction);

[DllImport("ktmw32.dll", SetLastError = true)]
public static extern bool RollbackTransaction(IntPtr transaction);

[DllImport("Kernel32.dll")]
public static extern bool CloseHandle(IntPtr handle);
}

Vamos a usar los siguientes métodos del api de Win32:

  • CreateFileTransacted: Crea o abre un fichero para ser usado de forma transaccional. Una vez obtenido el handle, el resto de funciones win32 que trabajan con handles funcionan transaccionalmente con el nuevo handle.
  • CreateTransaction: Crea la transaccion
  • CommitTransaction: Hace el commit de la transaccion 
  • RollbackTransaction: Hace el rollback de la transacción
  • CloseHandle: Cierra un handle cualquiera (sea de fichero o no y sea transaccional o no).

Vamos a hacer un programilla que abra dos ficheros en modo transaccional, escriba algo en ellos y luego haga commit y/o rollback de la transacción para ver sus efectos…

Primero creamos la transacción y abrimos dos ficheros (suponemos que los nombres nos los pasarán por línea de comandos):

// 1. Crear la transacción
IntPtr transaction = NativeMethods.CreateTransaction(IntPtr.Zero, IntPtr.Zero, 0, 0, 0, 0, null);
// 2. Abrir dos ficheros de forma transaccional
SafeFileHandle sfh1 = NativeMethods.CreateFileTransacted(args[0], NativeMethods.GENERIC_READ | NativeMethods.GENERIC_WRITE,
0, IntPtr.Zero, (uint)FileMode.CreateNew, 0, IntPtr.Zero, transaction, IntPtr.Zero, IntPtr.Zero);
SafeFileHandle sfh2 = NativeMethods.CreateFileTransacted(args[1], NativeMethods.GENERIC_READ | NativeMethods.GENERIC_WRITE,
0, IntPtr.Zero, (uint)FileMode.CreateNew, 0, IntPtr.Zero, transaction, IntPtr.Zero, IntPtr.Zero);

Una vez tenemos los handles cualquier función Win32 estándard para escribir o leer en ellos nos serviría… por suerte los file streams de .NET pueden ser creados a partir de un handle de Win32, así que podremos utilizar la clase FileStream.

Ahora ya sólo nos queda hacer un commit o un rollback… Para ello si se produce cualquier error durante la escritura haremos un rollback, y en caso contrario haremos un commit. Finalmente debemos cerrar la transacción y por ello usaremos CloseHandle.

El código es tal y como sigue:

try
{
// Escribimos algo en ambos ficheros
using (FileStream f1 = new FileStream(sfh1, FileAccess.ReadWrite))
using (FileStream f2 = new FileStream(sfh2, FileAccess.ReadWrite))
using (StreamWriter sw1 = new StreamWriter(f1))
using (StreamWriter sw2 = new StreamWriter(f2))
{
sw1.Write("Fichero 1");
if (args.Length > 2 && args[2] == "/e")
throw new IOException("Error cualquiera");
sw2.Write("Fichero 2");
}

// Lanzamos el commit. Si todo ha ido bien llegaremos aquí
NativeMethods.CommitTransaction(transaction);
}
catch (IOException ex)
{
// Algun error: lanzamos el rollback
Console.WriteLine("Error en el acceso a ficheros:" + ex.Message);
NativeMethods.RollbackTransaction(transaction);
}
finally
{
// Cerramos la transacción TxF
NativeMethods.CloseHandle(transaction);
}

Como se puede observar la escritura en los ficheros se hace a través de las clases estándard de .NET. Es solo la apertura del fichero que debe hacerse a través de la API de Win32, así como la creación de la transacción.

Si el tercer parámetro que se le pasa al programa es /e el programa simulará un error.

Si ejecutais el programa TxFDemo.exe f1.txt f2.txt vereis que os aparecen los dos ficheros.

Por otro lado si ejecutais TxFDemo f1.txt f2.txt /e vereis que NO os aparece ninguno de los dos ficheros, ya que se lanza la excepción y con ella se hace un rollback de la transacción NTFS.

Ahora imaginad las posibilidades que este sistema ofrece!

Eso sí recordad que es para Windows Vista o superior…

Link: Un artículo sobre TxF bastante interesante de Jason Olson.

Saludos!

con 1 comment(s)
Archivado en: ,

Hola a todos!! Este año tengo el placer de realizar una presentación en las ALM Sessions’09.

En concreto hablaré sobre Test Driven Development: que és, como su uso junto con otras buenas prácticas de desarrollo puede ayudarnos a ganar en calidad y como podemos implantarlo en un equipo de desarrollo.

También veremos que herramientas trae Visual Studio 2010 y como nos pueden ayudar a realizar de forma más sencilla TDD.

Os recomiendo que los que podais os paseis por Madrid este 24 de Noviembre, porque vale la pena. Si el año pasado las sesiones fueron buenas este año todavía más porque hay hasta 6 tracks simultáneos: Procesos, Calidad y testing, Herramientas, Arquitectura, Diseño/UX y Plataforma de aplicaciones. Si veis la agenda observaréis la gran cantidad de temas que se tratan. Es casi imposible no encontrar ninguno de vuestro interés!

Un saludo y nos vemos por allí!!!

image

con no comments
Archivado en: ,