Question

我正在从Entity对象返回值。其中一些是String打字的，有些则不是。现在，我做了如下快速解决方案。

private String GetStringValue(Entity entity, String attribute, String substitute = "")
{
  if(entity.Contains(attribute)
    return entity[attribute] as String;
  return substitute;
}

private String GetIntValue(Entity entity, String attribute, int substitute = 0)
{
  if(entity.Contains(attribute)
    return entity[attribute] as int;
  return substitute;
}

然后我记得有一种泛型类型的语法（类似<TypeX>）。但是，我的问题是，是否有必要开始更改现有代码。我需要在两个地方（返回类型和替换类型）更改方法的签名，但我担心我还需要在方法中执行一些复杂的编码。

另一方面，我有一种很好的方式来处理所有类型的可能性（我有预感，我们将使用的不仅仅是字符串和整数。

Answer 1

您必须在三个位置更改方法的签名，因为您还必须添加通用参数：

private T GetValue<T>(Entity entity, String attribute, T substitute)

在方法中，不需要任何复杂的编码;用string分别替换当前出现的int或T就足够了。（请注意，as运算符只能在T限制为引用类型时应用 - 您可能不想这样做，因为int是值类型。）

请注意，此方法存在两个问题，您可能会考虑这些问题：

这种通用方法将支持“所有可能的类型”，但它也支持任何类型不可能（用户可以自由指定他们喜欢T的任何类型，并且在仍支持T和string的情况下，无法限制int。
您无法为每种类型指定任意默认替换值。您可以做的是声明substitute的默认值，即default(T)，但至少对string来说，这不是空字符串，而是null。

Answer 2

如果您不想更改方法签名，可以编写泛型函数并从所有这些非泛型版本中调用它。

private String GetStringValue(...){
    return GetValue<String>(...);
}

顺便说一句，您正在寻找Generic methods

例如（来自msdn）

static void Swap<T>(ref T lhs, ref T rhs)
{
    T temp;
    temp = lhs;
    lhs = rhs;
    rhs = temp;
}

...

Swap<int>(ref a, ref b);

或只是

Swap(ref a, ref b); //type int is infered based on type of arguements and method signature

Answer 3

你是对的“类似的东西”是通用的方法。 Check out generic methods there. 下一个方法看起来很适合您的目的。

   private  static T GetValue<T>(Entity entity, string attribute, T defaultValue)
        {
            if (!entity.Contains(attribute))
                return defaultValue;

            return  (T)entity[attribute];
        }

编辑：根据w0lf的评论更新。

Answer 4

什么类是Entity？假设它是一个自定义类，使它也是通用的，那么这可以工作：

private T Get<T>(Entity<T> entity, T attribute, T substitute = default(T))
{
    if (entity.Contains(attribute))
        return entity[attribute];
    return substitute;
}

您可以通过以下方式检索值：

var entity = new Entity<string>();
string val = Get<string>(entity, "attr", "subst");

Answer 5

您应该定义Entity<T>班级：

public class Entity<T>
{
    // TODO: implement
    public T this[string i] { get; set; }

    // TODO: implement
    internal bool Contains(string attribute)
    {
        return true;
    }
    // TODO: implement
    // other properties and methods       
}

您可以使用通用方法：

private T GetStringValue<T>(Entity<T> entity, String attribute, T substitute = default(T))
{
    if (entity.Contains(attribute))
        return entity[attribute];
    return substitute;
}

Answer 6

如果可以在方法中概括代码，我绝对建议以通用方式使用它。它使类更小，更易读，如果需求发生变化，您只需更改一个方法即可。您的方法看起来很容易变得通用。

private T GetIntValue<T>(Entity entity, String attribute, T substitute = default(T))
{
    if(entity.Contains(attribute))
        return (T)entity[attribute];
    return substitute;
}

如果要执行更多逻辑，您还可以使用包含不同类型函数的字典：

private IDictionary<Type, Func<Entity, string, object>> actions;

private void InitActions()
{
    actions = new Dictionary<Type, Func<Entity, string, object>>
        {
            {
                typeof (string), (entity, attribute) =>
                    {
                        // this could be your custom code for string
                        return entity[attribute];
                    }
            },
            {
                typeof (int), (entity, attribute) =>
                    {
                        // this could be your custom code for int
                        return entity[attribute];
                    }
            }
        };
}

private T GetIntValue<T>(Entity entity, String attribute, T substitute = default(T))
{
    if (entity.Contains(attribute) && actions.ContainsKey(typeof (T)))
    {
        Func<Entity, string, object> action = actions[typeof (T)];
        return (T)action(entity, attribute);
    }
    return substitute;
}

返回不同类型时是否建议使用多种方法？

6 个答案: