Question

我经常想要将字符串解析成各种各样的位，并且有一种可读的方式来返回它们。

我喜欢这种方法，但它涉及创建一个特定的类

long orderID = Utils.UnTradeIdent(tradeIdent).OrderID;

在Utils.cs中：

    public class TradeIdentData
    {
        public string AccountIdent;
        public long OrderID;
        public string SubID;
    }

    public static TradeIdentData UnTradeIdent(string tradeIdent)
    {
        TradeIdentData tradeIdentData = new TradeIdentData();

        var parts = tradeIdent.Split('!');
        tradeIdentData.AccountIdent = parts[0];
        if (parts[1].Contains("."))
        {
            var bits = parts[1].Split('.');
            tradeIdentData.OrderID = long.Parse(bits[1]);
            tradeIdentData.SubID = bits[1];
        }
        else
        {
            tradeIdentData.OrderID = long.Parse(parts[1]);
            tradeIdentData.SubID = "";
        }

        return tradeIdentData;

    }

Answer 1

具有良好命名属性的单独类（您已经在使用）是目前最易读的方法。

在C＃7中，您将能够使用元组作为返回值，如下所示：

public static (string AccountIdent, string OrderID, string SubID) UnTradeIdent(string tradeIdent)
{
    string accountIdent, orderID, subID ;

    ... Code to initialise accountIdent, orderID and subID appropriately ...

    // Now return the data as a tuple:       

    return (accountIdent, orderID, subID);
}

您可以按如下方式使用它：

long orderID = Utils.UnTradeIdent(tradeIdent).OrderID;

或者如果您想要所有值：

var result = Utils.UnTradeIdent(tradeIdent);
// Use result.OrderId, result.SubID or result.AccountIdent

但是，直到明年的某个时候才会出现这种情况。

此外，即使这个新的元组支持使得编写代码更方便，但它也不允许您使用XML注释来记录它。花时间编写一个简单且记录良好的类通常仍然比使用新的C＃7元组支持更好。

See here for more details

Answer 2

您还可以使用out关键字通过引用传递参数，请参阅MSDN文章out (C# Reference)：

public static void UnTradeIdent(string tradeIdent, out string AccountIdent, out long OrderID, out string SubID)
{
    var parts = tradeIdent.Split('!');
    AccountIdent = parts[0];
    if (parts[1].Contains("."))
    {
        var bits = parts[1].Split('.');
        OrderID = long.Parse(bits[1]);
        SubID = bits[1];
    }
    else
    {
        OrderID = long.Parse(parts[1]);
        SubID = "";
    }
}

更新，建议发表评论：

public static bool UnTradeIdent(string tradeIdent, out string AccountIdent, out long OrderID, out string SubID)
{
    bool result = false;
    AccountIdent = "";
    OrderID = 0;
    SubID = "";

    try
    {
        var parts = tradeIdent.Split('!');
        AccountIdent = parts[0];
        if (parts[1].Contains("."))
        {
            var bits = parts[1].Split('.');
            OrderID = long.Parse(bits[1]);
            SubID = bits[1];
        }
        else
        {
            OrderID = long.Parse(parts[1]);
            SubID = "";
        }
    }
    catch(ArgumentNullException ane)
    {
        // Handle parsing exception

    }
    catch (FormatException fe)
    {
        // Handle parsing exception
    }
    catch (OverflowException oe)
    {
        // Handle parsing exception
    }

    return result;
}

Answer 3

只需将返回类型更改为动态并使用匿名类

即可

public static dynamic UnTradeIdent(string tradeIdent)
{
    var value1 = //parselogic
    var value2 = //parselogic
    return new { Identity = value1, Item2 = value2};
}

Answer 4

我会考虑制作额外的静态方法。当您需要所有返回的属性时，您当前的实现更清晰，但是当您只需要其中一个属性时，下面的内容可能是合适的。

public static string TradeIdentToAccountIdent(string tradeIdent)
{
    var parts = tradeIdent.Split('!');

    return parts[0];
}

public static long TradeIdentToOrderID(string tradeIdent)
{
    var parts = tradeIdent.Split('!');
    if (parts[1].Contains("."))
    {
        var bits = parts[1].Split('.');

        return long.Parse(bits[1]); // Taken from your example, should probably be bits[0]?
    }
    else
        return long.Parse(parts[1]);
}

// My own take on it this time, you could obviously use your logic as well.
public static string TradeIdentToSubID(string tradeIdent)
{
    var order = tradeIdent.Split('!')[1];

    if (order.Contains("."))
        return order.Split('.')[1];
    else
        return String.Empty;
}

是否有更简单的方法从静态函数返回字段？

4 个答案: