A seguir, uma introdução detalhada aos padrões de design de desenvolvimento comuns no Unity:
padrão singleton
introduzir
O padrão singleton é um padrão de design comum que garante que uma classe tenha apenas uma instância e forneça um ponto de acesso global para acessar essa instância.
método
O método de implementação do modo singleton é privatizar o construtor da classe, para que a instância da classe não possa ser criada por meio da palavra-chave new. Em seguida, defina um método estático na classe para obter a única instância da classe e, se a instância não existir, crie uma nova instância e retorne-a.
por exemplo
Aqui está um exemplo de uma classe GameManager implementada usando o padrão 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()
{
// ...
}
}
No exemplo acima, o construtor da classe GameManager é privado e a propriedade Instance fornece um ponto de acesso global para a única instância de GameManager. Outras classes podem acessar instâncias de GameManager por meio de GameManager.Instance e chamar seus métodos públicos.
padrão de fábrica
introduzir
O padrão de fábrica é um padrão de design comum que delega a criação de objetos a uma classe de fábrica, dissociando o código do cliente da instanciação de classes concretas.
método
O método de implementação do padrão de fábrica é definir uma classe ou interface de fábrica abstrata e declarar um método de fábrica para criar objetos nela. Em seguida, crie uma classe fábrica concreta para implementar um método fábrica que irá instanciar um objeto da classe concreta e retorná-lo. O código do cliente só precisa chamar o método de fábrica para obter o objeto desejado sem instanciar a classe concreta diretamente.
por exemplo
Aqui está um exemplo de uma classe EnemyFactory implementada usando o padrão 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();
}
}
No exemplo acima, Enemy é uma classe base abstrata e Slime e Goblin são subclasses concretas. EnemyFactory é uma classe fábrica abstrata, e SlimeFactory e GoblinFactory são classes fábrica concretas, que implementam respectivamente o método CreateEnemy e retornam instâncias de Slime e Goblin. O código do cliente pode usar o EnemyFactory para criar os objetos Enemy desejados sem instanciar Slime ou Goblin diretamente.
padrão de observador
introduzir
O modo Observer é um padrão de design comum, que define uma dependência um-para-muitos, permitindo que vários objetos observadores monitorem um objeto sujeito ao mesmo tempo, quando o objeto sujeito muda, todos os seus observadores serão notificados e atualizados.
método
O padrão observador é implementado definindo um objeto sujeito que mantém uma lista de observadores e fornece métodos para registrar e notificar observadores. Os objetos observadores implementam um método de atualização que é chamado quando o objeto sujeito é alterado. O código do cliente pode monitorar a alteração do objeto sujeito registrando um observador e executar as operações correspondentes no método de atualização.
por exemplo
A seguir está um exemplo de classes Subject e Observer implementadas usando o padrão Observer:
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()
{
// ...
}
}
No exemplo acima, Subject é uma classe de assunto que mantém uma lista de observadores e fornece os métodos Attach, Detach e Notify para registrar, cancelar o registro e notificar observadores. Observer é uma classe de observador abstrata e ConcreteObserver é uma classe de observador concreta, que implementa o método update. O código do cliente pode escutar mudanças no objeto sujeito criando uma instância de ConcreteObserver e registrando-a com o Subject.
modelo de delegação
introduzir
O padrão delegado é um padrão de design comum que usa objetos delegados para representar funções e passá-los como parâmetros para outras funções. Isso organiza o código em módulos menores, facilitando a manutenção e a reutilização.
método
O padrão delegado é implementado definindo um tipo delegado e passando-o como parâmetro para outras funções. Outras funções podem passar sua implementação para o objeto delegado, chamando assim a função representada pelo objeto delegado.
por exemplo
Aqui está um exemplo de uma classe EventHandler implementada usando o padrão 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()
{
// ...
}
}
No exemplo acima, EventHandler é um tipo delegado, EventPublisher é uma classe publicadora de eventos, que define um evento OnEvent e aciona o evento no método RaiseEvent. EventSubscriber é uma classe de assinante de eventos que define um método HandleEvent que pode ser implementado como um delegado EventHandler. O código do cliente pode criar instâncias de EventPublisher e EventSubscriber e passar o método HandleEvent de EventSubscriber para o evento OnEvent de EventPublisher, implementando assim o padrão de delegação.
modo de estado
introduzir
O padrão de estado é um padrão de design comum que separa o comportamento e o estado de um objeto para que as alterações no estado não afetem diretamente o comportamento do objeto.
método
O método de implementação do padrão de estado é definir uma classe de estado abstrato e várias classes de estado concreto, cada classe de estado concreto representa um estado específico e implementa um conjunto de métodos definidos na classe de estado abstrato. Em seguida, defina uma classe de contexto que contenha variáveis de membro da classe de estado abstrato, que representam o estado atual e implemente um conjunto de métodos na classe de contexto para alternar estados e chamar métodos do estado atual.
por exemplo
Aqui está um exemplo das classes PlayerState e Player implementadas usando o padrão 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
{