C# 泛型函数和带类型参数的函数之间的差异

我只是想知道，使用一个接受类型为

类型的参数（以及更多参数）的函数和一个只希望类型位于
尖括号中的泛型函数之间有什么区别

Idea behinde：我想编写一个函数，将ma文件系统上的类型保存为XML文件。由于XmlSerializer需要具有要序列化的对象类型，我想知道：什么更好

private bool SerializeIt(object o, Type t, string filePath)
{
    bool result = false;
    try
    {
        if (File.Exists(filePath))
            File.Delete(filePath);

        XmlSerializer serializer = new XmlSerializer(t);
        using (FileStream fs = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write))
        {
            serializer.Serialize(fs, o);
        }
        result = true;
    }
    catch (Exception ex)
    {
        result = false;
        Debug.WriteLine(ex);
    }

    return result;
}

private bool SerializeIt<T>(T o, string filePath)
{
    bool result = false;
    try
    {
        if (File.Exists(filePath))
            File.Delete(filePath);

        XmlSerializer serializer = new XmlSerializer(o.GetType());
        using (FileStream fs = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write))
        {
            serializer.Serialize(fs, o);
        }
    }
    catch (Exception ex)
    {
        result = false;
        Debug.WriteLine(ex);
    }

    return result;
}

private bool序列化它（对象o，类型t，字符串文件路径）
{
布尔结果=假；
尝试
{
if（File.Exists（filePath））
File.Delete（文件路径）；
XmlSerializer serializer=新的XmlSerializer（t）；
使用（FileStream fs=newfilestream（filePath，FileMode.CreateNew，FileAccess.Write））
{
serializer.Serialize（fs，o）；
}
结果=真；
}
捕获（例外情况除外）
{
结果=假；
Debug.WriteLine（ex）；
}
返回结果；
}
私有bool序列化它（to，字符串文件路径）
{
布尔结果=假；
尝试
{
if（File.Exists（filePath））
File.Delete（文件路径）；
XmlSerializer serializer=新的XmlSerializer（o.GetType（））；
使用（FileStream fs=newfilestream（filePath，FileMode.CreateNew，FileAccess.Write））
{
serializer.Serialize（fs，o）；
}
}
捕获（例外情况除外）
{
结果=假；
Debug.WriteLine（ex）；
}
返回结果；
}
您的第一个方法仅适用于类型
SomeData1
，因为这是您指定的类型。另一种方法适用于通过
T
传递的任何类型

您可以使用
o.GetType（）
而不是
typeof（SomeData1）
来解决上述问题。尽管如此，第二个方法还是让您有机会使用基类作为序列化基类，这将清除派生类中的所有属性。
您的第一个方法将只处理类型
SomeData1
，因为这是您指定的类型。另一种方法适用于通过
T
传递的任何类型

您可以使用
o.GetType（）
而不是
typeof（SomeData1）
来解决上述问题。尽管如此，第二种方法还是让您有机会使用基类作为序列化基类，这将清除派生类中的所有属性。
函数
private bool SerializeIt（对象o，类型t，字符串文件路径）
在运行时进行计算。
其中函数
private bool serializet（to，string filePath
在编译时进行计算。这是在IL代码中插入指定的类型。
函数
private bool serializet（object o，type T，string filePath）
在运行时进行计算。
其中函数
private bool序列化它（to，string filePath
在编译时进行计算。这就是在IL代码中插入指定的类型。
有很多不同之处。首先，您可以为泛型参数创建约束，例如：

private bool SerializeIt<T>(T o, string filePath) where T: ISomething

private bool序列化它（to，string filePath），其中T:ISomething

第二，泛型类型的自由类型推理

private bool SerializeIt<T>(T o, string filePath)

Something something = new Something();
o.SerializeIt(something, ""); // dont need to pass type (can infer from first argument).

private bool序列化它（to，字符串文件路径）
新事物；
o、 SerializeIt（something，“”；//不需要传递类型（可以从第一个参数推断）。

第三，您从事混凝土强度类型的工作，例如：

private bool SerializeIt<T>(T o, string filePath)

private bool序列化它（to，字符串文件路径）

通常，它使界面更简单、更清晰。您不必使用松散类型的对象。
有很多不同之处。首先，您可以为泛型参数创建约束，例如：

private bool SerializeIt<T>(T o, string filePath) where T: ISomething

private bool序列化它（to，string filePath），其中T:ISomething

第二，泛型类型的自由类型推理

private bool SerializeIt<T>(T o, string filePath)

Something something = new Something();
o.SerializeIt(something, ""); // dont need to pass type (can infer from first argument).

private bool序列化它（to，字符串文件路径）
新事物；
o、 SerializeIt（something，“”；//不需要传递类型（可以从第一个参数推断）。

第三，您从事混凝土强度类型的工作，例如：

private bool SerializeIt<T>(T o, string filePath)

private bool序列化它（to，字符串文件路径）

一般来说，它使界面更简单、更干净。您不必使用松散类型的对象。
您应该将
o
参数更改为
T
，而不是
对象，然后它可能开始有意义。在这种情况下，泛型不会向方法本身添加任何内容，因为您不依赖其类型a因此我不认为需要泛型或类型参数，您可以使用
o.GetType（）
在这两种情况下，只要您不需要处理空值。如果空值是一个问题，那么您的泛型版本就有错误。您应该将
o
参数更改为
T
而不是
对象，那么它可能开始有意义。在这种情况下，泛型不会向方法本身添加任何内容，因为您'您在编译时不依赖于它的类型。因此我认为不需要泛型或类型参数，您可以使用
o.GetType（）
在这两种情况下，只要您不需要处理空值。如果空值是一个问题，则您的通用版本有错误。最后一句是我搜索的内容。谢谢！最后一句是我搜索的内容。谢谢！