將結構化文本轉換爲商業實體的更好方法

Question

我正試圖找到一個更好的解決方案來將純文本（但具有每個字段的預定義長度）轉換爲業務實體。 例如，輸入文本可以是「Testuser new york 10018」，前11個字符表示用戶名，下12個字符表示城市，接下來5個字符表示郵政編碼。 輸入文本可能會很長像1000個字符，它代表在一個實體的多個屬性

任何幫助appreciated..Thanks

我嘗試以下方法

1. 定義的XML結構，其可以被反序列化到商業實體

2. 使用xslt導航到每個節點並通過在輸入文本上使用子字符串函數來填充xml元素值。

3. 一旦填充了xml，就將xml反序列化爲實體。

但我覺得上面的方法可能不是規模能夠與多個XSLT文件加載到不同的輸入轉換成相應個XML

Answer 1

一個很好的和優雅的方式可能是使用正則表達式，在System.Text.RegularExpressions命名空間，所以是這樣的：

static Regex inputParser = new Regex("(.{11})(.{12})(.{5})", RegexOptions.Compiled"); 

foreach(Match m in inputParser.Matches(yourInput)) { 
    BusinessEntity e = new BusinessEntity(); 
    e.Username = m.Groups(1).Value.TrimEnd(); // Remove spaces from the end; I take it that's what they'll be padded with 
    e.City = m.Groups(2).Value.TrimEnd(); 
    e.ZipCode = m.Groups(3).Value; 
    myListOfBusinessEntities.Add(e); 
} 

Answer 2

如果你正面臨一個情況，你可以簡單地用一個方法至極接收文本行，並返回一個新的實體編寫一個簡單的類。

如果您用空白填充行，具有固定長度的行，使用System.Text.Encoding類和GetString方法的二進制閱讀器可以生成更快的解決方案。

Answer 3

基於問題的細化，我推斷你對不同的輸入有多種不同的格式。這是IFormatter的一個實現，它應該可以幫助您實現這一目標。請注意，這是在幾個不同的方式，哈克打破，並附帶任何排序保證：

void Test() 
{ 
    var serializer = new FixedWidthSerializer<MyClass>(); 
    var ms = new MemoryStream(); 
    serializer.Serialize(ms, new MyClass { Age = 30, FirstName = "John", LastName = "Doe"}); 
    ms.Position = 0; 
    var newMyClass = (MyClass)serializer.Deserialize(ms); 
} 

[Serializable] 
private class MyClass 
{ 
    public String FirstName { get; set; } 
    public String LastName; 
    public Int32 Age { get; set; } 
} 

public class FixedWidthSerializer<T> : IFormatter 
{ 
    private readonly FixedWidthFieldDefinition[] _fieldDefinition; 

    public FixedWidthSerializer() 
     : 
     this(FormatterServices.GetSerializableMembers(typeof(T)).Select(sm=>new FixedWidthFieldDefinition(sm.Name, 100)).ToArray()) 
    { } 

    public FixedWidthSerializer(FixedWidthFieldDefinition[] fieldDefinition) 
    { 
     if (fieldDefinition == null) throw new ArgumentNullException("fieldDefinition"); 
     _fieldDefinition = fieldDefinition; 
     Context = new StreamingContext(StreamingContextStates.All);    
    } 

    public class FixedWidthFieldDefinition 
    { 
     public String FieldName { get; protected set; } 
     public Int32 CharLength { get; protected set; } 

     public FixedWidthFieldDefinition(String fieldName, Int32 charLength) 
     { 
      FieldName = fieldName; 
      CharLength = charLength; 
     } 
    } 

    public object Deserialize(Stream serializationStream) 
    { 
     var streamReader = new StreamReader(serializationStream); 
     var textLine = streamReader.ReadLine(); 

     if (textLine == null) 
      throw new SerializationException("Ran out of text!"); 

     var obj = FormatterServices.GetUninitializedObject(typeof (T)); 
     var memberDictionary = FormatterServices.GetSerializableMembers(obj.GetType(), Context).ToDictionary(mi => mi.Name); 

     var offset = 0; 
     foreach (var fieldDef in _fieldDefinition) 
     { 
      if (offset + fieldDef.CharLength > textLine.Length) 
       throw new SerializationException("Line was too short!"); 

      // Read the current field and increase the offset 
      var fieldStringValue = textLine.Substring(offset, fieldDef.CharLength); 
      offset += fieldDef.CharLength; 

      MemberInfo memberInfo; 

      if (!memberDictionary.TryGetValue(fieldDef.FieldName, out memberInfo)) 
       throw new SerializationException("You asked for the member '" + fieldDef.FieldName + "', but it doesn't exist on type '" + typeof (T) + "'"); 

      var memberAsField = memberInfo as FieldInfo; 

      if (memberAsField != null) 
       memberAsField.SetValue(obj, Convert.ChangeType(fieldStringValue.TrimEnd(), memberAsField.FieldType)); 
      else 
       throw new SerializationException("I don't know what to make of the property '" + fieldDef.FieldName + "'"); 
     } 
     return obj; 
    } 

    public void Serialize(Stream serializationStream, object graph) 
    { 
     var serializableMembers = FormatterServices.GetSerializableMembers(graph.GetType()); 
     var membersToSerialize = _fieldDefinition.Select(fd => serializableMembers.First(sm => sm.Name == fd.FieldName)).ToArray(); 
     var objectData = FormatterServices.GetObjectData(graph, membersToSerialize); 
     var sb = new StringBuilder(_fieldDefinition.Sum(fd => fd.CharLength)); 
     for (var i = 0; i < _fieldDefinition.Length; i++) 
      sb.Append(((String) Convert.ChangeType(objectData[i], typeof (String))).PadRight(_fieldDefinition[i].CharLength), 0, _fieldDefinition[i].CharLength); 
     var sw = new StreamWriter(serializationStream); 
     sw.WriteLine(sb.ToString()); 
     sw.Flush(); 
    } 

    public ISurrogateSelector SurrogateSelector { get; set; } 

    public SerializationBinder Binder { get; set; } 

    public StreamingContext Context { get; set; } 
}