C# Clases

En C#, una clase es un bloque de código que sirve como un plano o plantilla para crear objetos. Las clases permiten definir propiedades (datos) y métodos (funcionalidades) que tienen comportamientos asociados. Los objetos son instancias de una clase y se crean a partir de la definición de la clase. Las clases son una parte fundamental de la programación orientada a objetos (POO) y ayudan a organizar y estructurar el código de manera más eficiente.

Definición de una Clase

using System;

public class Persona
{
    // Propiedades
    public string Nombre;
    public int Edad;

    // Constructor
    public Persona(string nombre, int edad)
    {
        Nombre = nombre;
        Edad = edad;
    }

    // Método
    public void Saludar()
    {
        Debu.Log($"Hola, soy {Nombre} y tengo {Edad} años.");
    }
}

En este ejemplo, hemos creado una clase llamada Persona con dos propiedades (Nombre y Edad), un constructor que inicializa estas propiedades y un método Saludar que muestra un saludo en la consola.

En otra parte del codigo, lo que podemos hacer es crear una instancia de esta clase. Este momento es donde se construye este objeto del cual la clase es un “template” o “plantilla”.

class Program : Monobehavior
{
    public void Start()
    {
        // Crear objetos de la clase Persona
        Persona persona1 = new Persona("Juan", 30);
        Persona persona2 = new Persona("Maria", 25);

        // Llamar al método Saludar de cada objeto
        persona1.Saludar();
        persona2.Saludar();
    }
}

Este programa crea dos objetos Persona y llama al método Saludar de cada uno, lo que imprimirá mensajes personalizados en la consola.

💡 El hecho de que se pueda enviar el string nombre y edad entre paréntesis es la misma lógica que cuando enviamos atributos a traves de un método. Pero en vez de definir un método definimos un constructor. El constructor tiene que tener el se define como public NOMBRE_DE_LA_CLASE , en este caso, public Persona(){}

Constructores

Puedes tener varios constructores en una clase de C# para permitir diferentes combinaciones de parámetros, incluyendo parámetros opcionales. Esto se llama "sobrecarga de constructores". Aquí te mostraré cómo hacerlo, incluyendo ejemplos de parámetros opcionales.

public class Producto
{
    public string Nombre;
    public decimal Precio;
    public int Cantidad;

    // Constructor con todos los parámetros
    public Producto(string nombre, decimal precio, int cantidad)
    {
        Nombre = nombre;
        Precio = precio;
        Cantidad = cantidad;
    }

    // Constructor con nombre y precio (cantidad predeterminada a 1)
    public Producto(string nombre, decimal precio)
    {
        Nombre = nombre;
        Precio = precio;
        Cantidad = 1; // Valor predeterminado para cantidad
    }

    // Constructor sin parámetros (valores predeterminados para todos los campos)
    public Producto()
    {
        Nombre = "Sin Nombre";
        Precio = 0.0M;
        Cantidad = 0;
    }
}

En este ejemplo, hemos definido tres constructores diferentes para la clase Producto. Uno acepta todos los parámetros, otro acepta solo nombre y precio, y el último no acepta ningún parámetro y establece valores predeterminados.

Parámetros

Puedes utilizar parámetros opcionales (al igual que en los métodos) para permitir que los usuarios de tu clase proporcionen solo los valores que deseen al crear un objeto. Aquí hay un ejemplo que utiliza parámetros opcionales:

public class Coche
{
    public string Marca { get; set; }
    public string Modelo { get; set; }
    public int Año { get; set; }

    // Constructor con parámetros opcionales
    public Coche(string marca = "Desconocida", string modelo = "Desconocido", int año = 0)
    {
        Marca = marca;
        Modelo = modelo;
        Año = año;
    }
}

En este ejemplo, hemos definido un constructor para la clase Coche que acepta parámetros opcionales. Los parámetros marca, modelo y año tienen valores predeterminados, por lo que si no se proporcionan al crear un objeto Coche, se utilizarán los valores predeterminados.

Coche coche1 = new Coche(); // Valores predeterminados
Coche coche2 = new Coche("Toyota"); // Especifica solo la marca
Coche coche3 = new Coche("Ford", "Focus"); // Especifica marca y modelo
Coche coche4 = new Coche("Honda", "Civic", 2020); // Especifica todos los parámetros

Estos ejemplos ilustran cómo puedes crear constructores con diferentes combinaciones de parámetros, incluyendo parámetros opcionales, para hacer más flexible la creación de objetos en C#.

Herencia

public class Estudiante : Persona //De esta forma indicamos que la clase hereda de Persona
{
    // Nueva propiedad
    public string Universidad;

    // Constructor que llama al constructor de la clase base
    public Estudiante(string nombre, int edad, string universidad) : base(nombre, edad)
    {
        Universidad = universidad;
    }

    // Método adicional
    public void Estudiar()
    {
        Debug.Log($"Soy {Nombre}, estudio en {Universidad}, y tengo {Edad} años.");
    }
}

En este ejemplo, hemos creado una clase Estudiante que hereda de la clase Persona y añade una propiedad y un método adicionales.

💡 Como habras podido ver, todas las clases creadas desde Unity (no desde el editor de codigo). Heredan de Monobehavior. Esto es lo que nos permite tener metodos como Start() en esta clase.

Clases en Unity

En Unity, puedes utilizar el método AddComponent para añadir un componente MonoBehavior a un GameObject. Esto te permite adjuntar scripts personalizados a objetos en tiempo de ejecución.

Supongamos que tienes una clase MonoBehavior llamada MiScript que deseas añadir a un GameObject en tu escena:

using UnityEngine;

