最近在寫工業機械臂控制的程式碼，需要實現如下的一個功能：
將機械臂需要執行的函式與輸入引數按照順序儲存成檔案，載入檔案後能夠直接命令機械手進行動作。
介面使用winform進行開發。函式名與引數的儲存、載入的部分，考慮到日後函式的增刪，使用了函式反射+XML序列化/反序列一個方案。

這部分用Console模擬一下。

先編寫一個類 Coordinate 來表示座標，類中有三個屬性X,Y,Z分別代表X,Y,Z座標值。

    public class Coordinate
    {
        /// <summary>
        /// X座標值
        /// </summary>
 

        public double X { get; set; }
        /// <summary>
        /// Y座標值
        /// </summary>
        public double Y { get; set; }
        /// <summary>
        /// Z座標值
        /// </summary>
        public double Z { get; set; }

        public override string ToString()
        {
            return
 
 "X:" + X + "|Y:" + Y + "|Z:" + Z;
        }

        public void SetCoordinate(double x , double y, double z)
        {
            X = x;
            Y = y;
            Z = z;
        }

        public static Coordinate operator +(Coordinate coor1 , Coordinate coor2)
        {
            return new
 
 Coordinate() { X = coor1.X + coor2.X, Y = coor1.Y + coor2.Y, Z = coor1.Z + coor2.Z };
        }

        public static Coordinate operator -(Coordinate coor1, Coordinate coor2)
        {
            return new Coordinate() { X = coor1.X - coor2.X, Y = coor1.Y - coor2.Y, Z = coor1.Z - coor2.Z };
        }

        private static readonly Coordinate _originalCoordinate = new Coordinate { X = 0, Y = 0, Z = 0 };

        /// <summary>
        /// 原點座標
        /// </summary>
        public static Coordinate OriginalCoordinate { get { return _originalCoordinate; } }
    }

編寫一個類 Person 來模擬機械手臂，類中有如下幾種方法：

    public class Person
    {
        /// <summary>
        /// 當前座標點
        /// </summary>
        public Coordinate CurrentCoordinate { get; private set; }

        public Person()
        {
            CurrentCoordinate = Coordinate.OriginalCoordinate;
        }

        /// <summary>
        /// 以指定移動到目標地點
        /// </summary>
        /// <param name="coorDst"> 目的座標點 </param>
        /// <param name="speed"> 速度 </param>
        public void MoveToDestination(Coordinate coorDst , int speed)
        {
            Console.WriteLine("以速度:" + speed + "移動到點:" + coorDst.ToString());
            CurrentCoordinate = coorDst;
            Console.WriteLine("當前位置:" + CurrentCoordinate.ToString());
        }

        /// <summary>
        /// 移動一定偏移座標
        /// </summary>
        /// <param name="coorOffset">座標偏移量</param>
        /// <param name="speed">速度</param>
        public void MoveOffset(Coordinate coorOffset , int speed)
        {
            Console.WriteLine("以速度:" + speed + "移動偏移座標:" + coorOffset.ToString());
            CurrentCoordinate += coorOffset;
            Console.WriteLine("當前位置:" + CurrentCoordinate.ToString());
        }

        /// <summary>
        /// 退回原點
        /// </summary>
        /// <param name="speed">速度</param>
        public void BackToOriginalPoint(int speed)
        {
            CurrentCoordinate = Coordinate.OriginalCoordinate;
            Console.WriteLine("以速度:" + speed + "回到原點");
        }
    }

