XmlCmdBuilder - doing away with inline xml

I have to work with a 3rd-party API that allows me to define and execute "commands", using XML. Since I don't like seeing mixed abstraction levels, I managed to remove all the inline XML / string concatenations by creating a simple XmlCmdBuilder object - here is the C# implementation (I have one in VB6 as well, the C# one will eventually replace the VB6 equivalent code):

public class XmlCmdBuilder
{
    private readonly IList _xmlCommands;

    public XmlCmdBuilder()
    {
        _xmlCommands = new List();
    }

    public void AddCommand(XmlCmd cmd)
    {
        _xmlCommands.Add(cmd);
    }

    public void Clear()
    {
        _xmlCommands.Clear();
    }

    public override string ToString()
    {
        var builder = new StringBuilder();

        builder.Append("");
        foreach (var xmlCommand in _xmlCommands)
        {
            builder.Append(xmlCommand);
        }
        builder.Append("");

        return builder.ToString();
    }

}

The "builder" simply exposes a AddCommand method that takes in a XmlCmd object:

public class XmlCmd
{
    private readonly IList _parameters;

    public XmlCmd(string name)
        : this(name, new List())
    {

    }

    public XmlCmd(string name, params XmlCmdParameter[] parameters)
        : this(name, parameters.ToList())
    {

    }

    public XmlCmd(string name, IList parameters)
    {
        _parameters = parameters;
        Name = name;
    }

    public string Name { get; private set; }

    public void AddParameter(XmlCmdParameter parameter)
    {
        _parameters.Add(parameter);
    }

    public override string ToString()
    {
        var builder = new StringBuilder();

        builder.Append(string.Format("", Name));
        foreach (var xmlCommandParameter in _parameters)
        {
            builder.Append(xmlCommandParameter);
        }
        builder.Append("");

        return builder.ToString();
    }
}

Similarly, the XmlCmd exposes a method to add `XmlCmdPar

You have to provide interfaces API, which helps users of your framework to add their custom interface implementations, and you have to replace default .ToString() ovverrides for readability and compatibility. In common, all is just fine.

Generally, you can provide any of the containers for user project extensibility (System.AddIn, for example) by using attributes, as a bonus, you can then control the versioning of you assembiles in GAC, and gain the ability to mark interfaces, classes and methods as [Obsolete] or [Deprecated] attributes

Also, if you provide an inteface-only assemblies with no of minimum dependencies of other project assembiles, you will keep in mind loose-coupling in design, which is good. Additinally, you can create reference interface implementations as a reference to developers in the future which are always work as a whatchdogs in deprecated classes.

public interface IXmlCmdBuilder
{
    string Xml { get; }
}

public interface IXmlCmd
{
    string Xml { get; }
}

public interface IXmlCmdParameter
{
    string Xml { get; }
}

as it listed here:

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace Server
{
    public interface IXmlCmdBuilder
    {
        string Xml { get; }
    }

    public interface IXmlCmd
    {
        string Xml { get; }
    }

    public interface IXmlCmdParameter
    {
        string Xml { get; }
    }

    public sealed class XmlCmdBuilder : IXmlCmdBuilder
    {
        private readonly IList _xmlCommands;

        public XmlCmdBuilder()
        {
            _xmlCommands = new List();
        }

        public void AddCommand(IXmlCmd cmd)
        {
            _xmlCommands.Add(cmd);
        }

        public void Clear()
        {
            _xmlCommands.Clear();
        }

        public override string ToString()
        {
            return Xml;
        }

        public string Xml
        {
            get
            {
                var builder = new StringBuilder();

                builder.Append("");
                foreach (var xmlCommand in _xmlCommands)
                {
                    builder.Append(xmlCommand.Xml);
                }
                builder.Append("");

                return builder.ToString();
            }
        }
    }

    public sealed class XmlCmd : IXmlCmd
    {
        private readonly IList _parameters;

        public XmlCmd(string name)
            : this(name, new List())
        {

        }

        public XmlCmd(string name, params IXmlCmdParameter[] parameters)
            : this(name, parameters.ToList())
        {

        }

        public XmlCmd(string name, IList parameters)
        {
            _parameters = parameters;
            Name = name;
        }

        public string Name { get; private set; }

        public void AddParameter(IXmlCmdParameter parameter)
        {
            _parameters.Add(parameter);
        }

        public class XmlCmdParameter : IXmlCmdParameter
        {
            public string Xml { get; private set; }

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

        public override string ToString()
        {
            return Xml;
        }

        public string Xml
        {
            get
            {
                var builder = new StringBuilder();

                builder.Append(string.Format("", Name));
                foreach (var xmlCommandParameter in _parameters)
                {
                    builder.Append(xmlCommandParameter.Xml);
                }
                builder.Append("");

                return builder.ToString();
            }
        }
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            XmlCmdBuilder builder = new XmlCmdBuilder();
            builder.AddCommand(new XmlCmd(""));
            Console.WriteLine(builder.Xml);
        }
    }
}

StackExchange Code Review Q#39288, answer score: 3