public class MiScript : MonoBehaviour
{
    // Este es un ejemplo de un método en el script MiScript
    public void MiMetodo()
    {
        Debug.Log("¡Hola desde MiScript!");
    }
}

Ahora, en otro script o en algún lugar de tu código, puedes utilizar el método AddComponent para añadir MiScript a un GameObject específico. Aquí tienes un ejemplo:

using UnityEngine;

public class EjemploAgregarComponente : MonoBehaviour
{
    private void Start()
    {
        // Obtén una referencia al GameObject al que deseas añadir el componente
        GameObject objetoParaAgregarComponente = GameObject.Find("NombreDelObjeto"); // Reemplaza "NombreDelObjeto" con el nombre del GameObject

        // Añade el componente MiScript al GameObject
        MiScript miScript = objetoParaAgregarComponente.AddComponent<MiScript>();

        // Ahora puedes utilizar los métodos y propiedades de MiScript en el objeto
        miScript.MiMetodo();
    }
}

Asegúrate de reemplazar "NombreDelObjeto" con el nombre real del GameObject al que deseas añadir el componente MiScript. Cuando ejecutes este código en Unity, se añadirá el componente MiScript al objeto especificado, y podrás acceder a sus métodos y propiedades.

Ten en cuenta que es importante que el GameObject al que deseas añadir el componente ya exista en la escena o se haya instanciado previamente en el juego. Además, asegúrate de que el script desde el que estás llamando a AddComponent esté asociado a un GameObject en la escena o en algún prefab para que pueda ejecutarse en tiempo de ejecución.

Pero que pasa con los constructores en Unity?

Para pasar argumentos a un constructor de una clase que hereda de MonoBehaviour en Unity, debes tener en cuenta que Unity no permite la personalización de los constructores de las clases que heredan de MonoBehaviour. Esto se debe a que Unity controla el ciclo de vida de los objetos y requiere que sus componentes se inicialicen de una manera específica.

Sin embargo, puedes lograr algo similar utilizando métodos públicos personalizados para configurar tu componente después de que se haya agregado a un GameObject. Aquí tienes un ejemplo de cómo hacerlo:

Supongamos que tienes una clase MiScript que necesita algunos valores en su inicialización. En lugar de pasarlos directamente en el constructor, puedes crear un método personalizado para configurar los valores después de agregar el componente a un GameObject. Aquí está el ejemplo:

using UnityEngine;

public class MiScript : MonoBehaviour
{
    private int valor1;
    private string valor2;

    // Método personalizado para configurar los valores
    public void Initialize(int v1, string v2)
    {
        valor1 = v1;
        valor2 = v2;
    }

    // Otros métodos y funciones de MiScript
}

Luego, en otro script o en el Inspector de Unity, puedes agregar el componente MiScript a un GameObject y luego llamar al método Configurar para establecer los valores deseados:

using UnityEngine;

public class OtroScript : MonoBehaviour
{
    private void Start()
    {
        // Crea una instancia y asignalo a una variable.
        MiScript miScript = GameObject.AddComponent<MiScript>();

        // Configura los valores necesarios utilizando el método Configurar
        miScript.Configurar(42, "Hola, Mundo");
    }
}

De esta manera, puedes pasar argumentos a tu "clase" MonoBehavior después de agregarla al GameObject y asegurarte de que Unity administre adecuadamente el ciclo de vida de tus objetos.

Importante: No es lo mismo pasar un

La diferencia principal entre pasar un int o un string como parámetro y pasar una clase como parámetro radica en cómo se maneja la información en memoria y la semántica de pasaje de datos en C#.

Pasar un `int` o un `string` como parámetro:

Cuando pasas un int o un string como parámetro a una función, estás pasando una copia de su valor. Estos tipos de datos son tipos de valor en C#, lo que significa que su contenido se almacena directamente en la memoria donde se llama a la función. Cualquier modificación que hagas en estos parámetros dentro de la función no afectará a las variables originales fuera de la función.

void ModificarEntero(int numero)
{
    numero = 42;
}

int miNumero = 10;
ModificarEntero(miNumero);
// miNumero seguirá siendo 10, ya que el parámetro es una copia

Pasar una `class`como parámetro:

Cuando pasas una instancia de una clase como parámetro a una función, estás pasando una referencia al objeto. Las clases en C# son tipos de referencia, lo que significa que no pasas una copia de los datos del objeto, sino una referencia que apunta a la ubicación en la memoria donde se almacenan los datos del objeto. Esto significa que cualquier modificación que hagas en el objeto dentro de la función afectará al objeto original fuera de la función, ya que ambos apuntan a la misma ubicación en memoria.

class MiClase
{
    public int Valor;
}

void ModificarClase(MiClase objeto)
{
    objeto.Valor = 42;
}

MiClase miObjeto = new MiClase();
miObjeto.Valor = 10;
ModificarClase(miObjeto);
// miObjeto.Valor ahora es 42, ya que la función trabajó sobre el objeto original

En resumen, la diferencia fundamental radica en la semántica de copia (para tipos de valor) vs. referencia (para tipos de referencia). Al pasar una clase como parámetro, se pasa una referencia al objeto real, lo que permite modificar el objeto original dentro de la función. En contraste, cuando se pasan int o string, se pasa una copia de su valor y cualquier modificación dentro de la función no afectará a las variables originales fuera de la función.

Quieres saber mas?

Microsoft es quien tiene toda la información actualizada sobre nuestro querido lenguaje C#

Te recomiendo que investigues la siguiente pagina:

C# reference - C#

Del lado izquierdo tienes un arbol de seleccion, alli encontraras los Types divididos en Value types y Reference types.

PreviousEjercicio math NextRedes y topologías

Last updated 2 months ago