Contenido del curso
Clases, structs y records en C#
Cuando trabajas con C#, las clases no son tu única herramienta. Existen otros dos tipos, struct y record, que resuelven escenarios muy puntuales donde una clase resulta excesiva o poco práctica. Entender la diferencia entre class, struct y record en C# te ayuda a decidir cuándo conviene comparar por referencia y cuándo por valor, algo clave en aplicaciones modernas como microservicios.
¿Qué diferencia hay entre clases, estructuras y registros en C#?
La distinción central está en cómo cada tipo maneja la identidad de los objetos y para qué tamaño de componente se diseñó.
Las clases son el tipo más versátil y trabajan por reference. Cada vez que instancias un objeto, C# reserva una posición de memoria y le asigna un identificador propio. Por eso, dos objetos con datos idénticos siguen siendo distintos: cada uno apunta a una referencia diferente. Las clases sirven para componentes pequeños, medianos o grandes, y combinan valores y comportamientos, es decir, datos junto con métodos que los manipulan.
Las estructuras y los registros, en cambio, comparan por valor. Si dos objetos tienen exactamente los mismos datos, para un struct o un record son el mismo objeto. Están pensados para piezas pequeñas con pocas propiedades, donde lo importante es el contenido y no la identidad.
¿Cuándo usar un record en C#? Úsalo cuando necesitas objetos inmutables que se comparan por valor, por ejemplo, mensajes entre microservicios o DTOs que viajan entre capas.
¿Por qué dos objetos iguales en una clase devuelven false?
Porque las clases comparan referencias, no contenido. Aunque tú veas los mismos valores en pantalla, internamente cada instancia vive en una posición de memoria distinta [02:54].
En el demo del proyecto se crean dos objetos Superman y Superman2 a partir de la clase Superhéroe, con exactamente los mismos datos. Al ejecutar:
csharp Console.WriteLine(superman == superman2);
El resultado es false. Son dos instancias aisladas, con referencias independientes, así que C# las considera distintas aunque sus propiedades coincidan una a una.
Este comportamiento es útil cuando la identidad importa, por ejemplo cuando dos usuarios con el mismo nombre deben tratarse como entidades separadas. Pero se vuelve un problema cuando lo que te interesa es saber si dos paquetes de datos son equivalentes.
¿Cómo se declara y compara un record en C#?
Un record se declara casi igual que una clase, pero cambiando la palabra clave y aprovechando una sintaxis más compacta para sus propiedades [05:00].
La estructura mínima se ve así:
csharp public record SuperheroeRecord(int Id, string Nombre, string IdentidadSecreta);
No necesitas escribir constructores ni propiedades una por una si no quieres añadir comportamiento. Para crear instancias tienes dos caminos:
new SuperheroeRecord(...) pasando los valores entre paréntesis.new.Al repetir el ejercicio anterior con dos registros idénticos:
csharp var reg1 = new SuperheroeRecord(1, "Superman", "Clark Kent"); var reg2 = new SuperheroeRecord(1, "Superman", "Clark Kent"); Console.WriteLine(reg1 == reg2);
El resultado es true. El record compara propiedad por propiedad de forma automática y confirma que los objetos son equivalentes.
¿Qué es un record en C# en una frase? Es un tipo que compara objetos por valor y se usa para datos inmutables, ideal para mensajería y DTOs.
¿Por qué los records son útiles en microservicios?
En arquitecturas de microservicios recibes múltiples mensajes de otros servicios y necesitas saber si dos payloads son equivalentes. Con una clase tendrías que revisar manualmente propiedad por propiedad. Con un record, C# hace esa comparación por ti gracias a su semántica por valor [08:25].
Esto reduce código repetitivo, evita errores al olvidar comparar algún campo y deja tu lógica de negocio más limpia.
¿Cuándo conviene usar struct, record o class?
La elección depende del tamaño del componente, la mutabilidad de los datos y la forma en que necesitas compararlos.
Como ejercicio, completa el record SuperheroeRecord con todas las propiedades que ya tiene la clase Superhéroe, ejecuta la comparación y verifica que sigue funcionando por valor. Después, crea un struct equivalente y compara los tres tipos en un mismo proyecto. ¿Qué diferencias notaste al ejecutar tu propio demo? Comparte tu experiencia en los comentarios.
Erick Estrada Mancilla
Estudiante
Lucas Castillo Vasquez
Estudiante
Daniel Villera
Estudiante
YURIS CONEDO BENTHAN
Estudiante
Yezid Garcia Medina
Estudiante
Alexander Sencion Cespedes
Estudiante
Adolfo Arreaga
Estudiante
Alejandro de Jesús Reséndiz Olguín
Estudiante
Lucia Merlino
Estudiante
Cristhian Alexis Vera Sandoval
Estudiante
Joan Alexander Valerio Rodríguez
Estudiante
Edison Quimbiamba
EstudianteRECORD En C#, un "record" es un tipo de referencia inmutable introducido en C# 9.0 que se utiliza para modelar datos simples y valores inmutables. Los "records" son especialmente útiles cuando tienes un conjunto de datos que no cambia después de su creación y deseas garantizar que no se pueda modificar. Algunas de las ventajas y casos de uso comunes de los "records" incluyen:
Inmutabilidad: Los "records" son inmutables de forma predeterminada, lo que significa que sus valores no pueden cambiar después de que se hayan creado. Esto garantiza que los datos permanezcan consistentes y predecibles.
Facilidad de Igualdad: Los "records" facilitan la comparación de igualdad de objetos basándose en sus valores en lugar de sus referencias. Esto es útil al realizar comparaciones de igualdad en lugar de referencia.
Sintaxis Concisa: Los "records" tienen una sintaxis concisa para definir propiedades y métodos. Puedes definir propiedades de solo lectura de manera abreviada.
Desestructuración: Los "records" admiten la desestructuración, lo que significa que puedes descomponer un objeto "record" en sus componentes individuales.
Patrones de Coincidencia: Los "records" funcionan bien con patrones de coincidencia, lo que facilita la escritura de código que responde a diferentes combinaciones de valores de objetos "record".
Usos Comunes: Los "records" son ideales para modelar tipos de datos simples como puntos, vectores, coordenadas geográficas, datos de sensores y otros valores inmutables.
Aporte
Los records son especialmente útiles cuando necesitas representar datos que no cambian después de su creación, como datos de entidades. Algunas de las características clave de los records incluyen la inmutabilidad, la facilidad de comparación y la concisión en la sintaxis de definición.
Las principales diferencias entre una Record y una clase en C# son:
Comparación: Las Records comparan sus valores de manera estructural, mientras que las clases se comparan por referencia. Dos instancias de una clase con los mismos valores no son iguales, pero dos Records con los mismos valores sí.
Inmutabilidad: Las Records son inmutables por defecto, es decir, una vez creadas, sus propiedades no pueden cambiar. Las clases, en cambio, permiten la modificación de sus propiedades.
Sintaxis y Simplicidad: Definir una Record es más conciso que una clase, ya que no necesitas definir métodos adicionales si no son necesarios.
Estos aspectos hacen que las Records sean ideales para estructuras de datos que requieren igualdad de valor, como en microservicios.
Al intentar hacer el ejercicio con structs, me generaba un error al compilar, resulta que en C#, los structs pueden compararse utilizando el operador ==, pero solo si han sobrecargado explícitamente este operador o si sus campos son tipos que implementan comparaciones por defecto (como tipos primitivos).
Por defecto, los structs no tienen el operador == definido, por lo que si intentas compararlos directamente sin sobrecargar este operador, obtendrás un error de compilación. Sin embargo, todos los structs heredan de System.ValueType, lo que significa que puedes usar el método Equals para hacer una comparación de igualdad de sus campos.
public struct SuperHeroStruct
{
public int Id;
public string Name;
public string SecretIdentity;
}
var superHeroStruct1 = new SuperHeroStruct();
superHeroStruct1.Id = 1;
superHeroStruct1.Name = "Superman";
superHeroStruct1.SecretIdentity = "Clark Kent";
var superHeroStruct2 = new SuperHeroStruct();
superHeroStruct2.Id = 1;
superHeroStruct2.Name = "Superman";
superHeroStruct2.SecretIdentity = "Clark Kent";
Console.WriteLine(superHeroStruct1.Equals(superHeroStruct2));
gracias por el aporte y dato clave de Equals :-)
Aporte:
Los structs son tipos de valor, por lo que no pueden compararse por referencia. No existe una implementación por defecto de == para structs porque la comparación por miembros no siempre es una comparación válida, dependiendo del tipo.
Despues de tantos años, veo una manera ejemplar de como poder hacer notar las diferencias sin palabras domingueras ni explicaciones rebuscadas, super entendido, agradezco al excelente maestro! KUDOS!!
Gran clase!!!
CLASE: la forma en la que se crean o se comparan los elementos dentro del código es a través de referencias. Eso significa que cada vez que creamos un objeto con esa clase, se va a apartar una posición de memoria para almacenar los datos de ese objeto y se le va a asignar un identificador a esa posición de memoria. Si creamos otro objeto con exactamente los mismos valores de todas maneras va a ser un objeto diferente ya que cada uno de los objetos va a tener una referencia diferente.
Comparto mi código como quedo ```c#
// Proyecto de One Piece para diferenciar las frutas que tienen los personajes, debilidades, fuerza y niveles de despertar
// Se crea una instacia de la clase PoderesPirataOnePiece representando a Luffy using System.Text;
var NikaPoderes = new PoderesPiratasOnePiece(); NikaPoderes.Nombre = "Gear Fifth"; // Nombre del poder de Luffy. NikaPoderes.Descripcion = "Luffy alcanza un nuevo nivel de poder con su Gear Fifth, que le permite manipular su cuerpo como si fuera de goma y aumentar su fuerza y velocidad a niveles increíbles.";// Descripción del poder de Luffy. NikaPoderes.Nivel = NivelPiratasOnePiece.MuyAlta; // Luffy tiene una recompensa muy alta debido a su poder y hazañas. // Se crea una segunda instancia de la clase PoderesPirataOnePiece representando a Luffy var NikaHaki = new PoderesPiratasOnePiece(); NikaHaki.Nombre = "Haki del Rey"; // Nombre del poder de Luffy. NikaHaki.Descripcion = "Luffy ha desarrollado un Haki del Rey extremadamente poderoso, que le permite dominar a sus oponentes y aumentar su presencia en el campo de batalla.";// Descripción del poder de Luffy. NikaHaki.Nivel = NivelPiratasOnePiece.MuyAlta; // Luffy tiene una recompensa muy alta debido a su poder y hazañas.
// Se crea una instacia de la clase PoderesPirataOnePiece representando a Zoro var RoronoaPoderes = new PoderesPiratasOnePiece(); RoronoaPoderes.Nombre = "Santoryu"; // Nombre del poder de Zoro. RoronoaPoderes.Descripcion = "Zoro utiliza su técnica de Santoryu, que le permite manejar tres espadas a la vez, aumentando su poder de ataque y defensa.";// Descripción del poder de Zoro. RoronoaPoderes.Nivel = NivelPiratasOnePiece.Alta; // Zoro tiene una recompensa alta debido a su habilidad y logros. // Se crea una segunda instancia de la clase PoderesPirataOnePiece representando a Zoro var RoronoaHaki = new PoderesPiratasOnePiece(); RoronoaHaki.Nombre = "Haki de Observación"; // Nombre del poder de Zoro. RoronoaHaki.Descripcion = "Zoro ha perfeccionado su Haki de Observación, lo que le permite anticipar los movimientos de sus oponentes y reaccionar con rapidez.";// Descripción del poder de Zoro. RoronoaHaki.Nivel = NivelPiratasOnePiece.Alta; // Zoro tiene una recompensa alta debido a su habilidad y logros.
// Se crea una instancia de la clase PirataOnePiece representando a Luffy var luffy = new PiratasOnePiece(); luffy.Id = 1; luffy.Nombre = "Monkey D. Luffy"; luffy.FrutaDelDiablo = "Gomu Gomu no mi"; luffy.Tripulación = "Sombrero de Paja"; luffy.PuedeNadar = false; //Utilizo las clases de PoderesPirata de la linea 68 del codigo List<PoderesPiratasOnePiece> poderesLuffy = new List<PoderesPiratasOnePiece>(); poderesLuffy.Add(NikaPoderes); // Agrega el poder Gear Fifth a la lista de poderes de Luffy. poderesLuffy.Add(NikaHaki); // Agrega el poder Haki del Rey a la lista de poderes de Luffy. luffy.Poderes = poderesLuffy; //string resultUsarPoderes = luffy.UsarPoderes(); // Llama al método UsarPoderes() de Luffy, que recorre y muestra todos los poderes que posee. //Console.WriteLine(resultUsarPoderes); // Muestra por consola los poderes que está usando Luffy. luffy.UsarPoderes(); // Llama al método UsarPoderes() de Luffy, que recorre y muestra todos los poderes que posee. // Se crea una instancia de la clase PirataOnePiece representando a Zoro var zoro = new PiratasOnePiece(); zoro.Id = 2; zoro.Nombre = "Zoro"; zoro.FrutaDelDiablo = "Ninguna"; zoro.Tripulación = "Sombrero de Paja"; zoro.PuedeNadar = true;
var zoro2 = new PiratasOnePiece(); zoro.Id = 2; zoro.Nombre = "Zoro"; zoro.FrutaDelDiablo = "Ninguna"; zoro.Tripulación = "Sombrero de Paja"; zoro.PuedeNadar = true; Console.WriteLine(zoro == zoro2); // Compara si las dos instancias de Zoro son iguales, lo que debería ser cierto ya que tienen los mismos valores. PiratasOnePieceRecord piratasOnePieceRecord = new PiratasOnePieceRecord(1, "Zoro", "Ninguna"); // Crea un record de Zoro con los valores especificados. PiratasOnePieceRecord piratasOnePieceRecord2 = new PiratasOnePieceRecord(1, "Zoro", "Ninguna"); // Crea un record de Zoro con los valores especificados. Console.WriteLine(piratasOnePieceRecord == piratasOnePieceRecord2); // Compara si los dos records de Zoro son iguales, lo que debería ser cierto ya que tienen los mismos valores. //Utilizo las clases de PoderesPirata de la linea 68 del codigo //List<PoderesPiratasOnePiece> poderesZoro = new List<PoderesPiratasOnePiece>(); //poderesZoro.Add(RoronoaPoderes); // Agrega el poder Santoryu a la lista de poderes de Zoro. //poderesZoro.Add(RoronoaHaki); // Agrega el poder Haki de Observación a la lista de poderes de Zoro. //zoro.Poderes = poderesZoro; // Asigna la lista de poderes a Zoro. ////resultUsarPoderes = zoro.UsarPoderes(); // Llama al método UsarPoderes() de Luffy, que recorre y muestra todos los poderes que posee. ////Console.WriteLine(resultUsarPoderes); // Muestra por consola los poderes que está usando Zoro //zoro.UsarPoderes(); // Llama al método UsarPoderes() de Zoro, que recorre y muestra todos los poderes que posee.
// Clase que representa a un pirata del universo One Piece. class PiratasOnePiece { public int Id = 1; //Identificador único del pirata. public string Nombre;// Nombre del pirata. public string FrutaDelDiablo; // Nombre de la fruta del diablo que posee el pirata(si tiene). public string Tripulación; // Nombre de la tripulación a la que pertenece el pirata. public List<PoderesPiratasOnePiece> Poderes = new List<PoderesPiratasOnePiece>(); //Niveles de despertar alcanzados por el pirata (puede ser una lista de habilidades o etapas). public bool PuedeNadar; //Indica si el pirata puede nadar (los usuarios de frutas del diablo no pueden nadar).
//Creación de constructor para la Clase PiratasOnePice public PiratasOnePiece() { Id = 1; // Inicializa el identificador del pirata con el valor 1 por defecto. Poderes = new List<PoderesPiratasOnePiece>(); // Crea una lista vacía de poderes para el pirata. PuedeNadar = false; // Por defecto, el pirata no puede nadar (útil para usuarios de frutas del diablo). } // Método que recorre y muestra todos los poderes que posee el pirata con public void UsarPoderes() public void UsarPoderes() { // Recorre cada poder en la lista de poderes del pirata. foreach (var item in Poderes) { // Muestra por consola el nombre del pirata y el poder que está usando. Console.WriteLine($"{Nombre} Esta usando el poder {item.Nombre}!!"); } } //Metodo que recorre y muestra todos los poderes que posee el pirata con public string UsarPoderes() //public string UsarPoderes() //{ // StringBuilder stringBuilder = new StringBuilder(); // Crea un StringBuilder para construir la cadena de salida. // // Recorre cada poder en la lista de poderes del pirata. // foreach (var item in Poderes) // { // // Agrega el nombre del pirata y el poder que está usando al StringBuilder. // stringBuilder.AppendLine($"{Nombre} Esta usando el poder {item.Nombre}!!"); // } // return stringBuilder.ToString(); // Devuelve la cadena construida por el StringBuilder. //}
}
//Clase que representa los poderes de un pirata del universo One Piece. class PoderesPiratasOnePiece { public string Nombre; // Lista de habilidades del pirata. public string Descripcion; // Lista de debilidades del pirata. public NivelPiratasOnePiece Nivel; // Nivel de despertar del pirata.
// Constructor de la clase PoderesPiratasOnePiece. // Este constructor inicializa el nivel del poder como MuyAlta por defecto, // lo que indica que, si no se especifica otro valor, el poder será considerado de nivel muy alto. public PoderesPiratasOnePiece() { Nivel = NivelPiratasOnePiece.MuyAlta; // Asigna el nivel MuyAlta como valor predeterminado al crear un nuevo poder. }
}
// Clase que representa los niveles de un pirata del universo One Piece.
enum NivelPiratasOnePiece { Bajo = 1000000, // Recompensa baja. Media = 5000000, // Recompensa media. Alta = 10000000, // Recompensa alta. MuyAlta = 50000000 // Recompensa muy alta. }
// Clase de record que representa los poderes de un pirata del universo One Piece. public record PiratasOnePieceRecord( int Id,string Nombre, string FrutaDelDiablo);
//Compare Hero #4 vs. Hero #5 Hero.HeroRecord batman = new ( 4, "Bruce Wayne", "Batman", false, new List<Colors> { blackColor, yellowColor }, true, new List<SuperPower> { strengthPower }); Hero.HeroRecord spiderman = new(5, "Tobey Maguire", "Spider-man", false, new List<Colors> { blueColor, redColor }, true, new List<SuperPower> { strengthPower }); Console.WriteLine(batman == spiderman); //Output: False
public record SuperHeroRecord(int id, string nombre, string IdentidadSecreta);
SuperHeroRecord superHeroRecord = new(1, "SuperMan", "Clark kent");