0

我写了一个接口来编写一个非常简单的插件。事实上，它只是一个在运行时从 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 文件中共享，以基于该接口创建插件：

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

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

[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

4

1 回答 1

0

我已经解决了我的问题：我真的不知道为什么，但看看这篇文章： 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：序列化和反序列化。

于 2012-07-18T08:47:44.640 回答