主页 / 问题 / 1449645
Accepted
Vipz
Asked:2022-09-18 16:50:30 +0000 UTC2022-09-18 16:50:30 +0000 UTC

从方法返回元组

  • 772

使用这样的元组是否合适（从方法返回GetProduct()）或者我应该为此创建一个单独的类？

public static class WarehouseGoods
{
    private static object productsLock = new object();

    private static List<Product> products = new List<Product>();

    public static void AddProduct(Product product)
    {
        lock (productsLock)
        {
            products.Add(product);
        }
    }

    public static (bool success,Product product) GetProduct()
    {
        Product? product = null;

        lock (productsLock)
        {
            if (products.Count is not 0)
            {
                product = products.ElementAt(0);
                products.RemoveAt(0);

                return (true,product);
            }
            else
            {
                return (false, product);
            }
        }
    }
}

接下来，我只是检查一下bool，以防万一我True使用Product

            var result = WarehouseGoods.GetProduct();

            if (result.success)
            {
                CheckProduct(result.product);
            }

或者你可以检查productxDnull

那怎么正确？

c#

0 个回答

  1. 在您的情况下，您应该注意 Try 方法的语义，例如Int32.TryParse.

    public static bool TryGetProduct(out Product product)
{
    lock (productsLock)
    {
        if (products.Count is not 0)
        {
            product = products.ElementAt(0);
            products.RemoveAt(0);
            return true;
        }
        else
        {
            product = null;
            return false;
        }
    }
}

    在这种情况下，您既可以返回指示尝试是否成功的值，也可以使用通用约定形式的 out 参数返回可选结果。

    我也会改变这一行：

    products.Count > 0

    至于我，这里没有匹配模式看起来比存在更合乎逻辑。

    • 3
  2. Best Answer

    从逻辑上讲，这看起来像一个线程安全队列，因此请使用线程安全队列。

    我不建议使用静态类，在缩放和控制对象的生命周期时可能会出现问题。在这种情况下，最好使用单例。那么即使你活着看到项目中的 IoC 模式的实现，你也会很高兴你没有静态的。

    public class WarehouseGoods
{
    private static readonly Lazy<WarehouseGoods> _instance = new(() => new WarehouseGoods());
    public static WarehouseGoods Instance => _instance.Value;

    private readonly ConcurrentQueue<Product> products = new();
    private WarehouseGoods() { } // прячу конструктор

    public void AddProduct(Product product)
    {
        products.Enqueue(product);
    }

    public bool GetProduct(out Product product)
    {
        return products.TryDequeue(out product);
    }
}

    使用方便

    WarehouseGoods.Instance.AddProduct(product);

    if (WarehouseGoods.Instance.GetProduct(out Product product))
{
    Use(product); // какая-то работа с продуктом
}

    他给出了解决方案，但没有提及元组。因此，元组是一种轻量级的匿名（即未命名）数据结构。当需要返回多个分组值进行复杂处理时，应该使用元组。

    例如

    public (int, int) GetLocation()
{
    // ...
    return (x, y);
}

    结果将如下所示

    (int x, int y) = GetLocation();

    该元组立即被分解并使用从该方法获得的数据。舒服的。

    你的情况有点不同，一个论点表明结果的成功，也就是粗略的说第二个论点的有效性，也就是这些结果在语义上不是一个逻辑上的单一结构，因此不会很合乎逻辑将它们组合成一个元组。

    在这种情况下，上面显示的另一种方式就可以了，并且（突然）使用它的做法来自我在这里介绍的异常处理逻辑。这种做法在 .NET 中广泛使用，并且几乎所有 C# 开发人员（等）都熟悉int.TryParse，Dictionary.TryGetValue这意味着您的代码将易于阅读，并且该方法的行为看起来是可预测的。

    • 3

  3. 从 C# 8 开始就有 Nullable 引用类型。您可以将它们用作退货选项。
    方法签名将是：

    Product? GetProduct()

    在这种情况下，我们明确指出，当我们忘记初始化某些东西时，结果可能null不是意外错误。

    用法：

    var result = Warehouse.GetProduct();
if (result != null)
    ...

    示例是 LINQ 方法，例如FirstOrDefaultand LastOrDefault- 它们还返回nullable引用类型的值。只有他们不删除该元素。

    此代码效率不高：

    product = products.ElementAt(0);
products.RemoveAt(0);

    它获取第一个元素并将其删除，之后所有其他元素都向前移动一个。如果集合中有很多元素，那么会在这上面花费大量时间。
    最好从最后取出元素。当然，如果程序逻辑允许的话。

    int index = products.Count - 1;
product = products[index];
products.RemoveAt(index);

    这不会移动其余元素。

    • 1

相关问题