Estructura (Struct) de C#

　En C#, la estructura es un tipo de datos de valor de estructura de tipo de datos que representa una estructura de datos. Puede contener constructor parametrizado, constructor estático, constantes, campos, métodos, propiedades, índices, operadores, eventos y tipos anidados.

La estructura se puede usar para almacenar valores de datos pequeños que no requieren herencia, como puntos de coordenadas, pares clave-valor y estructuras de datos complejas.

Declaración de estructura

Se declara la estructura utilizando la palabra clave struct. El modificador predeterminado es el modificador interno de la estructura y sus miembros.

A continuación, se declara la estructura de la imagen de coordenadas.

struct Coordinate
{
　　　　public int x;
　　　　public int y;
}

struct Coordinate
{
　　　　public int x;
　　　　public int y;
}
Coordinate point = new Coordinate();
Console.WriteLine(point.x);　//Salida: 0　　
Console.WriteLine(point.y);　//Salida: 0

Arriba, se crea un objeto de la estructura Coordinate (coordenadas) utilizando la palabra clave new. Llama al constructor sin parámetros predeterminado de la estructura, que inicializa todos los miembros con el valor por defecto del tipo de datos especificado.

Si se declara una variable de tipo struct sin usar la palabra clave new, no se llama a ningún constructor, por lo tanto, todos los miembros permanecen en estado sin asignar. Por lo tanto, antes de acceder a cada miembro, debe asignarles valores; de lo contrario, se producirá un error en tiempo de compilación.

struct Coordinate
{
　　　　public int x;
　　　　public int y;
}
Coordinate point;
Console.Write(point.x);　//　Error en tiempo de compilación　　
point.x =　10;
point.y =　20;
Console.Write(point.x);　//Salida:10　　
Console.Write(point.y);　//Salida:20

Constructor de la estructura

La estructura (estructura) no puede contener un constructor sin parámetros. Solo puede contener un constructor parametrizado o un constructor estático.

struct Coordinate
{
　　　　public int x;
　　　　public int y;
　　　　public Coordinate(int x, int y)
　　　　{
　　　　　　　　this.x = x;
　　　　　　　　this.y = y;
　　　　}
}
Coordinate point = new Coordinate(10,　20);
Console.WriteLine(point.x);　//Salida:10　　
Console.WriteLine(point.y);　//Salida:20

Debe incluir todos los miembros de la estructura en el constructor parametrizado y asignarlos a los miembros; de lo contrario, si cualquier miembro permanece sin asignar, el compilador de C# generará un error en tiempo de compilación.

Métodos y propiedades de la estructura

La estructura (estructura) puede contener propiedades, propiedades implementadas automáticamente, métodos, etc., al igual que las clases.

struct Coordinate
{
　　　　public int x { get; set; }
　　　　public int y { get; set; }
　　　　public void SetOrigin()
　　　　{
　　　　　　　　this.x = 0;
　　　　　　　　this.y = 0;
　　　　}
}
Coordinate point = Coordinate();
point.SetOrigin();
Console.WriteLine(point.x);　//Salida: 0　　
Console.WriteLine(point.y);　//Salida: 0

A continuación, struct incluye métodos estáticos.

struct Coordinate
{
　　　　public int x;
　　　　public int y;
　　　　public Coordinate(int x, int y)
　　　　{
　　　　　　　　this.x = x;
　　　　　　　　this.y = y;
　　　　}
　　　　public static Coordinate GetOrigin()
　　　　{
　　　　　　　　return new Coordinate();
　　　　}
}
Coordinate point = Coordinate.GetOrigin();
Console.WriteLine(point.x);　//Salida: 0　　
Console.WriteLine(point.y);　//Salida: 0

Eventos de estructura

Las estructuras pueden contener notificaciones de eventos para suscribir a ciertas operaciones. A continuación, se muestra una estructura (struct) que contiene un evento.

struct Coordinate
{
　　　　private int _x, _y;
　　　　public int x　
　　　　{
　　　　　　　　get{
　　　　　　　　　　　　return _x;
　　　　　　　　}
　　　　　　　　set{
　　　　　　　　　　　　_x = value;
　　　　　　　　　　　　CoordinatesChanged(_x);
　　　　　　　　}
　　　　}
　　　　public int y
　　　　{
　　　　　　　　get{
　　　　　　　　　　　　return _y;
　　　　　　　　}
　　　　　　　　set{
　　　　　　　　　　　　_y = value;
　　　　　　　　　　　　CoordinatesChanged(_y);
　　　　　　　　}
　　　　}
　　　　public event Action<int> CoordinatesChanged;
}

La estructura superior contiene el evento coordinateChanged, que se desencadena cuando los coordenadas x o y cambian. A continuación, se muestra un ejemplo de cómo manejar el evento CoordinateChanged.

class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　Coordinate point = new Coordinate();
　　　　　　　　
　　　　　　　　point.CoordinatesChanged　+= StructEventHandler;
　　　　　　　　point.x =　10;
　　　　　　　　point.y =　20;
　　　　}
　　　　static void StructEventHandler(int point)
　　　　{
　　　　　　　　Console.WriteLine("El coordinate se cambia a {0}", point);
　　　　}
}

Struct es un tipo de valor, por lo que es más rápido que el objeto de clase. Cada vez que solo desee almacenar datos, utilice struct. Generalmente, las estructuras son adecuadas para la programación de juegos. Sin embargo, es más fácil transmitir objetos de clase que estructuras. Por lo tanto, cuando transmita datos a través de la red u otros tipos, no utilice struct.

Resumen

• La estructura puede incluir constructor, constantes, campos, métodos, propiedades, índices, operadores, eventos y tipos anidados.

• La estructura no puede contener constructor sin parámetros ni destructor.

• La estructura puede implementar interfaces idénticas a las de una clase.

• La estructura no puede heredar de otra estructura o clase, ni puede ser una clase base.

• La estructura no puede tener miembros abstractos, miembros sellados, miembros virtuales o miembros protegidos.