C#XmlSerialization插件序列化

我已经为编写一个非常简单的插件编写了一个接口。实际上，它只是一个在运行时从dll文件中加载的类，并作为属性存储在另一个类中。存储接口的类必须序列化。例如，这是我的序列化对象：

<?xml version="1.0" encoding="utf-8"?><MD5HashMapper xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.namespace.net" />

我也有不同的映射器（您可以通过它们传递输入，它们可以修改输出）。所有映射器均源自：

[XmlInclude(typeof(ConstMapper))]
[XmlInclude(typeof(FuncMapper))]
[XmlInclude(typeof(IdentMapper))]
[XmlInclude(typeof(NullMapper))]
[XmlInclude(typeof(RefMapper))]
[XmlInclude(typeof(VarMapper))]
[XmlInclude(typeof(TableMapper))]
[XmlInclude(typeof(AddinMapper))]
public class MapperBase:ComponentBase,IMap
{        public virtual object Map(object input) {
        throw new NotImplementedException("Diese Methode muss überschrieben werden");
    }

    public override string ToString() {
        return ShortDisplayName;
    }
}

忘了ComponentBase吧。这并不重要

现在我还有一个AddinMapper。该映射器的主要功能是将create MapperBase对象强制转换为IMap对象： 这正是我想要序列化的类，包括Mapper属性（类型IMap）的属性

问题是我想保存设置，比如StringToReplace，。。。作为xml，我已经解决了我的问题： 我真的不知道为什么，但看看这篇文章： （如果稍后链路断开）

---

现在重要的一点是：如果您没有获得序列化的例外，这并不重要。您必须以两种方式添加XmlRootAttribute：序列化和反序列化。

hmm-虽然您给出了序列化尝试的详细情况，但我认为您需要提供更多的代码以获得更多的理解。我会（在合理的范围内）将一个运行中的控制台应用程序引入到这个问题中，这样每个人都可以看到更大的图景，甚至可以将其作为解决您的问题的基础。

public interface IMap
{
    object Map(object input);
}

[XmlInclude(typeof(ConstMapper))]
[XmlInclude(typeof(FuncMapper))]
[XmlInclude(typeof(IdentMapper))]
[XmlInclude(typeof(NullMapper))]
[XmlInclude(typeof(RefMapper))]
[XmlInclude(typeof(VarMapper))]
[XmlInclude(typeof(TableMapper))]
[XmlInclude(typeof(AddinMapper))]
public class MapperBase:ComponentBase,IMap
{        public virtual object Map(object input) {
        throw new NotImplementedException("Diese Methode muss überschrieben werden");
    }

    public override string ToString() {
        return ShortDisplayName;
    }
}

    public class AddinMapper : MapperBase
{
    private static MapperBase[] _mappers;
    const string addinDirectory = @"Addin\Mappers\";

    //Mappers from *.dll files are loaded here:
    [XmlIgnore]
    public static MapperBase[] Mappers
    {
        get
        {
            if (_mappers == null)
            {
                List<MapperBase> maps = new List<MapperBase>();
                foreach (string dll in Directory.GetFiles(addinDirectory, "*.dll"))
                {
                    if (Path.GetFileName(dll) != "IMap.dll")
                    {
                        var absolutePath = Path.Combine(Environment.CurrentDirectory, dll);
                        Assembly asm = Assembly.LoadFile(absolutePath);
                        foreach (Type type in asm.GetTypes().ToList().Where(p => p.GetInterface("IMap") != null))
                        {
                            maps.Add(new AddinMapper((IMap)Activator.CreateInstance(type)));
                        }
                    }
                }

                Mappers = maps.ToArray();
            }
            return _mappers;
        }
        set
        {
            _mappers = value;
        }
    }

    IMap _base;

    public string MapperString { get; set; }

    [XmlIgnore()]
    public IMap Mapper
    {
        get
        {
            if (_base == null)
            {
                Type type = null;
                foreach (MapperBase mapperBase in Mappers)
                {
                    if (mapperBase is AddinMapper && ((AddinMapper)mapperBase).Mapper.GetType().FullName == _mapperName)
                    {
                        type = (mapperBase as AddinMapper).Mapper.GetType();
                        break;
                    }
                }
                if (type != null)
                {
                    XmlSerializer serializer = new XmlSerializer(type);
                    using (StringReader reader = new StringReader(MapperString))
                    {
                        Mapper = (IMap)serializer.Deserialize(reader);
                    }
                }
            }
            return _base;
        }
        private set
        {
            _base = value;
            StoreMapperString();
        }
    }

    string _mapperName;

    [System.ComponentModel.Browsable(false)]
    public string MapperName
    {
        get
        {
            return _mapperName;
        }
        set
        {
            _mapperName = value;
        }
    }

    public AddinMapper(IMap baseInterface) : this()
    {
        Mapper = baseInterface;
        _mapperName = baseInterface.GetType().FullName;
    }

    public AddinMapper() 
    {
    }

    public override object Map(object input)
    {
        return Mapper.Map(input);
    }

    public override string ToString()
    {
        return Mapper.ToString();
    }

    private void StoreMapperString()
    {
        MemoryStream memstream = new MemoryStream();
        XmlStore.SaveObject(memstream, Mapper);
        using (StreamReader reader = new StreamReader(memstream))
        {
            memstream.Position = 0;
            MapperString = reader.ReadToEnd();
        }
    }
}

    public class ReplaceMapper : IMap
{
    public string StringToReplace { get; set; }
    public string StringToInsert { get; set; }
    public object Map(object input)
    {
        if (input is string)
        {
            input = (input as string).Replace(StringToReplace, StringToInsert);
        }
        return input;
    }
}

XmlRootAttribute xRoot = new XmlRootAttribute();
xRoot.ElementName = elementName;
xRoot.IsNullable = true;


XmlSerializer ser = new XmlSerializer(typeof(MyObject), xRoot);
XmlReader xRdr = XmlReader.Create(new StringReader(xmlData));
MyObject tvd = (MyObject)ser.Deserialize(xRdr);