数据契约：在反序列化时忽略未知类型

Question

我有一个基于插件的宿主应用程序。其设置被描述为数据契约：

[DataContract(IsReference = true)]
public class HostSetup
{
    [DataMember]
    public ObservableCollection<Object> PluginSetups
    {
        get
        {
            return pluginSetups ?? (pluginSetups = new ObservableCollection<Object>());
        }
    }
    private ObservableCollection<Object> pluginSetups;          
}

任何插件都有自己的设置类型。例如：

[DataContract(IsReference = true)]
public class Plugin1Setup
{
    [DataMember]
    public String Name { get; set; }
}

并且

[DataContract(IsReference = true)]
public class Plugin2Setup
{
    [DataMember]
    public Int32 Percent { get; set; }
    [DataMember]
    public Decimal Amount { get; set; }
}

在运行时，用户已经配置了主机和插件：

        var obj = new HostSetup();
        obj.PluginSetups.Add(new Plugin1Setup { Name = "Foo" });
        obj.PluginSetups.Add(new Plugin2Setup { Percent = 3, Amount = 120.50M });

接下来，我的应用程序通过DataContractSerializer保存了其设置。插件类型作为已知类型传递给序列化器的构造函数。

问题：
用户物理删除了带有“Plugin2”的程序集，然后启动了我的应用程序。
因此，当主机收到可用插件列表时，它不知道已序列化的“Plugin2Setup”实例。

我想忽略这个实例，并让用户在没有“Plugin2”设置的情况下工作。
有没有什么优雅的方法可以做到这一点？
我可以将插件的设置存储为序列化为字符串的数据合同：

public ObservableCollection<String> PluginSetups  

但是它很不方便且难看。

Edit 1
问题在于如何反序列化HostSetup实例并忽略序列化的Plugin2Setup实例。

Edit 2
我目前的解决方案是：

[DataContract(IsReference = true)]
public class PluginSetupContainer
{
    [DataMember]
    private String typeName;
    [DataMember]
    private String rawData;

    [OnSerializing]
    private void OnSerializing(StreamingContext context)
    {
        if (SetupParameters != null)
        {
            using (var writer = new StringWriter())
            using (var xmlWriter = new XmlTextWriter(writer))
            {
                var setupParametersType = SetupParameters.GetType();
                var serializer = new DataContractSerializer(setupParametersType);
                serializer.WriteObject(xmlWriter, SetupParameters);

                xmlWriter.Flush();

                typeName = setupParametersType.AssemblyQualifiedName;
                rawData = writer.ToString();
            }
        }
    }

    [OnSerialized]
    private void OnSerialized(StreamingContext context)
    {
        ClearInternalData();
    }

    [OnDeserialized]
    private void OnDeserialized(StreamingContext context)
    {
        if (!String.IsNullOrEmpty(typeName) && !String.IsNullOrEmpty(rawData))
        {
            var setupParametersType = Type.GetType(typeName, false);
            if (setupParametersType != null)
            {
                using (var reader = new StringReader(rawData))
                using (var xmlReader = new XmlTextReader(reader))
                {
                    var serializer = new DataContractSerializer(setupParametersType);
                    SetupParameters = serializer.ReadObject(xmlReader);
                }
            }

            ClearInternalData();
        }
    }

    private void ClearInternalData()
    {
        typeName = null;
        rawData = null;
    }

    public Object SetupParameters { get; set; }
}

[DataContract(IsReference = true)]
public class HostSetup
{
    [DataMember]
    public ObservableCollection<PluginSetupContainer> PluginSetups
    {
        get
        {
            return pluginSetups ?? (pluginSetups = new ObservableCollection<PluginSetupContainer>());
        }
    }
    private ObservableCollection<PluginSetupContainer> pluginSetups;
}

也许它很糟糕，但它起作用了。:)

- Dennis

Answer 1

我认为理想情况下，你应该有类似于以下的内容：

[DataContract(IsReference = true)]
[MyPluginCustomAttribute]
public class Plugin1Setup
{
}

当你的应用程序加载时，你应该使用反射初始化obj.PluginSetups，基于MyPluginCustomAttribute，这样只有存在的程序集才会注册它们的类型。这样你就不会遇到缺少程序集的问题了。你也可以使用Managed Extensibility Framework (MEF)代替自己的MyPluginCustomAttribute

- parapura rajkumar

---

问题不在于“如何接收可用插件列表及其设置类型”或“如何初始化插件设置”。问题在于反序列化包含未知类型的对象图。 - Dennis