C# 具有抽象（基）/具体（继承）类的DataContractSerializer

鉴于此代码

public override void Serialize(BaseContentObject obj)
{
    string file = ObjectDataStoreFolder + obj.Slug + ".xml";
    if(obj.GetType() == typeof(Page))
    {
        DataContractSerializer dcs = new DataContractSerializer(typeof Page));
        XmlDictionaryWriter myWriter =
            XmlDictionaryWriter.CreateTextWriter(new FileStream(file, ileMode.CreateNew, FileAccess.Write),
                                             Encoding.UTF8);
        dcs.WriteObject(myWriter, obj);
        myWriter.Close();
    }
    else if(obj.GetType() == typeof(Image))
    {
        DataContractSerializer dcs = new DataContractSerializer(typeof Image));
        ...
        ...
    }
}

有没有办法做到这一点

DataContractSerializer dcs = new DataContractSerializer(obj.GetType());
// this fails however, compiler error

然后去掉上面的if（）语句？DataContractSerializer的构造函数需要类型或命名空间，但不能与obj.GetType（）一起使用

我的类层次结构如下所示：

BaseContentClass（摘要）

页面（具体，继承BaseContentClass）

图像（具体，继承BaseContentClass）

---

？

如果您正在谈论这一点，那么以下代码可以很好地编译：

DataContractSerializer dcs = new DataContractSerializer(obj.GetType());

---

由于构造函数需要一个类型参数。

如果您正在讨论这个问题，那么下面的代码可以很好地编译：

DataContractSerializer dcs = new DataContractSerializer(obj.GetType());

---

因为构造函数需要一个类型参数。

告诉序列化程序需要什么：

[KnownType(typeof(Page))]
[KnownType(typeof(Image))]
[DataContract]
public abstract class BaseContentObject { /* ... */ }

[DataContract]
public class Page : BaseContentObject { /* ... */ }

[DataContract]
public class Image : BaseContentObject { /* ... */ }

---

然后，您可以使用新的DataContractSerializer（typeof（BaseContentObject））进行所有操作。

告诉序列化程序预期的内容：

[KnownType(typeof(Page))]
[KnownType(typeof(Image))]
[DataContract]
public abstract class BaseContentObject { /* ... */ }

[DataContract]
public class Page : BaseContentObject { /* ... */ }

[DataContract]
public class Image : BaseContentObject { /* ... */ }

---

然后您可以使用新的DataContractSerializer（typeof（BaseContentObject））进行所有操作。

我更喜欢使用泛型。 辅助对象可以看起来像：

public static string Serialize<T>(T t, IEnumerable<System.Type> types, bool preserveReferences)
    {
        StringBuilder aStringBuilder = new StringBuilder();
        using (StringWriter aStreamWriter = new StringWriter(aStringBuilder))
        {
            DataContractSerializer aDCS;
            using (XmlTextWriter aXmlTextWriter = new XmlTextWriter(aStreamWriter))
            {
                aDCS = new DataContractSerializer( typeof( T ), types, int.MaxValue, false, preserveReferences, null );

                aDCS.WriteObject(aXmlTextWriter, t);
            }
        }
        return aStringBuilder.ToString();
    }

公共静态字符串序列化（T、IEnumerable类型、bool引用）
{
StringBuilder aStringBuilder=新建StringBuilder（）；
使用（StringWriter aStreamWriter=新StringWriter（aStringBuilder））
{
数据序列化ADC；
使用（XmlTextWriter aXmlTextWriter=新的XmlTextWriter（aStreamWriter））
{
aDCS=新的DataContractSerializer（typeof（T），types，int.MaxValue，false，preserveReferences，null）；
aDCS.WriteObject（aXmlTextWriter，t）；
}
}
返回aStringBuilder.ToString（）；
}

---

泛型将允许您在不使用if语句的情况下序列化任何类型。

我更喜欢使用泛型。 辅助对象可以看起来像：

public static string Serialize<T>(T t, IEnumerable<System.Type> types, bool preserveReferences)
    {
        StringBuilder aStringBuilder = new StringBuilder();
        using (StringWriter aStreamWriter = new StringWriter(aStringBuilder))
        {
            DataContractSerializer aDCS;
            using (XmlTextWriter aXmlTextWriter = new XmlTextWriter(aStreamWriter))
            {
                aDCS = new DataContractSerializer( typeof( T ), types, int.MaxValue, false, preserveReferences, null );

                aDCS.WriteObject(aXmlTextWriter, t);
            }
        }
        return aStringBuilder.ToString();
    }

公共静态字符串序列化（T、IEnumerable类型、bool引用）
{
StringBuilder aStringBuilder=新建StringBuilder（）；
使用（StringWriter aStreamWriter=新StringWriter（aStringBuilder））
{
数据序列化ADC；
使用（XmlTextWriter aXmlTextWriter=新的XmlTextWriter（aStreamWriter））
{
aDCS=新的DataContractSerializer（typeof（T），types，int.MaxValue，false，preserveReferences，null）；
aDCS.WriteObject（aXmlTextWriter，t）；
}
}
返回aStringBuilder.ToString（）；
}

---

泛型将允许您序列化任何您想要的类型，而无需使用if语句。

我刚刚在其他地方再次尝试了它，它确实有效，所以我真的不知道以前的错误来自何处。谢谢我只是在其他地方再次尝试，它确实有效，所以我真的不知道我的错误是从哪里来的。谢谢这看起来很有趣。但是，在我的抽象类上，我目前没有[DataContract]属性（目前只修饰继承类）。我也应该装饰抽象吗？这看起来很有趣。但是，在我的抽象类上，我目前没有[DataContract]属性（目前只修饰继承类）。我也应该装饰抽象吗？