是否有处理大型机数据的模式

您的示例实际上是反序列化，不是来自 XML 或 JSON，而是来自某种自定义文本格式。然后，当您创建类并对其字段进行属性化以帮助序列化/反序列化时，您可以遵循其他序列化程序的方向。我相信这可以称为属性序列化程序模式...

让我们创建一些自定义属性来注释序列化类：

[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
sealed class SomeDataFormatAttribute : Attribute
{
    readonly string name;
    // This is a positional argument
    public SomeDataFormatAttribute(string positionalString)
    {
        this.name = positionalString;
    }
    public string Name
    {
        get { return name; }
    }
} 

然后，您可以将数据对象描述为：

class SymitarAccount
{
    [SomeDataFormat("CLOSEDATE")]
    public string CloseDate;
    [SomeDataFormat("SHARECODE")]
    public int ShareCode;
}

现在您需要基于反射的序列化程序/反序列化程序，它将属性字段与字符串匹配。在这里，我使用正则表达式(为简单起见，没有错误检查(：

public class SomeDataFormatDeserializer
{
    public static T Deserlize<T>(string str) where T : new()
    {
        var result = new T();
        var pattern = @"RSIQ~1~K0(?:~J('w+='d+))*";
        var match = Regex.Match(str, pattern);
        // Get fields of type T
        var fields = typeof(T).GetFields(BindingFlags.Public | BindingFlags.Instance);
        foreach (var field in fields)
        {
           // Get out custom attribute of this field (might return null)
           var attr = field.GetCustomAttribute(typeof(SomeDataFormatAttribute)) as SomeDataFormatAttribute;
           // Find regex capture that starts with attributed name (might return null)
           var capture = match.Groups[1].Captures
                              .Cast<Capture>()
                              .FirstOrDefault(c => c.Value.StartsWith(attr.Name));
           if (capture != null)
           {
              var stringValue = capture.Value.Split('=').Last();
              // Convert string to the proper type (like int)
              var value = Convert.ChangeType(stringValue, field.FieldType);
              field.SetValue(result, value);
           }
        }                                     
        return result;
    }
}

然后你可以像这样简单地使用它：

public static List<SymitarAccount> GetAccounts(string accountId)
{
    var retAccounts = new List<SymitarAccount>();
    var responses = new List<string>() { @"RSIQ~1~K0~JCLOSEDATE=00000000~JSHARECODE=1" };
    foreach (var response in responses)
    {
        var account = SomeDataFormatDeserializer.Deserlize<SymitarAccount>(response);
        retAccounts.Add(account);
    }
    return retAccounts;
}

注意：SomeDataFormatDeserializer是为了清楚起见而编写的，而不是为了性能。当然可以优化(如缓存GetFields等(

我的解决方案：

属性定义：

[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
internal sealed class SymitarInquiryDataFormatAttribute : Attribute
{
    private readonly string _name;
    // This is a positional argument
    public SymitarInquiryDataFormatAttribute(string positionalString) { this._name = positionalString; }
    public string Name { get { return _name; } }
}

数据类：

[Serializable]
public class SymitarAccount
{
    public int PositionalIndex;
    public bool IsClosed{get { return CloseDate.HasValue; }}
    [SymitarInquiryDataFormatAttribute("ID")]
    public int Id;
    [SymitarInquiryDataFormatAttribute("CLOSEDATE")]
    public DateTime? CloseDate;
    [SymitarInquiryDataFormatAttribute("DIVTYPE")]
    public int DivType;
    [SymitarInquiryDataFormatAttribute("BALANCE")]
    public decimal Balance;
    [SymitarInquiryDataFormatAttribute("AVAILABLEBALANCE")]
    public decimal AvailableBalance;
}

扩展：

public static class ExtensionSymitar
{
    public static List<string> ValueList(this string source, string fieldType)
    {
        var list = source.Split('~').ToList();
        return list.Where(a => a.StartsWith(fieldType)).ToList();
    }
    public static string KeyValuePairs(this string source, string fieldType)
    {
        return source.ValueList(fieldType).Aggregate(string.Empty, (current, j) => string.Format("{0}~{1}", current, j));
    }
    public static bool IsMultiRecord(this string source, string fieldType)
    {
        return source.ValueList(fieldType)
                        .Select(q => new Regex(Regex.Escape(q.Split('=').First())).Matches(source).Count > 1).First();
    }
    public static int ParseInt(this string val, string keyName)
    {
        int newValue;
        if (!int.TryParse(val, out newValue))
            throw new Exception("Could not parse " + keyName + " as an integer!");
        return newValue;
    }
    public static decimal ParseMoney(this string val, string keyName)
    {
        decimal newValue;
        if (!decimal.TryParse(val, out newValue))
            throw new Exception("Could not parse " + keyName + " as a money amount!");
        return newValue;
    }
    public static DateTime? ParseDate(this string val, string keyName)
    {
        if (val.Equals("00000000")) return null;
        var year = val.Substring(0, 4).ToInt();
        var mon = val.Substring(4, 2).ToInt();
        var day = val.Substring(6, 2).ToInt();
        if (year <= 1800 || year >= 2200 || mon < 1 || mon > 12 || day < 1 || day > 31)
            throw new Exception("Could not parse " + keyName + " as a date!");
        return new DateTime(year, mon, day);
    }
}

反序列化器：

public class SymitarInquiryDeserializer
{
    /// <summary>
    /// Deserializes a string of J field key value pairs
    /// </summary>
    /// <param name="str">The request or response string</param>
    /// <param name="source">Optional: Use this if you are adding data to the source object</param>
    /// <param name="fieldName">Optional: Use this if you are only populating a single property and know what it is</param>
    /// <typeparam name="T">The target class type to populate</typeparam>
    /// <returns>New T Object or optional Source Object</returns>
    public static T DeserializeFieldJ<T>(string str, T source = null, string fieldName = null) where T : class, new() 
    {
        var result = source ?? new T();
        const string pattern = @"(?:~J('w+='d+))*";
        var match = Regex.Match(str, pattern);
        // Get fields of type T
        var fields = typeof(T).GetFields(BindingFlags.Public | BindingFlags.Instance).ToList();
        if (fieldName != null && fieldName.StartsWith("J")) fieldName = fieldName.Replace("J", "");
        if (!fieldName.IsNullOrEmpty())
        {
            var field = fields.FirstOrDefault(a => a.Name.Equals(fieldName, StringComparison.CurrentCultureIgnoreCase));
            var stringValue = GetValue(field, match);
            if (!stringValue.IsNullOrEmpty())
                SetProperty(field, stringValue, result);
        }
        else
        {
            foreach (var field in fields)
            {
                var stringValue = GetValue(field, match);
                if(!stringValue.IsNullOrEmpty())
                    SetProperty(field, stringValue, result);
            }
        }
        return result;
    }
    private static string GetValue(FieldInfo field, Match match)
    {
        // Get out custom attribute of this field (might return null)
        var attr = field.GetCustomAttribute(typeof(SymitarInquiryDataFormatAttribute)) as SymitarInquiryDataFormatAttribute;
        if (attr == null) return null;
        // Find regex capture that starts with attributed name (might return null)
        var capture = match.Groups[1]
                            .Captures
                            .Cast<Capture>()
                            .FirstOrDefault(c => c.Value.StartsWith(attr.Name, StringComparison.CurrentCultureIgnoreCase));
        return capture == null ? null : capture.Value.Split('=').Last();
    }
    private static void SetProperty<T>(FieldInfo field, string stringValue, T result)
    {
        // Convert string to the proper type (like int)
        if (field.FieldType.FullName.Contains("Int32"))
            field.SetValue(result, stringValue.ParseInt(field.Name));
        else if (field.FieldType.FullName.Contains("Decimal"))
            field.SetValue(result, stringValue.ParseMoney(field.Name));
        else if (field.FieldType.FullName.Contains("DateTime"))
            field.SetValue(result, stringValue.ParseDate(field.Name));
        else
        {
            var value = Convert.ChangeType(stringValue, field.FieldType);
            field.SetValue(result, value);
        }
    }
}

最后，在我的存储库中：

public List<SymitarAccount> GetAccounts(string accountId)
{
    var accountList = new List<SymitarAccount>();
    // build request, get response, parse it...
    var request = "IQ~1~A20424~BAUTOPAY~D101~F7777~HSHARE=0~JID=ALL";
    var response = UnitOfWork.SendMessage(request);
    ParseResponse(response, ref accountList);
    foreach (var account in accountList.Where(a => a.IsClosed == false))
    {
        request = "IQ~1~A20424~BAUTOPAY~D101~F7777~HSHARE#" + account.Id.ToString("0000") + "~JCLOSEDATE~JSHARECODE~JDIVTYPE~JBALANCE~JAVAILABLEBALANCE";
        response = UnitOfWork.SendMessage(request);
        ParseResponse(response, ref accountList, account.Id);
    }
    return accountList;
}
private void ParseResponse(string response, ref List<SymitarAccount> accountList, int? id = null)
{
    var index = 0;
    var list = response.ValueList(fieldType: "J");
    var jString = response.KeyValuePairs(fieldType: "J");
    var isMultiRecord = response.IsMultiRecord(fieldType: "J");
    SymitarAccount account;
    if (isMultiRecord && !id.HasValue)
        foreach (var q in list.Where(a => a.StartsWith("J")))
        {
            // Add object if we don't yet have it in the collection...
            if (accountList.Count <= index)
                accountList.Add(new SymitarAccount { PositionalIndex = index });
            account = accountList.FirstOrDefault(a => a.PositionalIndex == index);
            SymitarInquiryDeserializer.DeserializeFieldJ("~" + q, account, q.Split('=').First());
            index++;
        }
    else if(id.HasValue)
    {
        account = accountList.FirstOrDefault(a => a.Id == id.Value);
        SymitarInquiryDeserializer.DeserializeFieldJ(jString, account);
    }
}

对 ParseResponse 的 2 次调用之间的区别在于，在第一种情况下，我要求返回多条记录(尽管只有 1 个数据属性！(，而在第二种情况下，我请求发回单个记录的额外数据属性。