Hola de nuevo
En esta ocasión quiero comenzar con una serie de ejemplos que muestren cómo se debe escribir buen código en las aplicaciones. Es decir, tener en cuenta los recursos de la máquina en la que se van a ejecutar nuestras aplicaciones, ya que aunque hoy en dia el hardware nos favorece en gran medida nuestras metidas de pata con el software, en cualquier momento nuestras aplicaciones se van a ver seriamente afectadas en rendimiento, y por lo tanto llegar a causar errores o el serio aburrimiento de nuestros usuarios.
Utilizar propiedades en nuestras aplicaciones es mi primer recomendado:
1. No más variables públicas, no más métodos al estilo get y set.
2. Las propiedades son el mejor remedio para la encapsulación, si señores ellas exponen nuestros miembros de datos como parte de una interfaz pública.
3. Las propiedades nos permiten acceder nuestras variables y al mismo tiempo manipular su comportamiento, ya que las propiedades utilizan métodos.
4. Escribiendo propiedades tenemos acceso en un solo punto, para cambiar, o agregar funcionalidad según lo necesitemos. Por ejemplo, si decidimos que nuestro cliente no deberá aceptar nombres en blanco podemos hacer lo siguiente:
public class Customer
{
private string _name;
public string Name
{
get
{
return _name;
}
set
{
if (( value == null ) ||
( value.Length == 0 ))
throw new ArgumentException( "Name cannot be blank",
"Name" );
_name = value;
}
}
// ...
}
Con esto ya no tenemos el problema causado por las variables públicas, donde tendríamos que buscar en cada lugar de nuestro mar de código, donde esa variable se utilizó para hacer algo similar en muchas partes del código.
5. Adicionar manejo de hilos es mucho más sencillo, o si no que lo diga el ejemplo:
public string Name
{
get
{
lock( this )
{
return _name;
}
}
set
{
lock( this )
{
_name = value;
}
}
}
6. Ya que técnicamente las propiedades son métodos, estas heredan todas sus características, por ejemplo poder ser virtuales:
public class Customer
{
private string _name;
public virtual string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
// remaining implementation omitted
}
Propiedades abstractas, o quiza ser parte de una definición de interfaces:
public interface INameValuePair
{
object Name
{
get;
}
object Value
{
get;
set;
}
}
7. En C# 2.0 podemos establecer diferentes modificadores de acceso para los métodos get y set de nuestras propiedades. Por ejmplo, esto es válido:
// Legal C# 2.0:
public class Customer
{
private string _name;
public virtual string Name
{
get
{
return _name;
}
protected set
{
_name = value;
}
}
// remaining implementation omitted
}
8. Igualmente el uso de indexadores en las propiedades es permitido, haciendo de esto algo muy poderoso:
public int this [ int index ]
{
get
{
return _theValues [ index ] ;
}
set
{
_theValues[ index ] = value;
}
}
// Accessing an indexer:
int val = MyObject[ i ];
9. La legibilidadd del código es una ventaja más, ya que accedemos a nuestros miembros de clases utilizando nombres significativos y fáciles de entender para asignar u obtener la data.
string name = customerOne.Name;
customerOne.Name = "This Company, Inc.";
Esto y otras consideraciones son muy importantes, y nos pueden ahorrar dolores de cabeza más adelante. Les queda de tarea analizar por ejemplo qué ocurre con el MSIL generado para nuestras propiedades. Y finalmente decilres que a nivel de desempeño, entre propiedades y métodos normales que accedan campos públicos, aunque estos últimos pudieran en algun momento dado ser más rápidos, la verdad es que el comportamiento inline de los métodos definidos para las propiedades, hace que el JIT o el compilador justo a tiempo del Framework, ponga a la par en rendimiento las diferentes técnicas. No olviden, los miembros deben ser privados y nuestras propiedades serán los puntos por los cuales accedemos y modificamos la información de dichos miembros.
Feliz buena práctica!!
