C# 利用函数反射、XML序列化/反序列化保存函数执行与输入参数列表

最近在写工业机械臂控制的代码，需要实现如下的一个功能：

将机械臂需要执行的函数与输入参数按照顺序保存成文件，加载文件后能够直接命令机械手进行动作。

界面使用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 + "回到原点");
}
}

编写一个
beb7
类 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();
}
}