Question

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

<?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" />

但现在如果我想加载该对象，我会得到一个异常：例如：

{"<MD5HashMapper xmlns='http://www.vrz.net/Vrz.Map'> was not expected."}

那么有人知道如何解决这个问题吗？

代码：我有一个名为IMap的接口，它在dll文件中共享，以基于该接口创建Addins：

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

我也有不同的Mapper（您可以通过它们传递输入并修改输出）。所有Mappers都来自：

[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。该映射器的主要功能是从IMap对象中强制创建MapperBase对象：而这正是我想要分类的类，包括Mapper属性的属性（类型IMap）。

    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;
    }
}

问题是我想将设置保存为StringToReplace，...作为xml

Answer 1

我解决了我的问题：我真的不知道为什么，但看看这篇文章：http://www.calvinirwin.net/2011/02/10/xmlserialization-deserialize-causes-xmlns-was-not-expected/ （如果链接后来死了）

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);

现在重要的是：如果你没有得到序列化的摘要，那没关系。您必须在两个方面添加XmlRootAttribute：序列化和反序列化。

C＃Xml序列化添加序列化

1 个答案: