在抽象类中具有主克隆方法

Question

I am using an ECS architecture where components of the abstractcomponent class use value types only, and never reference types. I would like for the base abstractcomponent class to contain 1 and 1 shallowcopy method without having to reimplement that for each individual concrete class.

ANy ideas? C#?

/// <summary>
/// Only an empty classification/tag class. (Every last component is POD -- no exceptions!)
/// </summary>
public abstract class AbstractComponent
{
    public T CreateShallowClone(AbstractComponent c) where T : AbstractComponent
    {
        return (T)c.MemberwiseClone();
    }
}


[Serializable]
public sealed class Entity : Identifiable
{
    public Entity() : base()
    {

    }

    public bool IsEnabled { get; set; } = false;

    private Dictionary<Type, AbstractComponent> Components { get; set; } = new Dictionary<Type, AbstractComponent>();

    public void AddComponent(AbstractComponent c)
    {
        Components.Add(c.GetType(), c);
    }

    public void RemoveComponent<T>() where T : AbstractComponent<T>
    {
        if (!Components.Remove(typeof(T))) {
            throw new KeyNotFoundException();
        }
    }

    public bool HasComponent<T>() where T : AbstractComponent<T>
    {
        if (Components.ContainsKey(typeof(T)))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public T GetComponent<T>() where T : AbstractComponent<T>
    {
        AbstractComponent<T> c;
        if (!Components.TryGetValue(typeof(T), out c))
        {
            throw new KeyNotFoundException();
        }
        return c as T;
    }

    public void Destroy()
    {
        Components = null;
    }
}

Answer 1

If I understand right, you can use generics this way.

public abstarct class AbstractComponent<TFinalComponent> where TFinalComponent : AbstractComponent<TFinalComponent> {
    public TFinalComponent CreateShallowClone() {
        return (TFinalComponent)this.MemberwiseClone();
    }
}

EDIT: Now I finally see the point from your source code. The generics are unnecessary. All can be done without them.

public abstract class AbstractComponent {
    public AbstractComponent CreateShallowClone() {
        return (AbstractComponent)this.CreateShallowClone();
    }
}

public sealed class MyCustomComponent : AbstractComponent {
    public string Name { get; set; }
    public int Age { get; set; }
}

public sealed class Entity {
    public bool IsEnabled { get; set; }
    private Dictionary<Type, AbstractComponent> components = new Dictionary<Type, AbstractComponent>();

    public void AddComponent(AbstractComponent component) {
        if (null == component) { throw new ArgumentNullException("component"); }

        this.components.Add(component.GetType(), component);
    }
    public bool RemoveComponent(Type componentType) {
        if (null == componentType) { throw new ArgumentNullException("componentType"); }

        return this.components.Remove(componentType);
    }
    public bool HasComponent(Type componentType) {
        if (null == componentType) { throw new ArgumentNullException("componentType"); }

        return this.components.ContainsKey(componentType);
    }
    public AbstractComponent FindComponent(Type componentType) {
        if (null == componentType) { throw new ArgumentNullException("componentType"); }

        AbstractComponent result;
        this.components.TryGetValue(componentType, out result);
        return result;
    }
    public AbstractComponent GetComponent(Type componentType) {
        if (null == componentType) { throw new ArgumentNullException("componentType"); }

        var result = this.FindComponent(componentType);
        if (null == result) {
            throw new ArgumentException("The component of the specified type was not found.", "componentType");
        }

        return result;
    }
    public TComponent GetComponent<TComponent>() where TComponent : AbstractComponent {
        return (TComponent)this.GetComponent(typeof(TComponent));
    }

    public void Destroy() {
        this.components.Clear();
    }

    public Entity Clone() {
        var result = new Entity();
        foreach (var item in this.components.Values) {
            var clonedItem = item.CreateShallowClone();
            result.AddComponent(item);
        }

        return result;
    }
}

Some notes:

• method RemoveComponent() does not need generics, generaly it's better to have non-generic methods (if you can choose) because caller does not need know concrete type before compile-time
• method RemoveComponent() does not need throw exception when component was not present. the result will be same for both cases - the component will be not present in the entity
• method FindComponent() can be used instead of calling HasComponent() and GetComponent . it's better for perfofmance.

• method GetComponent() is overloaded

  • one overload is non-generic for same reasons like RemoveComponent() method.
  • one overload is generic for better usage in code:

  var custom = entity.GetComponent();

  • method `Destroy()' just clear the components. it's better than setting that null because user of the class does not have any way how to know if the instance is "destroyed" and any call on these entity will cause exception.