Question

I have written an Interface for writing a very very simple Plugin. In fact it is just a class that is loaded at runtime out of a dll file and is stored as Property in another class. That class that stores the interface has to get serialized. As example this is my serialized object:

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

But now If i want to load that Object I get an Exception:
As example :

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

So does anyone has an idea how to solve that problem?

Code:
I have an Interface named IMap that is shared in a dll file to create Addins based on that interface:

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

I also have different Mappers (you can pass an input through them and they modify the output). All Mappers are derived from:

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

Just forget ComponentBase. It is not important for this…

Now i also have a AddinMapper. The main function of that mapper is to cast create MapperBase Object out of the IMap object:
And that is exactly that class I want to seralize including the properties of the Mapper Property (type 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();
        }
    }
}

An example for such a addin would be:

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

And the Problem is I want to save the Settings like StringToReplace,… as xml

Answer 1

I ve solved my problem:
I really don t know why but take a look at this article: http://www.calvinirwin.net/2011/02/10/xmlserialization-deserialize-causes-xmlns-was-not-expected/
(if link is dead later)

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

Now the important thing: It does not matter if you don t get an excption on serialization. You have to add the XmlRootAttribute on both ways: Serialisation and Deserialization.