这个约束存在于。net 7中。

查看这篇。net博客文章和实际文档。

从。net 7开始，你可以使用接口如INumber和IFloatingPoint来创建程序，例如:

using System.Numerics;

Console.WriteLine(Sum(1, 2, 3, 4, 5));
Console.WriteLine(Sum(10.541, 2.645));
Console.WriteLine(Sum(1.55f, 5, 9.41f, 7));

static T Sum<T>(params T[] numbers) where T : INumber<T>
{
    T result = T.Zero;

    foreach (T item in numbers)
    {
        result += item;
    }

    return result;
}

innumber在系统中。数字名称空间。

还有诸如IAdditionOperators和IComparisonOperators这样的接口，因此您可以通用地使用特定的操作符。

这是没有限制的。对于任何想要使用泛型进行数值计算的人来说，这都是一个真正的问题。

更进一步说，我们需要

static bool GenericFunction<T>(T value) 
    where T : operators( +, -, /, * )

甚至

static bool GenericFunction<T>(T value) 
    where T : Add, Subtract

不幸的是，你只有接口，基类和关键字struct(必须是值类型)，class(必须是引用类型)和new()(必须有默认构造函数)

你可以把数字包装在其他东西(类似于INullable<T>)，就像这里的codeproject。

您可以在运行时应用该限制(通过对操作符进行反射或检查类型)，但这首先就失去了使用泛型的优势。

我想知道和samjudson一样，为什么只对整数有效?如果是这样的话，你可能想要创建一个helper类或者类似的东西来保存你想要的所有类型。

如果你想要的只是整数，不要使用泛型，那不是泛型;或者更好的是，通过检查其类型来拒绝任何其他类型。

十多年后，这个特性终于出现在。net 7中。最通用的接口是INumber<TSelf>而不是innumeric(在系统中。数字名称空间)，它不仅包含整数类型。要只接受整数类型，可以考虑使用IBinaryInteger<TSelf>。以你的原型，神秘的IntegerFunction为例:

static bool IntegerFunction<T>(T value) where T : IBinaryInteger<T> {
    return value > T.Zero;
}

Console.WriteLine(IntegerFunction(5));         // True
Console.WriteLine(IntegerFunction((sbyte)-5)); // False
Console.WriteLine(IntegerFunction((ulong)5));  // True

下面的答案(现在已经过时了)是作为一个历史的角度。

c#不支持这一点。在接受Bruce Eckel的采访时，Hejlsberg描述了没有实现该功能的原因:

And it's not clear that the added complexity is worth the small yield that you get. If something you want to do is not directly supported in the constraint system, you can do it with a factory pattern. You could have a Matrix<T>, for example, and in that Matrix you would like to define a dot product method. That of course that means you ultimately need to understand how to multiply two Ts, but you can't say that as a constraint, at least not if T is int, double, or float. But what you could do is have your Matrix take as an argument a Calculator<T>, and in Calculator<T>, have a method called multiply. You go implement that and you pass it to the Matrix.

然而，这会导致相当复杂的代码，用户必须为他们想要使用的每个T提供自己的Calculator<T>实现。只要它不需要是可扩展的，也就是说，如果你只想支持固定数量的类型，比如int和double，你可以使用一个相对简单的接口:

var mat = new Matrix<int>(w, h);

(GitHub Gist中的最小实现。)

然而，一旦您希望用户能够提供他们自己的自定义类型，您就需要打开这个实现，以便用户能够提供他们自己的Calculator实例。例如，要实例化一个使用自定义十进制浮点数实现DFP的矩阵，你必须编写以下代码:

var mat = new Matrix<DFP>(DfpCalculator.Instance, w, h);

实现DfpCalculator的所有成员:ICalculator<DFP>。

正如Sergey Shandar的回答中所讨论的那样，另一种选择(不幸的是，它也有同样的局限性)是使用策略类。

话题老了，但对未来的读者来说:

这个特性与歧视联盟紧密相关，而歧视联盟目前还没有在c#中实现。我发现它的问题在这里:

https://github.com/dotnet/csharplang/issues/113

这个问题仍然没有解决，并且已经计划在c# 10中推出新特性

所以我们仍然需要等待一段时间，但在释放之后，你可以这样做:

static bool IntegerFunction<T>(T value) where T : Int16 | Int32 | Int64 | ...

我有一个类似的情况，我需要处理数字类型和字符串;看起来有点奇怪，但就是这样。

和许多人一样，我研究了约束条件，提出了一堆它必须支持的接口。然而，第一，它并不是100%无懈可击的;第二，任何新看到这一长串约束条件的人都会立刻感到困惑。

所以，我的方法是把我所有的逻辑放到一个没有约束的泛型方法中，但是让这个泛型方法是私有的。然后我用公共方法公开它，其中一个方法显式地处理我想处理的类型——在我看来，代码是干净而显式的，例如。

public static string DoSomething(this int input, ...) => DoSomethingHelper(input, ...);
public static string DoSomething(this decimal input, ...) => DoSomethingHelper(input, ...);
public static string DoSomething(this double input, ...) => DoSomethingHelper(input, ...);
public static string DoSomething(this string input, ...) => DoSomethingHelper(input, ...);

private static string DoSomethingHelper<T>(this T input, ....)
{
    // complex logic
}