martes, 31 de julio de 2007

Campaña MasFoxPro

Yo aprendí a programar con Visual Basic 6, pero cuando empecé a trabajar programando, que son cosas muy distintas, fue con Visual FoxPro 6. Vamos, que me ha dado de comer muchos años, y también es el "culpable" de que esté en Barcelona.

Y aunque he tardado un poco en hacerlo, me he unido a la campaña MasFoxPro para pedirle a Microsoft que siga con el desarrollo de Visual FoxPro o, si no le resulta rentable o no entra en sus planes de negocio, lo libere para que la comunidad de desarrolladores de FoxPro lo haga.

Y seguro que lo harán encantados, porque comunidades como PortalFox, Foxite, CodeFox, y muchas otras, llevan muchos años ayudando a que programar con VFP sea más fácil, y haciendo el trabajo que Microsoft no está interesada en hacer, como traducir el IDE de VFP al castellano y sacar herramientas de informes o reparación de bases de datos.

Así que ya sabes, si alguna vez has trabajado con Visual FoxPro, por favor, únete a la causa.


PD: este post va por la gente que he conocido gracias a VFP, Suso, Leo, Eva, Juanji, Elena, Samu, Juan Carlos, Mercè, Merce, Josep, Humi, Manel, Pere, Xavi Rubio, los Javeros de Costaisa, Ade, Icu, Jose, Xavi, Joaquín, y todos los demás con los que he trabajado y que me deben perdonar por mi mala memoria al recordar los nombres pero de los que no me olvido.

sábado, 28 de julio de 2007

Code Snippets (II)

Trasteando con los code snippets

Como vimos en el anterior post, los code snippets ayudan a escribir código, y el Visual Studio incluye una gran cantidad de ellos, vamos a ver cómo encontrarlos.
Seleccionamos Herramientas -> Code Snippets Manager, y nos muestra la siguiente ventana:



Seleccionamos el lenguaje que estemos utilizando, y nos actualiza las categorías que trae por defecto, si os fijáis existe la categoría My Code Snippets para incluir los que creemos.

Bien, vamos a buscar el code snippet que utilizamos en el post anterior:



Si echáis un vistazo a todas las categorías y los code snippets que se incluyen podéis ver que están contempladas muchas acciones comunes, pero ¿qué pasa si no encontramos el code snippet que nos hace falta? Pues aquí tenemos 2 opciones:

- Modificar uno existente para que incluya un cambio o crear uno nuevo a partir de uno existente
- Buscar code snippets que alguien haya creado

Modificar un code snippet existente

Si nos fijamos en la imagen anterior, al seleccionar un code snippet nos muestra dónde está, en este caso el que define una propiedad se encuentra en C:\Archivos de programa\Microsoft Visual Studio 8\Vb\Snippets\1033\common code patterns\properties and procedures\DefineAProperty.snippet.

Con esta ruta podemos ver un par de cosas: que cada code snippet se guarda en un fichero .snippet y las colecciones están agrupadas en directorios, por lo que la agrupación física y la lógica coinciden.

Vamos a modificar este snippet para que el tipo de la propiedad siempre sea string. Abrimos el fichero DefineAProperty.snippet con el Visual Studio (o con el bloc de notas), y podemos observar la estructura de un code snippet sencillo:


<?xml version="1.0" encoding="UTF-8"?>
<CodeSnippets mlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
<Header>
<Title>Define a Property</Title>
<Author>Microsoft Corporation</Author>
<Description>Defines a Property with a backing field.</Description>
<Shortcut>Property</Shortcut>
</Header>
<Snippet>
<Declarations>
<Literal>
<ID>PropertyName</ID>
<Type>String</Type>
<ToolTip>Replace with property name.</ToolTip>
<Default>NewProperty</Default>
</Literal>
<Literal>
<ID>PropertyType</ID>
<Type>
</Type>
<ToolTip>Replace with the property type.</ToolTip>
<Default>Integer</Default>
</Literal>
<Object>
<ID>PrivateVariable</ID>
<Type>Object</Type>
<ToolTip>Replace this with the private variable name.</ToolTip>
<Default>newPropertyValue</Default>
</Object>
</Declarations>
<Code Language="VB" Kind="method decl">
<![CDATA[
Private $PrivateVariable$ As $PropertyType$
Public Property $PropertyName$() As $PropertyType$
Get
Return $PrivateVariable$
End Get
Set(ByVal value As $PropertyType$)
$PrivateVariable$ = value
End Set
End Property
]]>
</Code>
</Snippet>
</CodeSnippet>
</CodeSnippets>


