13

我经常看到（例如在许多模拟库中）使用泛型类型参数代替类型参数的方法System.Type。我特别讨论的是泛型类型仅在typeof(T)操作中使用的情况（即在方法中的任何地方都没有使用类型 T 的实例，并且 T 没有用于返回类型或其他参数）。

例如考虑以下方法：

public string GetTypeName(System.Type type) { return type.FullName; }

这种方法通常伴随着一个通用版本：

public string GetTypeName<T>() { return GetTypeName(typeof(T)); }

问题 是不好的做法还是好的做法？
这是语法糖还是有更多？

我认为这是滥用语言功能来缩写对接受类型参数的方法的调用System.Type

你会认为这是一种气味吗？应该避免这种情况吗？或者这实际上是一个好习惯（提供一个通用方法作为避免打字的快捷方式typeof()）。

以下是我能想到的使用这种模式的一些实际问题：

  1. 如果添加了非 System.Type 类型的参数 -可能需要将方法（如果参数的顺序在语义上重要）重写为非泛型版本（否则一些参数将是泛型类型参数，而一些将是常规参数）。
  2. 它需要两种方法（在编译时类型未知的情况下，泛型和非泛型）。因此添加了几乎没有意义的单元测试。

另一方面，这是一种常见的做法（大多数人总是正确的，对吗？）但更重要的是，当我对需要在编译时已知的 System.Type 类型的单个参数的代码进行提取方法重构时，ReSharper 更喜欢该签名（并且我学会了接受他们的建议，尽管不是出于信仰，而是认真）。

4

6 回答 6

3

我认为您需要考虑文档。这些方法的作用有多明显？如果您有两种方法（一种带有Type类型参数，一种带有类型参数），用户需要同时查看并选择。不查看您的代码的人可能不会意识到第二个代码只是调用了第一个代码。

两者都使用绝对有意义的地方是，当可以使用类型参数并且Type版本有某种回退时。例如：

object GetThingOfType(Type type) { ... }

T GetThingOfType<T>() { return (T)GetThingOfType(typeof(T)); }

要考虑的另一件事：类型参数必须始终显式编写。如果可能会对同一个类型对象执行多个操作，那么使用类型参数是没有帮助的。考虑这样的事情：

var t = typeof(string);
var name = GetTypeName(t);
var assemblyName = t.Assembly.FullName;

即使我知道类型是string，我也不应该GetTypeName<string>在这里写，因为我会重复自己。通过给我一个我通常最好不要选择的选项，你增加了一些不必要的复杂性。

更模糊的一点是 IDE 对 XML 文档的支持。您像这样记录类型参数：

<typeparam name="T">important information</typeparam>

然后如果你输入GetTypeName<C#，Visual Studio 会显示“T：重要信息”。但是，由于某种原因，当您输入GetTypeName(OfVisual Basic 时，它不会（截至 2012 年）。

于 2013-10-16T15:13:38.010 回答
3

你是对的：考虑方法的语义。它是在类型的实例上运行，还是在类型本身上运行？

如果它在实例上运行，那么它应该是一个通用方法。如果它在类型上，则将其设为 type 的参数Type。

所以在你的例子中我会说

public string GetTypeName(System.Type type) { return type.FullName; }

然而

public static int Count<TSource>(this IEnumerable<TSource> source)

正在对source类型的实例进行操作IEnumerable<TSource>。

总的来说，我看到泛型被滥用多于使用良好。任何执行 typeof(T) 或更糟的通用方法实现，使用任何类型的反射在我看来都不是真正的通用方法，而是一种滥用。毕竟，泛型意味着无论类型参数如何，它的工作原理都是一样的，不是吗？

所以，总而言之，我同意你的看法——它闻起来很香。

于 2013-10-16T16:58:03.143 回答
1

我不使用该string GetName<T>() { return typeof(T).Name; }模式，因为它是设计模式的误用（误用可能很强烈，但我想不出正确的词），这是泛型的原因，即：泛型类型参数用于编译器和JITter（请参阅此问题的答案），以便它们可以生成特定于类型的存储、参数、堆栈变量等。

使用它作为在运行时将类型参数传递给我的便捷方法，我闻起来很臭。有时typeof(T)是必要的，但我发现它们很少见，通常只在使用泛型做复杂的事情时才需要，而不是简单的类型安全之类的事情。如果我看到它，我肯定会停下来问自己为什么它在那里。

于 2013-10-16T17:21:30.597 回答
0

正如已经说过的，在我看来，这只是个人喜好问题。根据我的经验，大多数接受Type 类型参数的方法都可以使用附带的扩展方法在语法上“甜化”。

因此，在您的示例中，我会将第二种方法作为扩展。使用这种方法，您可以获得第二个问题的解决方案 - 不需要不必要的单元测试。但是，第一个仍然存在；但是，添加参数无论如何都需要重构，因此它将提供一个机会来更改扩展方法的使用者，以便他们使用原始方法的修改版本。

当然，这只是个人意见。

于 2013-10-16T13:52:36.567 回答
0

泛型方法比具有类型参数的方法具有优势Type，因为它可以使用提供的类型引用其他泛型事物。这在以下场景中特别有用：

public string GetTypeName<T>()
{ 
    return Cache<T>.TypeName;
}

private static class Cache<T>
{
    public static readonly TypeName = GetTypeName(typeof(T));
}

这个缓存很简单，不需要乱用字典，而且它是自动线程安全的。

话虽这么说，如果实现不使用这种可能性，那么两者之间的差异只是表面上的。

于 2013-10-16T14:10:36.463 回答
0

处理类型的方法通常这样做：处理类型。

IMO，Class.Method<SomeType>();比Class.Method(typeof(SomeType));

但我想这是一个见仁见智的问题。

考虑 LINQ .OfType<T>()，例如：

personlist.OfType<Employee>().Where(x => x.EmployeeStatus == "Active");

相对：

personlist.OfType(typeof(Employee)).Where(x => ((Employee)x).EmployeeStatus == "Active");

你更喜欢哪一个？

于 2013-08-15T16:26:55.113 回答