La siguiente es una introducción detallada a los patrones de diseño de desarrollo comunes en Unity:
patrón único
introducir
El patrón singleton es un patrón de diseño común que garantiza que una clase tenga solo una instancia y proporciona un punto de acceso global para acceder a esa instancia.
método
El método de implementación del modo singleton es privatizar el constructor de la clase, de modo que la instancia de la clase no se pueda crear a través de la nueva palabra clave. Luego, defina un método estático en la clase para obtener la única instancia de la clase y, si la instancia no existe, cree una nueva instancia y devuélvala.
Por ejemplo
Aquí hay un ejemplo de una clase GameManager implementada usando el patrón singleton:
public class GameManager
{
private static GameManager instance;
private GameManager() {
}
public static GameManager Instance
{
get
{
if (instance == null)
{
instance = new GameManager();
}
return instance;
}
}
public void StartGame()
{
// ...
}
public void EndGame()
{
// ...
}
}
En el ejemplo anterior, el constructor de la clase GameManager se hace privado y la propiedad Instance proporciona un punto de acceso global a la única instancia de GameManager. Otras clases pueden acceder a las instancias de GameManager a través de GameManager.Instance y llamar a sus métodos públicos.
patrón de fábrica
introducir
El patrón de fábrica es un patrón de diseño común que delega la creación de objetos a una clase de fábrica, desvinculando así el código del cliente de la creación de instancias de clases concretas.
método
El método de implementación del patrón de fábrica es definir una clase o interfaz de fábrica abstracta y declarar un método de fábrica para crear objetos en ella. Luego, cree una clase de fábrica concreta para implementar un método de fábrica que instanciará un objeto de la clase concreta y lo devolverá. El código del cliente solo necesita llamar al método de fábrica para obtener el objeto deseado sin instanciar la clase concreta directamente.
Por ejemplo
Aquí hay un ejemplo de una clase EnemyFactory implementada usando el patrón de fábrica:
public abstract class Enemy
{
public abstract void Attack();
}
public class Slime : Enemy
{
public override void Attack()
{
// ...
}
}
public class Goblin : Enemy
{
public override void Attack()
{
// ...
}
}
public abstract class EnemyFactory
{
public abstract Enemy CreateEnemy();
}
public class SlimeFactory : EnemyFactory
{
public override Enemy CreateEnemy()
{
return new Slime();
}
}
public class GoblinFactory : EnemyFactory
{
public override Enemy CreateEnemy()
{
return new Goblin();
}
}
En el ejemplo anterior, Enemy es una clase base abstracta y Slime y Goblin son subclases concretas. EnemyFactory es una clase de fábrica abstracta, y SlimeFactory y GoblinFactory son clases de fábrica concretas, que implementan respectivamente el método CreateEnemy y devuelven instancias de Slime y Goblin. El código del cliente puede usar EnemyFactory para crear los objetos Enemy deseados sin crear instancias de Slime o Goblin directamente.
Patrón de observador
introducir
El modo de observador es un patrón de diseño común, que define una dependencia de uno a muchos, lo que permite que múltiples objetos observadores controlen un objeto sujeto al mismo tiempo, cuando el objeto sujeto cambia, todos sus observadores recibirán una notificación y actualización.
método
El patrón de observador se implementa definiendo un objeto sujeto que mantiene una lista de observadores y proporciona métodos para registrar y notificar a los observadores. Los objetos observadores implementan un método de actualización que se llama cuando cambia el objeto sujeto. El código del cliente puede monitorear el cambio del objeto sujeto al registrar un observador y realizar las operaciones correspondientes en el método de actualización.
Por ejemplo
A continuación se muestra un ejemplo de las clases Sujeto y Observador implementadas con el patrón Observador:
using System;
using System.Collections.Generic;
public class Subject
{
private List<Observer> observers = new List<Observer>();
public void Attach(Observer observer)
{
observers.Add(observer);
}
public void Detach(Observer observer)
{
observers.Remove(observer);
}
public void Notify()
{
foreach (Observer observer in observers)
{
observer.Update();
}
}
}
public abstract class Observer
{
protected Subject subject;
public Observer(Subject subject)
{
this.subject = subject;
}
public abstract void Update();
}
public class ConcreteObserver : Observer
{
public ConcreteObserver(Subject subject) : base(subject) {
}
public override void Update()
{
// ...
}
}
En el ejemplo anterior, Sujeto es una clase de sujeto que mantiene una lista de Observadores y proporciona métodos de Adjuntar, Separar y Notificar para registrar, cancelar el registro y notificar a los observadores. Observer es una clase de observador abstracto y ConcreteObserver es una clase de observador concreto, que implementa el método de actualización. El código del cliente puede detectar cambios en el objeto sujeto creando una instancia de ConcreteObserver y registrándola con el Sujeto.
modelo de delegación
introducir
El patrón delegado es un patrón de diseño común que usa objetos delegados para representar funciones y pasarlos como parámetros a otras funciones. Esto organiza el código en módulos más pequeños, lo que facilita su mantenimiento y reutilización.
método
El patrón de delegado se implementa definiendo un tipo de delegado y pasándolo como parámetro a otras funciones. Otras funciones pueden pasar su implementación al objeto delegado, llamando así a la función representada por el objeto delegado.
Por ejemplo
Aquí hay un ejemplo de una clase EventHandler implementada usando el patrón de delegado:
public delegate void EventHandler();
public class EventPublisher
{
public event EventHandler OnEvent;
public void RaiseEvent()
{
if (OnEvent != null)
{
OnEvent();
}
}
}
public class EventSubscriber
{
public void HandleEvent()
{
// ...
}
}
En el ejemplo anterior, EventHandler es un tipo de delegado, EventPublisher es una clase de publicación de eventos, que define un evento OnEvent y activa el evento en el método RaiseEvent. EventSubscriber es una clase de suscriptor de eventos que define un método HandleEvent que se puede implementar como un delegado de EventHandler. El código del cliente puede crear instancias de EventPublisher y EventSubscriber, y pasar el método HandleEvent de EventSubscriber al evento OnEvent de EventPublisher, implementando así el patrón de delegación.
modo de estado
introducir
El patrón de estado es un patrón de diseño común que separa el comportamiento y el estado de un objeto para que los cambios en el estado no afecten directamente el comportamiento del objeto.
método
El método de implementación del patrón de estado es definir una clase de estado abstracta y varias clases de estado concretas, cada clase de estado concreta representa un estado específico e implementa un conjunto de métodos definidos en la clase de estado abstracta. Luego, defina una clase de contexto que contenga variables miembro de la clase de estado abstracto, que representan el estado actual, e implemente un conjunto de métodos en la clase de contexto para cambiar de estado y llamar a métodos del estado actual.
Por ejemplo
Aquí hay un ejemplo de las clases PlayerState y Player implementadas usando el patrón State:
public abstract class PlayerState
{
protected Player player;
public PlayerState(Player player)
{
this.player = player;
}
public abstract void Move();
public abstract void Jump();
public abstract void Attack();
}
public class IdleState : PlayerState
{
public IdleState(Player player) : base(player) {
}
public override void Move()
{
player.State = new RunState(player);
}
public override void Jump()
{
player.State = new JumpState(player);
}
public override void Attack()
{
// ...
}
}
public class RunState : PlayerState
{
public RunState(Player player) : base(player) {
}
public override void Move()
{
// ...
}
public override void Jump()
{
player.State = new JumpState(player);
}
public override void Attack()
{
// ...
}
}
public class JumpState : PlayerState
{