Vaya si es XML. ¿Qué más podemos ver?
Que hay una cabecera Header donde poner los datos del creador del code snippet, su descripción y el ShortCut o alias del code snippet.
Que hay un elemento Declarations donde se definen los literales del code snippet (los que se muestran en un cuadrado verde) y se especifica el texto que se debe mostrar cuando se pase el ratón sobre él.
Y que hay un elemento Code, que es donde se está el código que va a aparecer cuando introduzcamos un snippet. Aquí podemos ver los literales que se defienen arriba y se deben reemplazar por el nombre de la variable o el tipo de dato.

Parece fácil, así que vamos a hacer una pequeña modificación para que la propiedad siempre sea de tipo String, para ello tenemos que comentar el literal PropertyType y en el elemento Code poner en su lugar String, algo así:


<?xml version="1.0" encoding="UTF-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
<Header>
<Title>Define a string Property</Title>
<Author>bousan</Author>
<Description>Defines a string Property with a backing field.</Description>
<Shortcut>SProperty</Shortcut>
</Header>
<Snippet>
<Declarations>
<Literal>
<ID>PropertyName</ID>
<Type>String</Type>
<ToolTip>Replace with property name.</ToolTip>
<Default>NewProperty</Default>
</Literal>
<!--<Literal>
<ID>PropertyType</ID>
<Type>
</Type>
<ToolTip>Replace with the property type.</ToolTip>
<Default>Integer</Default>
</Literal>-->
<Object>
<ID>PrivateVariable</ID>
<Type>Object</Type>
<ToolTip>Replace this with the private variable name.</ToolTip>
<Default>newPropertyValue</Default>
</Object>
</Declarations>
<Code Language="VB" Kind="method decl">
<![CDATA[
Private $PrivateVariable$ As string
Public Property $PropertyName$() As string
Get
Return $PrivateVariable$
End Get
Set(ByVal value As string)
$PrivateVariable$ = value
End Set
End Property
]]>
</Code>
</Snippet>
</CodeSnippet>
</CodeSnippets>


Como se puede ver, he cambiado el shorcut, la descripción, he comentado el literal PropertyType y lo he sustituido en el elemento Code por string.

Ahora tenemos 2 opciones: guardarlo con en el mismo fichero que estaba, lo cual no es muy recomendable porque no siempre vamos a querer crear propiedades de tipo string, o guardarlo en un fichero diferente, por ejemlplo DefineAStringProperty.snippet, que es lo que vamos a hacer.
Si volvemos al Code Snippet Manager podemos encontrar el snippet que acabamos de crear.

También podemos crear un snippet desde cero y añadirlo a una de las carpetas que ya están registradas por el Code Snippet Manager.


Buscar code snippets

Como yo sé que no soy el único programador del universo siempre que se me plantea un problema, y antes de empezar a devanarme los sesos, busco en Internet si alguien tuvo el mismo problema y ha encontrado una solución. Con los code snippets ocurre lo mismo, hay muchos en diferentes webs que han sido creados por otros programadores que posiblemente se han encontrado en la misma situación que nosotros. Sólo hay que poner "code snippet" en vuestro buscador favorito (el mío es Google, por si alguien lo quiere saber) y tener un poco de suerte.

Una vez que encontremos el snippet que nos hace falta, creamos un fichero .snippet y lo copiamos en él. Si el fichero está en uno de los directorios que están referenciados en el Code Snippet Manager, el nuevo snippet aparecerá en la lista de los existentes. Pero si lo creamos en otro directorio, por ejemplo uno de red para que puedan acceder todos los programadores de un grupo de trabajo, hay que añadir ese directorio al Code Snippet Manager, aunque lo más fácil es mantener la estructura lógica que ya nos presenta Visual Studio.

Casi se me olvida, en MSDN podéis encontrar un editor de Code Snippets en Visual Basic, para no tener que pelearos con el XML.

