(翻译)构建自定义组件

Tips：
如果你还不清楚MVC的话建议你读这篇Model—View—Controller结构的这篇文章

using UnityEngine;
using System;
using System.Collections;

public class Demo : MonoBehaviour
{
public static event EventHandler apocolypseEvent;

void Start ()
{
CreateLocalScopedInstances();

GC.Collect();

if (apocolypseEvent != null)
apocolypseEvent(this, EventArgs.Empty);
}

void CreateLocalScopedInstances ()
{
new Mortal();
new Immortal();
}
}

public class Mortal
{
public Mortal ()
{
Debug.Log("A mortal has been born");
}

~ Mortal ()
{
Debug.Log("A mortal has perished");
}
}

public class Immortal
{
public Immortal ()
{
Debug.Log("An immortal has been born");
Demo.apocolypseEvent += OnApocolypticEvent;
}

~ Immortal ()
{
// This won't ever be reached
Debug.Log("An immortal has perished");
Demo.apocolypseEvent -= OnApocolypticEvent;
}

void OnApocolypticEvent (object sender, EventArgs e)
{
Debug.Log("I'm alive!!!");
}
}

Exit the Rabbit Trail

On to the Code!

Interfaces

using UnityEngine;
using System.Collections;

public interface IPart
{
IWhole whole { get; set; }
bool allowed { get; set; }
bool running { get; }

void Check ();
void Assemble ();
void Resume ();
void Suspend ();
void Disassemble ();
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public interface IWhole
{
string name { get; set; }
bool allowed { get; set; }
bool running { get; }
IWhole parent { get; set; }
IList<IWhole> children { get; }
IList<IPart> parts { get; }

void AddChild (IWhole whole);
void RemoveChild (IWhole whole);
void RemoveChildren ();

T AddPart<T> () where T : IPart, new();
void RemovePart (IPart p);

T GetPart<T>() where T : class, IPart;
T GetPartInChildren<T>() where T : class, IPart;
T GetPartInParent<T>() where T : class, IPart;
List<T> GetParts<T>() where T : class, IPart;
List<T> GetPartsInChildren<T>() where T : class, IPart;
List<T> GetPartsInParent<T>() where T : class, IPart;

void Check ();
void Destroy ();
}

Implementation

using UnityEngine;
using System;
using System.Collections;

public class Part : IPart
{
#region Fields / Properties
public IWhole whole
{
get
{
return owner != null ? owner.Target as IWhole : null;
}
set
{
owner = (value != null) ? new WeakReference(value) : null;
Check();
}
}
WeakReference owner = null;

public bool allowed
{
get { return _allowed; }
set
{
if (_allowed == value)
return;

_allowed = value;
Check();
}
}
bool _allowed = true;

public bool running
{
get { return _running; }
private set
{
if (_running == value)
return;

_running = value;
if (_running)
{
if (!_didAssemble)
{
_didAssemble = true;
Assemble();
}
Resume();
}
else
{
Suspend();
}
}
}
bool _running = false;

bool _didAssemble = false;
#endregion

#region Public
public void Check ()
{
running = ( allowed && whole != null && whole.running );
}

public virtual void Assemble ()
{

}

public virtual void Resume ()
{

}

public virtual void Suspend ()
{

}

public virtual void Disassemble ()
{

}
#endregion
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public sealed class Whole : IWhole
{
#region Fields / Properties
public string name { get; set; }

public bool allowed
{
get { return _allowed; }
set
{
if (_allowed == value)
return;
_allowed = value;
Check();
}
}
bool _allowed = true;

public bool running
{
get { return _running; }
private set
{
if (_running == value)
return;
_running = value;
for (int i = _parts.Count - 1; i >= 0; --i)
_parts[i].Check();
}
}
bool _running = true;

public IWhole parent
{
get { return _parent; }
set
{
if (_parent == value)
return;

if (_parent != null)
_parent.RemoveChild(this);

_parent = value;

if (_parent != null)
_parent.AddChild(this);

Check ();
}
}
IWhole _parent = null;

public IList<IWhole> children { get { return _children.AsReadOnly(); }}
public IList<IPart> parts { get { return _parts.AsReadOnly(); }}

List<IWhole> _children = new List<IWhole>();
List<IPart> _parts = new List<IPart>();
bool _didDestroy;
#endregion

#region Constructor & Destructor
public Whole ()
{

}

public Whole (string name) : this ()
{
this.name = name;
}

~ Whole ()
{
Destroy();
}
#endregion

#region Public
public void Check ()
{
CheckEnabledInParent();
CheckEnabledInChildren();
}

public void AddChild (IWhole whole)
{
if (_children.Contains(whole))
return;

_children.Add(whole);
whole.parent = this;
}

public void RemoveChild (IWhole whole)
{
int index = _children.IndexOf(whole);
if (index != -1)
{
_children.RemoveAt(index);
whole.parent = null;
}
}

public void RemoveChildren ()
{
for (int i = _children.Count - 1; i >= 0; --i)
_children[i].parent = null;
}

public T AddPart<T> () where T : IPart, new()
{
T t = new T();
t.whole = this;
_parts.Add(t);
return t;
}

public void RemovePart (IPart p)
{
int index = _parts.IndexOf(p);
if (index != -1)
{
_parts.RemoveAt(index);
p.whole = null;
p.Disassemble();
}
}

public T GetPart<T>() where T : class, IPart
{
for (int i = 0; i < _parts.Count; ++i)
if (_parts[i] is T)
return _parts[i] as T;
return null;
}

public T GetPartInChildren<T>() where T : class, IPart
{
T retValue = GetPart<T>();
if (retValue == null)
{
for (int i = 0; i < _children.Count; ++i)
{
retValue = _children[i].GetPartInChildren<T>();
if (retValue != null)
break;
}
}
return retValue;
}

public T GetPartInParent<T>() where T : class, IPart
{
T retValue = GetPart<T>();
if (retValue == null && parent != null)
retValue = parent.GetPartInParent<T>();
return retValue;
}

public List<T> GetParts<T>() where T : class, IPart
{
List<T> list = new List<T>();
AppendParts<T>(this, list);
return list;
}

public List<T> GetPartsInChildren<T>() where T : class, IPart
{
List<T> list = GetParts<T>();
AppendPartsInChildren<T>(this, list);
return list;
}

public List<T> GetPartsInParent<T>() where T : class, IPart
{
List<T> list = new List<T>();
AppendPartsInParent<T>(this, list);
return list;
}

public void Destroy ()
{
if (_didDestroy)
return;

_didDestroy = true;
allowed = false;
parent = null;

for (int i = _parts.Count - 1; i >= 0; --i)
_parts[i].Disassemble();

for (int i = _children.Count - 1; i >= 0; --i)
_children[i].Destroy();
}
#endregion

#region Private
void CheckEnabledInParent ()
{
bool shouldEnable = allowed;
IWhole next = parent;
while (shouldEnable && next != null)
{
shouldEnable = next.allowed;
next = next.parent;
}
running = shouldEnable;
}

void CheckEnabledInChildren ()
{
for (int i = _children.Count - 1; i >= 0; --i)
_children[i].Check();
}

void AppendParts<T> (IWhole target, List<T> list) where T : class, IPart
{
for (int i = 0; i < target.parts.Count; ++i)
if (target.parts[i] is T)
list.Add(target.parts[i] as T);
}

void AppendPartsInChildren<T>( IWhole target, List<T> list ) where T : class, IPart
{
AppendParts<T>(target, list);
for (int i = 0; i < target.children.Count; ++i)
AppendPartsInChildren<T>(target.children[i], list);
}

void AppendPartsInParent<T>( IWhole target, List<T> list ) where T : class, IPart
{
AppendParts<T>(target, list);
if (target.parent != null)
AppendPartsInParent<T>(target.parent, list);
}
#endregion
}

Another Demo

using UnityEngine;
using System;
using System.Collections;

public class Demo : MonoBehaviour
{
public static event EventHandler apocolypseEvent;

void Start ()
{
CreateLocalScopedInstances();

GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

if (apocolypseEvent != null)
apocolypseEvent(this, EventArgs.Empty);
}

void CreateLocalScopedInstances ()
{
IWhole whole = new Whole("Mortal");
whole.AddPart<MyPart>();
}
}

public class MyPart : Part
{
public override void Resume ()
{
base.Resume ();
Debug.Log("MyPart is now Enabled on " + whole.name);
Demo.apocolypseEvent += OnApocolypticEvent;
}

public override void Suspend ()
{
base.Suspend ();
Debug.Log("MyPart is now Disabled");
Demo.apocolypseEvent -= OnApocolypticEvent;
}

~ MyPart ()
{
Debug.Log("MyPart has perished");
}

void OnApocolypticEvent (object sender, EventArgs e)
{
// This won't actually be reached
Debug.Log("I'm alive!!!");
}
}