Fundamentos de la POO con C# [4/10]: Tipos de datos, por valor y por referencia
Aprende los tipos de datos que existen en C#, además también comprende las zonas de memoria reservadas para almacenar variables 🙌

Devs! Continuamos con esta serie de entradas, ahora aprenderemos qué son los tipos de datos y cuáles son, también comprenderemos aspectos básicos de la gestión del espacio en memoria donde se guardan las variables en C#.

Contenido de la Serie de artículos

Estos son todos los temas de la serie:

  1. 1. La Programacion orientada a objetos (POO) y el diseño orientado a objetos (DOO)
  2. 2. Los requerimientos: funcionales y no funcionales
  3. 3. Objetos y clases
  4. 4. Tipos de datos en C#: Por valor y por referencia
  5. 5. Constructores
  6. 6. Signaturas e Interfaces
  7. 7. Clases especiales: estáticas y abstractas
  8. 8. Modificadores de acceso
  9. 9. Los 4 Pilares de la POO: Herencia, abstracción, encapsulamiento y polimorfismo
  10. 10. Los Principios SOLID
Los datos pueden guardarse de muchas formas, cada una de ellas es un tipo. Foto de Kenny Eliason en Unsplash

Tipos de datos

Un tipo de dato indica un conjunto de valores que tienen el mismo significado genérico o propósito.

Por ejemplo, en la imagen de arriba se puede observar que hay datos, tenemos precios, textos, teléfonos.

Entonces estos datos puedes agruparse en tipos que reunen características en común, y es allí donde se originan los tipos de datos, como por ejemplo: cadenas de texto [string], número entero [int], número decimal [decimal], fecha [DateTime], entre otros.

Hay algunos tipos de datos especiales que son los definidos por una clase. A estos tipos de datos se les conoce como tipos de datos personalizados.

Categorías de tipos de datos

TIPOS POR VALORTIPOS POR REFERENCIA
Los valores de las variables de estos tipos son copiados en donde sean llamados.Las variables cuando son llamadas, envían una referencia de ella misma
Son tipos de datos sencillos, estos almacenan un dato en concreto.Son tipos de datos complejos, es decir personalizados o formados a partir de una clase, sea la clase Object o una creada.
El valor por defecto está definido, no es NULL ni vacío.El valor por defecto es NULL
Ejemplos: int, bool, float, double, decimal, charEjemplos: string, DateTime, todo objeto creado
Estas variables son guardadas en la zona de memoria reservada llamada STACK o PILA.Estas variables son guardadas en la zona de memoria reservada llamada HEAP o MONTÓN.

Áreas de memoria reservada

Son dos. La información, es decir, las variables se guardan en esta zona y dependiendo del tipo de dato se va a una u otra, veamos:

  • Stack: También llamada pila. Aquí se almacena la información de uso inmediato que emplea el hilo de ejecución de un programa. En esta área de la memoria los valores se van almacenando uno sobre otro, de forma tal que cuando queremos liberar un valor, la pila va devolviendo la posición mayor primero y así hacia abajo, este comportamiento se conoce como LIFO (Last in, first out).
  • Heap: También llamado el "montón" es una área o zona de memoria donde la asignación es dinámica, la devolución de un valor no necesita seguir un orden como en la pila.

Como hemos visto en el cuadro superior según el tipo de datos con el que haya sido definido una variable se almacenará en una u otra área de la memoria reservada.

Comprobación con código

Para comprobar esto he creado una aplicación de consola en .NET 6.

Añadí dos clases en el archivo Program.cs

Recordar que en .NET 6 ya no se crea por defecto el método Main

public static class Operaciones
{
    public static void RealizarTransaccion()
    {
        /*TIPOS (Por referencia)*/
        var cliente = new Cliente();
        cliente.Nombre = "Gerson";
        Console.WriteLine($"El nombre del cliente es {cliente.Nombre}");
        CambiarNombre(cliente);
        Console.WriteLine($"El nombre del cliente es {cliente.Nombre}");//el nombre es alterado aunque fue modificado en un método aparte.

        /*TIPOS (Por valor)*/
        var saldo = 5000;        
        Console.WriteLine($"El saldo del cliente es {saldo}");
        DuplicarSaldo(saldo);
        Console.WriteLine($"El saldo del cliente es {saldo}");//el saldo aunque fue cambiado afuera, aquí sigue siendo el mismo
    }

    public static void CambiarNombre(Cliente cliente)
    {
        cliente.Nombre = "Jorge";
    }

    public static void DuplicarSaldo(int saldo)
    {
        saldo *= 2;
    }
}

public class Cliente
{
    /* CAMPOS */
    private int id;
    private string nombre;       

    /* PROPIEDADES */
    public int Id
    {
        get { return id; }
        set { id = value; }
    }
    public string Nombre
    {
        get { return nombre; }
        set { nombre = value; }
    }
    public decimal Credito { get; set; } //Propiedad auto-implementada

    /* MÉTODOS */
    public void Comprar(decimal monto)
    {
        this.Credito -= monto;
    }

    public void Vender(decimal monto)
    {
        this.Credito += monto;
    }
}

Utilizamos estas clases añadiendo estas líneas en la clase Program.cs

Console.WriteLine("Tipos");
Operaciones.RealizarTransaccion();

El programa se ve algo así:

Y al ejecutar la aplicación tenemos este resultado 😉

Confirmamos lo dicho hasta ahora, el nombre aunque fue cambiado afuera en un método, altera el valor de la variable ya que al ser un tipo por referencia envió a ese método una referencia de sí mismo. Por otro lado el valor entero al ser un tipo por valor, no se ve modificado aunque haya sido cambiado en un método.

Ahora es momento que compartas esta entrada, es la mejor forma en la que me puedes ayudar 😉

Deja una respuesta

Tu dirección de correo electrónico no será publicada.