Y con esto finalizan los posts sobre Code Snippets, por ahora, porque prometo más.

domingo, 22 de julio de 2007

Code snippets (I)

¿Qué son y para qué sirven?

Visual Studio 2005 tiene un par de novedades que hacen que la tarea de escribir código sea un poco menos pesada. Una de estas novedades son los code snippets.

Según MSDN son: "bloques de código reusables orientados a tareas". Vaya definición, así que vamos a poner un ejemplo para que se pueda ver más claro. Si programando en C# tenemos que crear una propiedad dentro de una clase tendremos que escribir algo parecido a esto:


private string _miPropiedad;

public string miPropiedad
{
get
{
return _miPropiedad;
}

set
{
_miPropiedad = value;
}
}


Bien, esto son 19 palabras (sí, las he contado), y unos 150 caracteres, y sólo para una propiedad. Imaginaos si hay que escribir una clase con 50 o 100 propiedades, la cantidad de tiempo que te puede llevar. ¿Y no habrá en algo en Visual Studio para ayudarnos? Pues esto es lo que hacen los code snippets.

Vamos a usar este mismo ejemplo y usar un code snippet para ver lo fácil que es. Escribimos “prop” y el Intellisense (si lo tenemos activado) nos muestra lo siguiente:


Si presionamos TAB, ocurrirá lo siguiente:


Podemos observar que aparece en un rectángulo verde el tipo de variable asociada a la propiedad, el nombre de esa variable y el nombre de la propiedad. Como se puede suponer, al cambiar el tipo de dato de la variable automáticamente se cambia el tipo de dato de la propiedad.
Para movernos entre los diferentes elementos que se pueden cambiar hay que presionar la tecla TAB y para volver al elemento anterior con Shift + TAB, y cuando finalicemos de modificar este código y tengamos la propiedad que deseamos sólo hay que pulsar ENTER para seguir con el resto del código.

Para obtener el primer fragmento de código de este post, tendremos que escribir: string (una sola vez), _miPropiedad, y miPropiedad. En total son 4 palabras y unos 33 caracteres. Vaya cambio, ¿no?

Pues esto es un code snippet, un fragmento de código que se activa con Intellisense mediante un “alias” que tiene cada snippet.

¿Y en VB.NET? Pues es algo parecido, puesto que después de escribir el alias o identificador del code snippet hay que poner un “?”, con lo que tenemos prop? y presionar TAB.

Hay otra forma de insertar un snippet es presionando el botón derecho en la ventana de código y eligiendo la opción de Insertar Snippet, con lo que tenemos:


Además Visual Studio nos permite modificar los snippets existentes o crear unos nuevos, pero eso será tema par otro post.

lunes, 16 de julio de 2007

Control de concurrencia pesimista en ADO.NET (VB.NET)

Como lo prometido es deuda, aquí esta el código en VB.NET del anterior artículo


Imports System
Imports System.Text
Imports System.Data
Imports System.Data.SqlClient

Namespace BloqueoPesimista

Module Module1

Sub Main()
Dim ds As DataSet = New DataSet()
Dim conexion As SqlConnection = New SqlConnection()
Dim transaccion As SqlTransaction
Dim comando As SqlCommand = New SqlCommand()
Dim da As SqlDataAdapter = New SqlDataAdapter()

Console.WriteLine("Pulse una tecla para iniciar...")
Console.ReadKey()

Try
' La cadena de conexión indica que atacamos a la base de datos Northwind del servidor local
conexion = New SqlConnection("Data Source=.;Initial Catalog=Northwind;Integrated Security=True")

comando.Connection = conexion
comando.CommandType = CommandType.Text

' El SELECT tiene un parámetro para evitar SQL Injection
comando.CommandText = "SELECT ProductID, ProductName FROM Products WITH (Rowlock,Xlock) " & _
"WHERE ProductID = @ID"
comando.Parameters.AddWithValue("@ID", 1)
da.SelectCommand = comando

'Abrimos la conexión y ejecutamos en comando
'Nota: también se puede hacer con la sentencia Using() que nos evita abrir y cerrar la conexión
conexion.Open()

