一、前言
类似如下字符串
"ID", "NameValue", "CodeValue", "ExchangeTypeValue", 6, "invalid"
"ID2", "NameValue2", "CodeValue2", "ExchangeTypeValue2", 6, "invalid"
.......
有可能是文件中存在的，或者调用其他程序返回的结构化数据，那么该如何解析？当其他场景中，只是返回顺序（属性顺序）变了，类结构还是一样，又如何应对？当有很多类似场景时，是不是该抽象出一个泛型方法来应对该场景？当然，也不仅仅于上述情况，可能返回的结构是确定，只是形式不一样，这个过程这里暂时省略，因为正则表达式完全能够解析出来。要用以下的方法，必须转换成IEnumerable<IEnumerable<string>>结构，IEnumerable<IEnumerable<string>>结构中IEnumerable<string>为一个对象所有的值，总体是多个对象的值集合。本文中用反射写的（关于IL操作的后续文章提供），相关的类图如下：
二、ResultTransfer的具体实现
ResultTransfer主要用于对IEnumerable<IEnumerable<string>>结构的解析，另外还可以指定params string[] propertyNames属性参数列表来确定解析顺序（也即是属性顺序），主要方法如下：
public static IList<T> Parse<T>(IEnumerable<IEnumerable<string>> entityRows, params string[] propertyNames) where T : new()
第一个参数entityRows为对象列表值集合。
第二个参数propertyNames为可选参数，输入该参数后，如果propertyNames中存在相关属性，则按照propertyNames对应的属性顺序进行解析。否则按照提供的T类中属性的DataMemberAttribute来确定属性顺序进行解析。
实现代码非常简洁和简单，方法具体如下所示：
public static IList<T> Parse<T>(IEnumerable<IEnumerable<string>> entityRows, params string[] propertyNames) where T : new()
{
if (entityRows == null || entityRows.Count() == )
{
return new List<T>();
} IList<T> entities = new List<T>();
var members = new DataMemberAttributeCollection(typeof(T), propertyNames); if (members.Count <= )
{
return new List<T>();
} FuncProvider funcProvider = new FuncProvider(); foreach (var propertyValues in entityRows)
{
if (propertyValues == null || propertyValues.Count() == )
{
continue;
} entities.Add(Generate<T>(propertyValues, members, funcProvider));
} return entities;
} private static T Generate<T>(IEnumerable<string> propertyValues, DataMemberAttributeCollection members,
FuncProvider funcProvider) where T : new()
{
T entity = Activator.CreateInstance<T>();
int memberCount = members.Count;
int propertyCount = propertyValues.Count(); if (memberCount == || propertyCount == )
{
return entity;
} int convertCount = Math.Min(memberCount, propertyCount);
DataMemberAttribute currAttribute;
PropertyInfo currPropertyInfo; int propertyValueIndex = ; foreach (string propertyValue in propertyValues)
{
if (propertyValueIndex >= convertCount)
{
break;
} propertyValueIndex++;
currAttribute = members[propertyValueIndex - ];
currPropertyInfo = currAttribute.PropertyInfo; if (propertyValue == null)
{
currPropertyInfo.SetValue(entity, null, null);
continue;
} if (propertyValue.GetType() == currAttribute.PropertyType)
{
currPropertyInfo.SetValue(entity, propertyValue, null);
}
else
{
object result = funcProvider.DynamicInvoke(currAttribute.PropertyType, (propertyValue ?? string.Empty).ToString());
currPropertyInfo.SetValue(entity, result, null);
}
} return entity;
}
三、DataMemberAttributeCollection的具体实现
DataMemberAttributeCollection集合类主要用于设置解析属性的顺序，同样，该类提供二个参数的构造函数用于生成相应的配置信息public DataMemberAttributeCollection(Type type, params string[] propertyNames)。
主要代码如下：
public void GetConfiguration(Type type, params string[] propertyNames)
{
if (type == null || type.GetProperties().Length <= )
{
return;
} if (propertyNames == null || propertyNames.Length == )
{
AddAllDataMemberAttributes(type);
}
else
{
AddDataMemberAttributes(type, propertyNames);
} this._memberAttributes = this._memberAttributes.OrderBy(p => p.Order).ToList();
} private void AddDataMemberAttributes(Type type, string[] propertyNames)
{
IList<PropertyInfo> validPropertyInfos = new List<PropertyInfo>();
PropertyInfo tempPropertyInfo; foreach (string propertyName in propertyNames)
{
if (string.IsNullOrWhiteSpace(propertyName))
{
continue;
} tempPropertyInfo = type.GetProperty(propertyName.Trim()); if (tempPropertyInfo == null)
{
throw new ArgumentException(string.Format(@"Contains Invalid Property Name Arg : {0}.", propertyName.Trim()));
} validPropertyInfos.Add(tempPropertyInfo);
} if (validPropertyInfos.Count() > )
{
foreach (var property in validPropertyInfos)
{
AddAttributes(new DataMemberAttribute(), property);
}
}
} private void AddAllDataMemberAttributes(Type type)
{
DataMemberAttribute attr = null;
foreach (PropertyInfo propertyInfo in type.GetProperties())
{
attr = AttributeUtility.GetCustomAttribute<DataMemberAttribute>(propertyInfo); if (attr == null)
{
continue;
} if (!attr.IsRequire)
{
continue;
} if (this._memberAttributes.Count(p => p.Order == attr.Order) > )
{
throw new ArgumentException(string.Format(@"Contains Same Order {0}.Please Look Up DataMemberAttribute
Of The Type {1}", attr.Order, type.Name));
} AddAttributes(attr, propertyInfo);
}
} private void AddAttributes(DataMemberAttribute attr, PropertyInfo propertyInfo)
{
if (string.IsNullOrWhiteSpace(attr.Name))
{
attr.Name = propertyInfo.Name;
} attr.PropertyName = propertyInfo.Name;
attr.PropertyType = propertyInfo.PropertyType;
attr.PropertyInfo = propertyInfo; this._memberAttributes.Add(attr);
}
该类确保指定Type的类中DataMemberAttribute是否设置正确（是否有相同的Order），确保是否输入了错误的propertyName。
四、具体应用
对于具体应用的话，用单元测试来得方便与直接。
（1）对于只输入一个参数的应用如下：
[TestMethod()]
public void ParseTest()
{
IList<IList<string>> entityRows = new List<IList<string>>();
entityRows.Add(new List<string>() { "", "NameValue", "CodeValue", "ExchangeTypeValue", "", "invalid" }); var contracts = ResultTransfer.Parse<ContinousContract>(entityRows); Assert.IsNotNull(contracts);
Assert.IsTrue(contracts.Count == );
Assert.AreEqual(contracts[].Code, "CodeValue");
Assert.AreEqual(contracts[].Name, "NameValue");
Assert.AreEqual(contracts[].ExchangeType, "ExchangeTypeValue");
Assert.AreEqual(contracts[].OrgidID, );
Assert.AreEqual(contracts[].ExchangeTypeValue, );
}
（2）对于只输入无效参数的应用如下：
[TestMethod()]
public void ParseWithInvalidArgTest()
{
IList<IList<string>> entityRows = new List<IList<string>>();
entityRows.Add(new List<string>() { "sss", "NameValue", "CodeValue", "ExchangeTypeValue", "", "invalid" }); var contracts = ResultTransfer.Parse<ContinousContract>(entityRows); Assert.IsNotNull(contracts);
Assert.IsTrue(contracts.Count == );
Assert.AreEqual(contracts[].Code, "CodeValue");
Assert.AreEqual(contracts[].Name, "NameValue");
Assert.AreEqual(contracts[].ExchangeType, "ExchangeTypeValue");
Assert.AreEqual(contracts[].OrgidID, );
Assert.AreEqual(contracts[].ExchangeTypeValue, );
}
输入无效的IEnumerable<IEnumerable<string>>参数，方法内部会进行隐式的转换，比如“sss”转换成0。
（3）对于二个参数时的应用如下：
[TestMethod()]
public void ParseWithArgTest()
{
IList<IList<string>> entityRows = new List<IList<string>>();
entityRows.Add(new List<string>() { "", "NameValue", "ExchangeTypeValue", "", "invalid" });
var propertyNames = new List<string>() { "ExchangeTypeValue", "Name", "", "ExchangeType" }; var contracts = ResultTransfer.Parse<ContinousContract>(entityRows, propertyNames.ToArray()); Assert.IsNotNull(contracts);
Assert.IsTrue(contracts.Count == );
Assert.AreEqual(contracts[].Code, null);
Assert.AreEqual(contracts[].Name, "NameValue");
Assert.AreEqual(contracts[].ExchangeType, "ExchangeTypeValue");
Assert.AreEqual(contracts[].OrgidID, );
Assert.AreEqual(contracts[].ExchangeTypeValue, );
}
一旦输入二个参数，且propertyNames参数的个数大于0，则以propertyNames对应的属性顺序进行解析。对于输入错误的属性名，方法内部会抛出异常，当然也可以增加一个参数用于控制是否抛出异常，或者写入日志文件中等。
对于将固定格式的字符串解析成IEnumerable<IEnumerable<string>>，正则表达式解析的话比较简单，此文不做讲解，略过...