編寫一個類 Parameter 用來儲存函式的單個輸入引數，類中有兩個屬性 Type : ParamType 與 Object : Value 。ParamType 表示引數值的型別，Value 表示輸入引數的值。因為Xml序列化/反序列化需要引數值的型別，所以需要儲存輸入引數的型別 ParamType。並且為了降低耦合度，使用Object物件來儲存引數值。實現IXmlSerializable介面來自定義序列化的過程（object物件無法自行實現序列化/反序列化）。

    public class Parameter :  IXmlSerializable
    {
        /// <summary>
        /// 引數型別
        /// </summary>
        public Type ParamType { get; set; }

        /// <summary>
        /// 引數值
        /// </summary>
        public object Value { get; set; }

        XmlSchema IXmlSerializable.GetSchema()
        {
            return null;
        }

        void IXmlSerializable.ReadXml(XmlReader reader)
        {
            if (reader.IsEmptyElement)
                return;
            reader.Read();

            XmlSerializer xs = new XmlSerializer(typeof(string));
            reader.ReadStartElement("ParamType");
            string strType = (string)xs.Deserialize(reader);
            string strAssembly = strType.Split('.')[0];
            //如果是.net裡面包含的Type 直接使用Type.GetType介面
            if (strAssembly == "System") 
            {
                ParamType = Type.GetType(strType);
            }
            else
            { 
                //如果是其他程式集內的型別，需要載入程式集，然後利用反射獲取引數型別
                Assembly assembly = Assembly.Load(strAssembly);
                ParamType = assembly.GetType(strType);
            }

            xs = new XmlSerializer(ParamType);
            reader.ReadStartElement("Value");
            Value = xs.Deserialize(reader);
            reader.ReadEndElement();

            reader.ReadEndElement();
        }

        void IXmlSerializable.WriteXml(XmlWriter writer)
        {
            writer.WriteStartElement("ParamType");
            //這邊需要將Type儲存成字串，直接序列化 Type 會有異常（暫時不清楚為什麼）
            XmlSerializer xs = new XmlSerializer(typeof(string));
            xs.Serialize(writer, ParamType.ToString());
            writer.WriteEndElement();

            writer.WriteStartElement("Value");
            xs = new XmlSerializer(ParamType);
            xs.Serialize(writer, Value);
            writer.WriteEndElement();
        }
    }

編寫一個類 FunctionInfo ，類中有兩個屬性 string : FunctionName 與 Parameter[]：Parameters ，分別用來儲存函式名與函式的輸入引數。

    public class FunctionInfo
    {
        /// <summary>
        /// 函式名稱
        /// </summary>
        public string FunctionName { get; set; }

        /// <summary>
        /// 引數
        /// </summary>
        [XmlArray]
        public Parameter[] Parameters { get; set; }
    }

最後再編寫一個類，用來儲存整個函式事務列表

    public class Actions
    {
        [XmlArray]
        public FunctionInfo[] FunctionInofs { get; set; }
    }

下面是Main函式的執行程式碼：

        static void Main(string[] args)
        {
            //新建一個事務列表
            Actions actions = new Actions();
            actions.FunctionInofs = new FunctionInfo[3];
            //函式1 MoveToDestination
            actions.FunctionInofs[0] = new FunctionInfo()
            {
                FunctionName = "MoveToDestination",
                Parameters = new Parameter[]
                {
                    new Parameter { Value = new Coordinate { X = 1, Y = 2, Z = 3}, ParamType = typeof(Coordinate) },
                    new Parameter {  Value = 10, ParamType = typeof(int)},
                }
            };

            //函式2 MoveOffset
            actions.FunctionInofs[1] = new FunctionInfo()
            {
                FunctionName = "MoveOffset",
                Parameters = new Parameter[]
                {
                    new Parameter { Value = new Coordinate { X = 1, Y = 2, Z = 3}, ParamType = typeof(Coordinate) },
                    new Parameter {  Value = 5, ParamType = typeof(int)},
                }
            };

            //函式3 BackToOriginalPoint
            actions.FunctionInofs[2] = new FunctionInfo()
            {
                FunctionName = "BackToOriginalPoint",
                Parameters = new Parameter[]
                {
                    new Parameter {  Value = 2, ParamType = typeof(int)},
                }
            };

            //儲存到Xml檔案
            using (XmlWriter writer = XmlWriter.Create(System.Environment.CurrentDirectory + "\\functions.xml"))
            {
                XmlSerializer xs = new XmlSerializer(typeof(Actions));
                xs.Serialize(writer, actions);
            }

            //從Xml檔案反序列化
            using (XmlReader reader = XmlReader.Create(System.Environment.CurrentDirectory + "\\functions.xml"))
            {
                XmlSerializer xs = new XmlSerializer(typeof(Actions));
                actions = (Actions)xs.Deserialize(reader);
            }

            //定義一個Person
            Person person = new Person();
            //獲取型別
            Type type = typeof(Person); //這裡需要根據Person程式集的位置適當修改獲取Type的方式
            //依次執行函式
            foreach (var action in actions.FunctionInofs)
            {
                var mi = type.GetMethod(action.FunctionName, BindingFlags.Public | BindingFlags.Instance);
                mi.Invoke(person, action.Parameters.Select(x => x.Value).ToArray());
            }
            Console.ReadLine();
        }
    }