El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Conceptes Avançats de C# per a Unity

Següent ►
►

En aquest tema, explorarem conceptes avançats de C# que són especialment útils per al desenvolupament de jocs en Unity. Aquests conceptes inclouen delegats, esdeveniments, expressions lambda, LINQ i patrons de disseny. Aquests elements permeten escriure codi més eficient, modular i mantenible.

Índex del Tema

  1. Delegats
  2. Esdeveniments
  3. Expressions Lambda
  4. LINQ (Language Integrated Query)
  5. Patrons de Disseny

  1. Delegats

Què és un Delegat?

Un delegat és un tipus que representa referències a mètodes amb una signatura específica. Els delegats són útils per passar mètodes com a arguments a altres mètodes.

Exemple de Delegat

// Definició d'un delegat
public delegate void MyDelegate(string message);

public class DelegateExample
{
    // Mètode que coincideix amb la signatura del delegat
    public void PrintMessage(string message)
    {
        Debug.Log(message);
    }

    public void Start()
    {
        // Instanciació del delegat
        MyDelegate del = PrintMessage;
        // Crida al mètode a través del delegat
        del("Hola, món!");
    }
}

Explicació

  1. Definició del Delegat: public delegate void MyDelegate(string message);
  2. Mètode que Coincideix amb la Signatura: PrintMessage
  3. Instanciació i Ús del Delegat: MyDelegate del = PrintMessage; i del("Hola, món!");

  1. Esdeveniments

Què és un Esdeveniment?

Els esdeveniments permeten que una classe notifiqui a altres classes quan alguna cosa succeeix. Els esdeveniments es basen en delegats.

Exemple d'Esdeveniment

public class EventExample
{
    // Definició d'un delegat per a l'esdeveniment
    public delegate void MyEventHandler(string message);
    // Definició de l'esdeveniment
    public event MyEventHandler OnMessage;

    public void TriggerEvent(string message)
    {
        // Comprovació i invocació de l'esdeveniment
        if (OnMessage != null)
        {
            OnMessage(message);
        }
    }
}

public class EventListener
{
    public void Start()
    {
        EventExample example = new EventExample();
        // Subscripció a l'esdeveniment
        example.OnMessage += HandleMessage;
        example.TriggerEvent("Esdeveniment activat!");
    }

    // Mètode que maneja l'esdeveniment
    public void HandleMessage(string message)
    {
        Debug.Log(message);
    }
}

Explicació

  1. Definició del Delegat i Esdeveniment: public delegate void MyEventHandler(string message); i public event MyEventHandler OnMessage;
  2. Subscripció a l'Esdeveniment: example.OnMessage += HandleMessage;
  3. Invocació de l'Esdeveniment: OnMessage(message);

  1. Expressions Lambda

Què és una Expressió Lambda?

Les expressions lambda són una manera concisa d'escriure mètodes anònims utilitzant la sintaxi =>.

Exemple d'Expressió Lambda

public class LambdaExample
{
    public void Start()
    {
        // Expressió lambda que imprimeix un missatge
        System.Action<string> printMessage = message => Debug.Log(message);
        printMessage("Hola des de lambda!");
    }
}

Explicació

  1. Definició de l'Expressió Lambda: message => Debug.Log(message);
  2. Ús de l'Expressió Lambda: printMessage("Hola des de lambda!");

  1. LINQ (Language Integrated Query)

Què és LINQ?

LINQ és un conjunt de mètodes que permeten realitzar operacions de consulta sobre col·leccions de dades de manera similar a SQL.

Exemple de LINQ

using System.Linq;

public class LINQExample
{
    public void Start()
    {
        int[] numbers = { 1, 2, 3, 4, 5, 6 };
        // Ús de LINQ per filtrar números parells
        var evenNumbers = numbers.Where(n => n % 2 == 0);

        foreach (var num in evenNumbers)
        {
            Debug.Log(num);
        }
    }
}

Explicació

  1. Definició de la Col·lecció: int[] numbers = { 1, 2, 3, 4, 5, 6 };
  2. Ús de LINQ per Filtrar: var evenNumbers = numbers.Where(n => n % 2 == 0);
  3. Iteració sobre el Resultat: foreach (var num in evenNumbers)

  1. Patrons de Disseny

Què és un Patró de Disseny?

Els patrons de disseny són solucions generals reutilitzables per a problemes comuns en el disseny de programari.

Exemple de Patró Singleton

El patró Singleton assegura que una classe només tingui una instància i proporciona un punt d'accés global a aquesta instància.

public class SingletonExample
{
    private static SingletonExample instance;

    // Constructor privat per evitar la instanciació directa
    private SingletonExample() { }

    public static SingletonExample Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new SingletonExample();
            }
            return instance;
        }
    }

    public void PrintMessage()
    {
        Debug.Log("Singleton instance");
    }
}

Explicació

  1. Instància Estàtica: private static SingletonExample instance;
  2. Constructor Privat: private SingletonExample() { }
  3. Propietat per Accedir a la Instància: public static SingletonExample Instance

Exercicis Pràctics

Exercici 1: Delegats i Esdeveniments

  1. Crea un delegat que accepti dos enters i retorni la seva suma.
  2. Defineix un esdeveniment que utilitzi aquest delegat.
  3. Escriu una classe que es subscrigui a l'esdeveniment i imprimeixi el resultat de la suma.

Solució

public delegate int SumDelegate(int a, int b);

public class EventSumExample
{
    public event SumDelegate OnSum;

    public void TriggerSum(int a, int b)
    {
        if (OnSum != null)
        {
            int result = OnSum(a, b);
            Debug.Log("Resultat de la suma: " + result);
        }
    }
}

public class SumListener
{
    public void Start()
    {
        EventSumExample example = new EventSumExample();
        example.OnSum += Sum;
        example.TriggerSum(3, 4);
    }

    public int Sum(int a, int b)
    {
        return a + b;
    }
}

Exercici 2: Expressions Lambda i LINQ

  1. Crea una llista de números enters.
  2. Utilitza una expressió lambda per filtrar els números que són més grans que 5.
  3. Imprimeix els números filtrats.

Solució

using System.Collections.Generic;
using System.Linq;

public class LambdaLINQExample
{
    public void Start()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 6, 7, 8 };
        var filteredNumbers = numbers.Where(n => n > 5);

        foreach (var num in filteredNumbers)
        {
            Debug.Log(num);
        }
    }
}

Conclusió

En aquest tema, hem explorat conceptes avançats de C# que són molt útils per al desenvolupament de jocs en Unity. Hem après sobre delegats, esdeveniments, expressions lambda, LINQ i patrons de disseny. Aquests conceptes ens permeten escriure codi més eficient i mantenible. En el proper tema, aprofundirem en les coroutines i la programació asíncrona en Unity.

◄ Anterior
◄
Següent ►
►

Curs de Unity

Mòdul 1: Introducció a Unity

Mòdul 2: Programació Bàsica en Unity

Mòdul 3: Treballant amb Actius

Mòdul 4: Física i Col·lisions

Mòdul 5: Interfície d'Usuari (UI)

Mòdul 6: Àudio en Unity

Mòdul 7: Programació Avançada

Mòdul 8: Física Avançada i IA

Mòdul 9: Optimització i Rendiment

Mòdul 10: Publicació i Més Enllà

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats