将类似的方法移动到通用实现中

Question

我正在尝试重构一些代码，并且不得不承认我对泛型的概念不熟悉。

我有一个基类：

BaseVarDef.cs：

using UnityEngine;
public abstract class BaseVarDef<T> : ScriptableObject
{
    [Multiline]
    public string DeveloperDescription = "";

    public T Value;

    public void SetValue(T value)
    {
        Value = value;
    }

}

然后我有几个由此派生的类。但它们都包含相同的 3 个方法，我想将它们重构为这个通用基类。唯一的区别是他们期望当前定义它们的泛型类型或类。

FloatVar.cs

using UnityEngine;
[CreateAssetMenu(fileName = "New FloatVar", menuName = "Variables/FloatVar")]
public class FloatVar : BaseVarDef<float>
{
    public void SetValue(FloatVar value)
    {
        Value = value.Value;
    }
    public void ApplyChange(float amount)
    {
        Value += amount;
    }
    public void ApplyChange(FloatVar amount)
    {
        Value += amount.Value;
    }
}

StringVar.cs

using UnityEngine;
[CreateAssetMenu(fileName = "New StringVar", menuName = "Variables/StringVar")]
public class StringVar : BaseVarDef<string>
{
    public void SetValue(StringVar value)
    {
        Value = value.Value;
    }
    public void ApplyChange(string amount)
    {
        Value += amount;
    }
    public void ApplyChange(StringVar amount)
    {
        Value += amount.Value;
    }
}

有没有办法将 SetValue 和 2 个重载的 ApplyChange 方法重构为 BaseVarDef.cs？

提前致谢

Answer 1

我认为你可以在基类中定义所有的 Apply 和 Set

public abstract class BaseVarDef<T>
{
    public string DeveloperDescription = "";

    public T Value;

    public void SetValue(T value)
    {
        Value = value;
    }
    public void SetValue(BaseVarDef<T> value)
    {
        Value = value.Value;
    }
    public void ApplyChange(T amount)
    {
        AddValue(amount);
    }
    public void ApplyChange(BaseVarDef<T> amount)
    {
        AddValue(amount.Value);
    }

    protected abstract void AddValue(T val);
}

public class FloatVar : BaseVarDef<float>
{
    protected override void AddValue(float val)
    {
        Value += val;
    }
}

Answer 2

如果您可以将这些方法添加到原始基类（然后从中删除abstract），那么您只需执行BaseVarDef<string> 或BaseVarDef<float>。不再需要 FloatVar 或 StringVar 类！

这里棘手的部分是+= 运算符，它不能应用于泛型（至少我知道没有约束允许您指定类型实现运算符）。

因此，您可以创建一个抽象的Add 方法，派生类必须按照 Svetlana 的描述实现该方法，或者您可以使用dynamic，如下所示（并且完全不需要派生类）。

dynamic 的一个问题是dynamic 类型没有编译时检查，所以它不是万无一失的。 T 类型必须重载 + 运算符，否则会出现运行时异常。您可以通过将行 Value = amt + val; 包装在 try/catch 中来避免这种情况，但随后您可能会得到意外行为。

public class BaseVarDef<T>
{
    public string DeveloperDescription { get; set; } = "";

    public T Value { get; private set; }

    public void SetValue(T value)
    {
        Value = value;
    }

    public void SetValue(BaseVarDef<T> value)
    {
        Value = value.Value;
    }

    public void ApplyChange(T amount)
    {
        AddToValue(amount);
    }

    public void ApplyChange(BaseVarDef<T> amount)
    {
        AddToValue(amount.Value);
    }

    private void AddToValue(T amount)
    {
        dynamic amt = amount;
        dynamic val = Value;

        // Empty catch to avoid runtime exception if 'T' doesn't support the '+' operator
        try { Value = amt + val; }
        catch { }           
    }
}