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

和许多人一样，我研究了约束条件，提出了一堆它必须支持的接口。然而，第一，它并不是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
}

没有办法将模板限制为类型，但是可以根据类型定义不同的操作。作为泛型数值包的一部分，我需要一个泛型类来添加两个值。

    class Something<TCell>
    {
        internal static TCell Sum(TCell first, TCell second)
        {
            if (typeof(TCell) == typeof(int))
                return (TCell)((object)(((int)((object)first)) + ((int)((object)second))));

            if (typeof(TCell) == typeof(double))
                return (TCell)((object)(((double)((object)first)) + ((double)((object)second))));

            return second;
        }
    }

请注意，typeofs是在编译时计算的，因此if语句将被编译器删除。编译器还会删除虚假的类型转换。因此，在编译器中会解析为

        internal static int Sum(int first, int second)
        {
            return first + second;
        }

这个练习的意义是什么?

正如人们已经指出的，你可以让一个非泛型函数取最大的项，编译器会自动为你转换较小的整型。

static bool IntegerFunction(Int64 value) { }

如果您的函数处于性能关键的路径上(在我看来，这是不太可能的)，您可以为所有需要的函数提供重载。

static bool IntegerFunction(Int64 value) { }
...
static bool IntegerFunction(Int16 value) { }

. net数字基元类型不共享任何允许它们用于计算的公共接口。可以定义自己的接口(例如ISignedWholeNumber)来执行这样的操作，定义包含单个Int16、Int32等的结构并实现这些接口，然后有方法接受受ISignedWholeNumber约束的泛型类型，但是必须将数值转换为你的结构类型可能是一个麻烦。

An alternative approach would be to define static class Int64Converter<T> with a static property bool Available {get;}; and static delegates for Int64 GetInt64(T value), T FromInt64(Int64 value), bool TryStoreInt64(Int64 value, ref T dest). The class constructor could use be hard-coded to load delegates for known types, and possibly use Reflection to test whether type T implements methods with the proper names and signatures (in case it's something like a struct which contains an Int64 and represents a number, but has a custom ToString() method). This approach would lose the advantages associated with compile-time type-checking, but would still manage to avoid boxing operations and each type would only have to be "checked" once. After that, operations associated with that type would be replaced with a delegate dispatch.

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

和许多人一样，我研究了约束条件，提出了一堆它必须支持的接口。然而，第一，它并不是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
}

我会使用一个通用的，你可以处理外部…

/// <summary>
/// Generic object copy of the same type
/// </summary>
/// <typeparam name="T">The type of object to copy</typeparam>
/// <param name="ObjectSource">The source object to copy</param>
public T CopyObject<T>(T ObjectSource)
{
    T NewObject = System.Activator.CreateInstance<T>();

    foreach (PropertyInfo p in ObjectSource.GetType().GetProperties())
        NewObject.GetType().GetProperty(p.Name).SetValue(NewObject, p.GetValue(ObjectSource, null), null);

    return NewObject;
}