代码之家 › 专栏 › 技术社区 › KrisTrip

如何使一个方法采用两种不同的类型

overloading generics c#

KrisTrip · 技术社区 · 14 年前

我知道这可能是个很简单的问题,但我现在脑子里有个屁。我正在尝试创建一个方法,该方法可以采用两个自定义类型之一。基本上,这两种类型的方法体是相同的,因为它们都有一个name属性(我正在比较用于排序的name属性)。我该怎么做?

我的第一个想法是用两种类型作为参数来重载方法:

int Compare(Type1 first, Type1 second)
int Compare (Type2 first, Type2 second)

但是这些方法的主体最终是相同的,因此看起来像是浪费。

我的下一个想法是使用泛型,但这似乎不正确,因为我并没有真正使它成为泛型,因为它只能用于2个特定类型。

说明:“自定义”类型实际上不是我的自定义类型。我的意思是它们不是内置类型。我无法控制这些类型或继承层次结构中的内容。他们恰好都有name属性。

7 回复 | 直到 14 年前

Anthony Pegram 14 年前

如果两个类型派生自相同的基或使用相同的接口,并且没有其他类使用基和/或接口,那么generic仍然是一个选项。

int Compare<T>(T first, T second) where T : IHasName

除此之外,两个超负荷是解决问题的方法。

注意:如果您有.NET 4,您可以使它成为运行时的东西,并使该方法成为动态的。

int Compare(dynamic first, dynamic second)

在这种情况下,您向它扔的任何东西都将编译,但如果 Name 属性不存在。

就个人而言,如果我不能修改类型以使用公共接口,那么我将使用重载并获得编译时安全性。

Eric Lippert 14 年前

奇怪的是,到目前为止,还没有人发布我认为是显而易见的选择: 以名称作为比较的参数 . 使 呼叫者 从对象中获取name属性。如果需要使用的所有方法都是名称,那么为什么要传入对象的其余部分?

如果你需要抽象出“我可以从这件事中得到一个名字”的概念,那么就这样做:

例子:

int Compare(string name1, string name2) { ... whatever ... }
int Compare<T>(T t1, T t2, Func<T, string> getName)
{
    return Compare(getName(t1), getName(t2));
}

现在你可以说:

Compare(car1, car2, c=>c.Name);
Compare(employee1, employee2, e=>e.Name);

等等。

porges 14 年前

好吧,我在第一个回答中完全错了你的问题。这里有一个更好的。)

超载是最好的选择。因为比较结果只取决于 Name ,生成一个这样做的方法那个比较,然后称之为:

private int Compare(string first, string second)
{
    // do comparison
}

public int Compare(Type1 first, Type1 second)
{
    return Compare(first.Name, second.Name):
}

public int Compare(Type2 first, Type2 second)
{
    return Compare(first.Name, second.Name);
}

编辑:

由于您有多个项目,您可以做两件事:

public int Compare(string first1, string second1, X first2, X second2 ...

但那会变得有点难看。另一种方法是提供一个投影来提取值:

private int Compare<T>(T first, T second, Func<T,Tuple<string,int,TypeX,TypeY>> projection)
{
    // test for first==null, second==null, etc...

    var nicerFirst = projection(first);
    var nicerSecond = projection(second);

    // compare objects using nicerFirst.Item1, nicerFirst.Item2, etc.
}

然后你的比较看起来像:

int Compare(Type1 first, Type1 second)
{
    return Compare(first, second, x => Tuple.Create(x.Name, x.Int, x.X, x.Y));
}

Bertvan 14 年前

如果可以只有与2个类型一起使用,然后进行2个重载。

Guffa 14 年前

重载方法将是使它只需要两个特定类型的好方法。为了避免重复代码,可以在场景后面使用泛型:

public int Compare(Type1 first, Type1 second) {
  return Compare<Type1>(first, second);
}

public int Compare(Type2 first, Type2 second) {
  return Compare<Type2>(first, second);
}

private int Compare<T>(T first, T second) {
  ...
}

Auxiliary 14 年前

也许不是最好的解决方案,但我想到的是: 你的方法如下:

int MainCompare(Type1 first1, Type1 second1, Type2 first2, Type2 second2, bool firsttype){...}

然后你可以用一行来比较两种方法。

int compare(Type1 first, Type1 second){
    return MainCompare(first, second, null, null, true);
}


int compare(Type2 first, Type2 second){
    return MainCompare(null, null, first, second, false);
}

您的mainCompare将根据使用的类型稍微改变一点。

Steven Evers 14 年前

这可能是一个不切实际的解决方案,但是您可以为这两个类制作适配器,并让它们实现一个公共接口:

public class MyType1 : ICommonInterface, Type1
{
    // Where you can define 'Somethin' in the common interface
    public string Something 
    { 
        get { return base.Something; } 
        set { base.Something = value; } 
    }

     /* ... */
}

public class MyType2 : ICommonInterface, Type2
{
    // If there is no base.Something on Type2, you can re-name it assuming 
    // its intent is the same as Something
    public string Something
    {
        get { return base.SomethingElse; } 
        set { set base.SomethingElse = value; }
    }        
}

然后,您可以基本上实现@Anthony Pegram(+1)所拥有的:

int Compare<T> (T first, T second) where T : ICommonInterface
{
    return first.Something.CompareTo(second.Something);
}