' La transacción no tiene constructor, se crea a partir de la conexión a través de un Class Factory
transaccion = conexion.BeginTransaction(IsolationLevel.ReadCommitted)

' Una vez creada la transacción la asignamos al comando
comando.Transaction = transaccion

' Ejecutamos el comando mediante el SQLDataAdapter
da.Fill(ds, "Products")

' Mostramos el registro bloqueado
Console.WriteLine("Registro con ProductID = {0} está bloqueado.", ds.Tables("Products").Rows(0)("ProductID"))

Console.WriteLine("Pulse una tecla para finalizar el bloqueo...")
Console.ReadKey()

' Finalizamos la transacción, aquí ya se deshace el bloqueo
transaccion.Rollback()

' Cerramos la conexión
conexion.Close()

Catch ex As Exception
If conexion.State <> ConnectionState.Closed Then
conexion.Close()
End If

Console.WriteLine(ex.Message)
Console.ReadKey()

End Try

End Sub

End Module

End Namespace

viernes, 13 de julio de 2007

Control de concurrencia pesimista con ADO.NET (C#)

Esta es la primera entrada seria del blog, después de la presentación, así que espero que me salga bien.

El tema a tratar es el control pesimista en ADO.NET como solución para la concurrencia entre varios usuarios al acceder a un mismo registro de una tabla. El caso concreto que voy a tratar corresponde a una base de datos SQL Server. Para otro tipo de bases de datos existen otras soluciones.

Para los que no conozcáis como maneja la concurrencia ADO.NET tenéis una introducción en este blog, o en esta entrada de MSDN.

En este post vamos a tratar el caso de la concurrencia pesimista, esto es, cuando un usuario accede a un registro éste quedará bloqueado para los demás usuarios que tengan acceso a la base de datos.

Para que os hagáis una idea de por donde van los tiros, se trata de especificarle a SQL Server que queremos bloquear un registro mientras estamos en una transacción.

¿Cómo se hace?

Vayamos por partes, lo primero que tengo que explicar es que en SQL Server existe una instrucción en la sentencia SELECT para que bloquee un registro cuando lo leemos. Esta instrucción se conoce como Table Hint y lo que hace es indicarle al optimizador de consultas (query optimizer) el método de bloqueo de la tabla o vista.

Por emplo: SELECT * FROM MiTabla WITH(Rowlock, Xlock) WHERE id = 10;

Rowlock -> fuerza el bloqueo de los registros que devuelva la instrucción.
Xlock -> indica que el bloqueo es exclusivo.

Y esta sentencia SELECT la tenemos que iniciar con una transacción abierta. El bloqueo existe mientras la transacción esté en curso, por tanto, hasta que no se finalice la transacción (Commit o Rollback), se salga de su alcance o se cierre la conexión, el bloqueo permanecerá activo. Para que el bloqueo sea efectivo el nivel de asilamiento de la transacción (isolationLevel) puede ser ReadCommitted, ReadUnCommitted, RepetableRead o Serializable, no aceptandose Chaos, ni SnapShot, ni Unspecified.



El código

Seguro que viendo el código lo entenderéis mejor de que va todo esto, así que aquí lo tenéis:




using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;

namespace BloqueoPesimista
{
class Program
{
static void Main(string[] args)
{

DataSet ds = new DataSet();
SqlConnection conexion = new SqlConnection();
SqlTransaction transaccion;
SqlCommand comando = new SqlCommand();
SqlDataAdapter da = new SqlDataAdapter();

Console.WriteLine("Pulse una tecla para iniciar...");
Console.ReadKey();

try
{

// La cadena de conexión indica que atacamos a la base de datos Northwind del servidor local
conexion = new SqlConnection("Data Source=.;Initial Catalog=Northwind;Integrated Security=True");

comando.Connection = conexion;
comando.CommandType = CommandType.Text;

// El SELECT tiene un parámetro para evitar SQL Injection
comando.CommandText = "SELECT ProductID, ProductName FROM Products WITH (Rowlock,Xlock) " +
"WHERE ProductID = @ID";
comando.Parameters.AddWithValue("@ID", 1);
da.SelectCommand = comando;

//Abrimos la conexión y ejecutamos en comando
//Nota: también se puede hacer con la sentencia Using() que nos evita abrir y cerrar la conexión
conexion.Open();

// La transacción no tiene constructor, se crea a partir de la conexión a través de un Class Factory
transaccion = conexion.BeginTransaction(IsolationLevel.ReadCommitted);

// Una vez creada la transacción la asignamos al comando
comando.Transaction = transaccion;

// Ejecutamos el comando mediante el SQLDataAdapter
da.Fill(ds, "Products");

// Mostramos el registro bloqueado
Console.WriteLine("Registro con ProductID = {0} está bloqueado.", ds.Tables["Products"].Rows[0]["ProductID"]);

Console.WriteLine("Pulse una tecla para finalizar el bloqueo...");
Console.ReadKey();

// Finalizamos la transacción, aquí ya se deshace el bloqueo
transaccion.Rollback();

// Cerramos la conexión
conexion.Close();
}
catch (Exception e)
{
if (conexion.State != ConnectionState.Closed)
conexion.Close();

Console.WriteLine(e.Message);
Console.ReadKey();
}
}
}
}



Se trata de una aplicación de consola en C#, en un futuro post pondré el código en VB.NET. Así que sólo hay que copiarlo en un proyecto de consola.


Vamos a probarlo

Para poder pobrarlo, hay que Generar el proyecto, con lo que nos creara un fichero .EXE en la carpeta Bin/Debug del proyecto.
Ejecutamos el exe una vez y pulsamos una tecla para que se inicie el bloqueo.







Si volvemos a ejecutar el exe e iniciamos el bloqueo, la aplicación se quedará esperando que se libere el registro.






En cuanto finalicemos la primera ejecución, la segunda podrá acceder al registro y bloquearlo.


Y con esto finalizamos por hoy. Para ser la primera entrada me ha quedado un poco larga, pero espero que pueda ayudar a cualquiera de los que la lean.

Cualquier duda o sugerencia, por favor, en los comentarios.


PD: ¿Es el control de concurrencia pesimista la mejor opción? En absoluto, pero para algún caso en concreto puede ser LA SOLUCIÓN. Queda a vuestro criterio el usarlo o no.

jueves, 12 de julio de 2007

Presentación

Sed todos bienvenidos a esta aventura en forma de blog.

Antes de nada me presento, me llamo Pablo y trabajo como programador en la central de MRW de Barcelona. Aunque soy gallego llevo varios años vivendo en tierras catalanas y disfrutando de su clima (los gallegos que viváis en Barcelona ya me entendéis) y de su gente.

El principal motivo para crear este blog es poder compartir con la comunidad de programadores mis experiencias en el desarrollo de aplicaciones en .NET, y así ayudar a los que se encuentren con algún problema con el que ya me he peleado, o con los que me esté peleando. Sí, peleando porque cualquiera que haya programado sabe que con las aplicaciones te peleas, bueno, más bien te peleas con la tecnología por que no consigues que haga lo que pretendes o no hace lo que debería hacer.

No me considero ningún experto, sólo soy alguien que tiene la suerte de trabajar en lo que le gusta y disfruta de su trabajo, y que quiere aportar su pequeño granito de arena a la comunidad.

¿Por qué sobre .NET?
Esta pregunta tiene una respuesta muy fácil: porque es con lo que trabajo a diario (es lo que me da de comer) y es lo que más conozco. No voy a entrar en si .NET es mejor o peor que Java o que Ruby o que X o que Y. Yo sólo puedo hablar sobre lo que conozco, y como casi toda mi experiencia profesional se ha basado en .NET sería un poco absurdo si hablase sobre otro lenguaje.

También podría hablas sobre Visual Fox Pro o sobre Visual Basic 6.0, que es con lo que empecé a programar, pero como los tengo un poco abandonados no creo que aportase demasiado.

Pero que yo hable sobre .NET no quita que en este blog se acepten aportaciones sobre cualquier tema (relacionado con la programacióno la informática, claro) de cualquiera. Estaré encantado de que me enviéis cosas para publicar o añadir un link a vuestro blog.


Lo dicho, sed todos bienvenidos.


Actualización 18/07/2007: la postdata me quedó un poco borde, así que mejor la quito. Podéis poner lo que queráis en los comentarios que ya lo moderaré cuando tenga tiempo.