La mayoría de los tipos de datos conocimos como primitivos de C# son estructuras.
Cuando usamos int, long, float, etc. utilizamos alias para un manejo más simple de las estructuras, System.Int32, System.Int64 y System.Single. Estas estructuras tienen campos y métodos, por ejemplo el método ToString, que convierte el número en su representación en cadena.
Al usar Visual Studio podemos observar como los tipos de datos primitivos son definidos como estructuras, como se ve en la siguiente imagen.
Un importante método estático de estos tipos de datos es Parse, utilizado para convertir una cadena a su valor numérico correspondiente, por ejemplo:
En este ejemplo usamos el alias int para declarar las variables de tipo numérico.
Estas estructuras ademas tienen algunos campos de tipo estático que son útiles, por ejemplo, Int32.MaxValue que representa al máximo valor posible a almacenar en un tipo de valor int.
La siguiente tabla presenta los alias y su equivalente del .NET Framework. Observe que string y object son clases.
Para declarar una estructura se utiliza la palabra clave struct y delante de ella el nombre de la estructura.
Es posible definir los valores de los campos, proporcionando un constructor con parámetros, ya que el compilador crea el constructor por omisión sin parámetros. En una estructura no esa permitido colocar valores por omisión a los campos. Los campos definidos como estáticos tienen permitido colocar valores por omisión.
Si quiere copiar una estructura no inicializada el compilador no lo permite.
El GC (Garbage Collector) recupera la memoria usada para la declaración del tipo, de forma inmediata al salir del método donde fue declarada, ya que el tipo que es manejado en el stack.
Usando una estructura
Para el siguiente ejemplo he considerado usar una estructura para definir un tipo que podría usar como un tipo numérico con campos y métodos estáticos, los cuales pueden ser invocados sin tener que crear una instancia; además declaro métodos públicos que se pueden invocar una vez que se creo un tipo de la estructura; Estos métodos se pueden usar para realizar algunos cálculos. La estructura tienen el nombre InteresMensual, enseguida el código.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace UsandoStructuras
{
class Program
{
struct InteresMensual
{
public static float Minimo = 1f;
public static float Maximo = 100f;
// campos privados
private float _cantidad;
private float _interes;
/// <summary>
/// constructor con 1 parámetro
/// </summary>
/// <param name="interes"></param>
public InteresMensual(float interes)
{
this._interes = interes;
this._cantidad = 0;
}
/// <summary>
/// constructor con 2 parámetros
/// </summary>
/// <param name="interes"></param>
/// <param name="cantidad"></param>
public InteresMensual(float interes, float cantidad)
{
this._interes = interes;
this._cantidad = cantidad;
}
/// <summary>
/// Propiedad
/// </summary>
public float Cantidad
{
get { return _cantidad; }
set { _cantidad = value; }
}
/// <summary>
/// Propiedad
/// </summary>
public float Interes
{
get { return _interes; }
set { _interes = value; }
}
/// <summary>
/// Método estatico, que puede llamarse sin crear una instacia
/// de la estructura, no es posible usar los valores de las variables
/// que son manejados como propiedades, tampoco se puede usar la
/// palabra clave this para tener acceso a ellos porque el método es
/// estatico.
/// </summary>
/// <param name="cantidad"></param>
/// <returns></returns>
public static float CalculaInteresMinimo(float cantidad)
{
return (Minimo / 100) * cantidad;
}
/// <summary>
/// Método estatico, que puede llamarse sin crear una instacia
/// de la estructura, no es posible usar los valores de las variables
/// que son manejados como propiedades, tampoco se puede usar la
/// palabra clave this para tener acceso a ellos porque el método es
/// estatico.
/// </summary>
/// <param name="cantidad"></param>
/// <returns></returns>
public static float CalculaInteresMaximo(float cantidad)
{
return (Maximo / 100) * cantidad;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public float CalculaInteres()
{
return ( this._interes / 100) * this._cantidad;
}
/// <summary>
///
/// </summary>
/// <param name="interes"></param>
/// <returns></returns>
public float CalculaInteres(float interes)
{
this._interes = interes;
return (this._interes / 100) * this._cantidad;
}
/// <summary>
///
/// </summary>
/// <param name="interes"></param>
/// <param name="cantidad"></param>
/// <returns></returns>
public float CalculaInteres(float interes, float cantidad)
{
this._interes = interes;
this._cantidad = cantidad;
return (this._interes / 100) * this._cantidad;
}
}
static void Main(string[] args)
{
InteresMensual interesMensual = new InteresMensual(20);
Console.WriteLine("Interes mínimo mensual: {0}", InteresMensual.Minimo);
Console.WriteLine("Interes máximo mensual: {0}", InteresMensual.Maximo);
Console.WriteLine();
Console.WriteLine("Interes mínimo calculado : {0}", InteresMensual.CalculaInteresMinimo(100));
Console.WriteLine("Interes máximo calculado : {0}", InteresMensual.CalculaInteresMaximo(100));
Console.WriteLine();
InteresMensual otroInteres = new InteresMensual();
// acceso a propiedades, también es posible llamar a los
// constructores con parámetros.
otroInteres.Interes = 20f;
otroInteres.Cantidad = 100f;
Console.WriteLine("De la cantidad: {0} con interes de : {1} se paga mensual: {2} ",
otroInteres.Cantidad, otroInteres.Interes,
otroInteres.CalculaInteres());
Console.WriteLine("De la cantidad: {0} con interes de : {1} se paga mensual: {2} ",
otroInteres.Cantidad, 15f,
otroInteres.CalculaInteres(15));
Console.WriteLine("De la cantidad: {0} con interes de : {1} se paga mensual: {2} ",
otroInteres.Cantidad, otroInteres.Interes = 20,
otroInteres.CalculaInteres(20, 200));
}
}
}
Los siguientes puntos deben tenerse en mente al trabajar con estructuras
- Los constructores son opcionales, pero si se incluyen, estos deben usar parámetros. No podemos ni debemos crear un constructor por omisión -es decir sin parámetros - de eso se encarga el compilador.
- No se puede definir un valor por omisión para un campo en la declaración del mismo.
- A los campos se les puede dar valores solamente usando el constructor o bine después de que la estructura ya fue declarada.
- Los miembros privados pueden ser inicializados usando solamente el constructor.
- En necesario usar la palabra new para crear un tipo de una estructura.
- Si la estructura tienen un elemento de tipo referencia debe llamar al constructor del tipo de forma explicita.
Referencias libros:
Microsoft Visual C# Step by Step, editorial
MCSD Certification ToolKit (Exam 70-483)
No hay comentarios.:
Publicar un comentario