Hemos visto en conceptos anteriores que normalmente definimos una propiedad para acceder a un atributo o campo de la clase. En muchas situaciones podemos agregar código en el momento de la asignación o cuando recuperamos el valor de la propiedad.
Pero hay situaciones donde definimos un atributo y luego una propiedad que accede a dicho atributo y no definimos ningún algoritmo tanto en la sección del get como del set. En estos casos nos cuestionamos el porque no definir public el atributo y no definir una propiedad para accederlo. Debido a estos casos en C# se ha agregado la posibilidad de definir propiedades automáticas.
Una propiedad automáticas crea en forma transparente un atributo donde se almacena el valor y posteriormente se consulta.
Veamos un ejemplo como definimos una propiedad en la forma tradicional y como la definimos con esta técnica.
Problema 1:
Plantear una clase llamada Cuadrado definir una propiedad llamada Lado. Calcular la superficie.
Veamos primero el código que ya conocemos para la definición de un atributo y la propiedad que la accede:
Programa:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Propiedades1
{
class Cuadrado
{
private int lado;
public int Lado
{
set
{
lado = value;
}
get
{
return lado;
}
}
public int RetornarSuperficie()
{
return Lado * Lado;
}
}
class Program
{
static void Main(string[] args)
{
Cuadrado cuadrado1 = new Cuadrado();
cuadrado1.Lado = 30;
Console.WriteLine("Su superficie es:" + cuadrado1.RetornarSuperficie());
Console.ReadKey();
}
}
}
Hemos definido el atributo o campo llamado 'lado':
private int lado;
Definimos la propiedad 'Lado' que solo fija o recupera el atributo:
public int Lado
{
set
{
lado = value;
}
get
{
return lado;
}
}
Veamos la sintaxis que reduce la cantidad de líneas que debe escribir el programador para los casos en que una propiedad tiene el objetivo de fijar y recuperar el valor de un atributo:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Propiedades1
{
class Cuadrado
{
public int Lado { get; set; }
public int RetornarSuperficie()
{
return Lado * Lado;
}
}
class Program
{
static void Main(string[] args)
{
Cuadrado cuadrado1 = new Cuadrado();
cuadrado1.Lado = 30;
Console.WriteLine("Su superficie es:" + cuadrado1.RetornarSuperficie());
Console.ReadKey();
}
}
}
Como podemos ver podemos definir una propiedad automática con la sintaxis:
public int Lado { get; set; }
El compilador se encarga de crear un atributo del mismo tipo de la propiedad 'Lado'.
Podemos definir modificadores de acceso para el get y el set, por ejemplo la sintaxis:
public int Lado { private get; set; }
No permite extraer el valor de la propiedad desde fuera de la clase, por ejemplo sería un error la siguiente sintaxis:
class Program
{
static void Main(string[] args)
{
Cuadrado cuadrado1 = new Cuadrado();
cuadrado1.Lado = 30;
//La siguiente línea genera un error de compilación ya que Lado define el 'get' en forma privada
int x = cuadrado1.Lado;
Console.WriteLine("Su superficie es:" + cuadrado1.RetornarSuperficie());
Console.ReadKey();
}
}
Dentro de la clase no hay problema de acceder a la propiedad 'Lado' por más que sea private:
public int RetornarSuperficie()
{
return Lado * Lado;
}
En la última versión de C# se permite inicializar la propiedad automática con un valor cuando se la define, en lugar de tener que hacerlo en el constructor:
public int Lado { get; set; } = 10;
Acotaciones
El editor Visual Studio tiene herramientas que nos permiten transformar el código a una propiedad automática, si posicionamos el cursor en la línea donde se define el atributo aparece un ícono a la izquierda donde podemos ver los cambios que nos propone el editor implementar en forma automática:
Luego de esta acción vemos que tenemos el código fuente de nuestro programa modificado con una propiedad automática:
