给定一个受约束的泛型方法，我可以调用传递泛型参数的实际类型的非泛型方法吗

如何解决给定一个受约束的泛型方法，我可以调用传递泛型参数的实际类型的非泛型方法吗

| 我知道标题很尴尬，最好用代码说明。给定一组类：

public abstract class MyBaseType
{
    public string Message { get; set; }
}

public class MySuperType : MyBaseType
{
    public string AdditionalInfo { get; set; }
}

public class MyOtherSuperType : MyBaseType
{
    public DateTime Started { get; set; }
    public DateTime Finished { get; set; }
}

有没有一种写通用方法的方法，该方法调用传递通用类型的非通用方法，同时将传递的类型解释为实际类型而不是基本类型。也就是说，我想写这样的东西：

public void OutputFormattedTypeInfo<T>(T theType) where T : MyBaseType
{
    OutputFormattedTypeInfo(theType as T);
}

public void OutputFormattedTypeInfo(MySuperType theType)
{
    System.Console.WriteLine(String.Format(\"{0} and {1}\",theType.Message,theType.AdditionalInfo));
}

public void OutputFormattedTypeInfo(MyOtherSuperType theType)
{
    System.Console.WriteLine(String.Format(\"{0} - Start: {1},End: {2}\",theType.Started,theType.Finished));
}

但是很明显，将Type作为T解释为基本类型。我知道我可以这样使用反射：

Type type = typeof(MyBaseTypeDisplayFormatter);
    MethodInfo method = type.GetMethod(
                                    \"FormatSpecific\",BindingFlags.Instance | BindingFlags.NonPublic,null,new[] { update.GetType() },null);

    return (MyBaseTypeDataItem)method.Invoke(this,new object[] { update });

但是感觉很不雅有没有更好的办法？     

解决方法

正如Aliostad所说，您尝试做的不再是通用的，最好只使用重载。看起来您正在尝试执行与C ++中的模板专业化类似的操作，在此取决于通用类型，它调用不同的方法。 这是我使用反射实现某种通用专业化的示例，如果重载方法对您不起作用，您可能可以应用类似的模式。如果您可以缓存反射的结果并且仅调用一次GetMethod，那么事实证明它不会太慢。在T泛型的类中，有一个方法调用：

if (_serializeDataToStream == null)
    _serializeDataToStream = (Action<BinaryWriter,int,T[]>)GetTypeSpecificSerializationMethod();

_serializeDataToStream(writer,_size,_data);

其中GetTypeSpecific方法使用反射来创建委托

/// <summary>
/// Returns a delegate that points at the static type specific serialization method
/// </summary>
/// <returns></returns>
private Delegate GetTypeSpecificDeserializationMethod()
{
    if (typeof(T) == typeof(double))
    {
        MethodInfo method = this.GetType().GetMethod(\"DeserializeDouble\",BindingFlags.Static | BindingFlags.NonPublic);
        return Delegate.CreateDelegate(typeof(Action<BinaryReader,T[]>),method);
    }
    else if (typeof(T) == typeof(ushort))
    {
        MethodInfo method = this.GetType().GetMethod(\"DeserializeUshort\",method);
    }
    else if (typeof(T) == typeof(DateTime))
    {
        MethodInfo method = this.GetType().GetMethod(\"DeserializeDateTime\",method);
    }
    else if (typeof(T) == typeof(bool))
    {
        MethodInfo method = this.GetType().GetMethod(\"DeserializeBool\",method);
    }

    throw new NotImplementedException(\"No deserialization method has been setup for type \" + typeof(T).FullName);
}

/// <summary>
/// Serialize double[] to BinaryWriter
/// </summary>
/// <param name=\"writer\"></param>
/// <param name=\"size\"></param>
/// <param name=\"data\"></param>
private static void SerializeDouble(BinaryWriter writer,int size,double[] data)
{
    for (int i = 0; i < size; i++)
    {
        writer.Write(data[i]);
    }
}

    ,这里的问题是您没有真正表达普遍性。您必须为每个基本类型实现

OutputFormattedTypeInfo

，因此您最好也不要使用泛型方法，而只需使用重载（这里不需要泛型）：

public void OutputFormattedTypeInfo(BaseType theType)
{
    // ...
}

public void OutputFormattedTypeInfo(MySuperType theType)
{
    // ...
}

public void OutputFormattedTypeInfo(MyOtherSuperType theType)
{
    // ...
}