我该如何重构这段代码？

Question

我有.net 3.5，我想制定一个通用方法。我该如何重构这段代码？

            case (int)Enums.SandwichesHoagies.Cheeses:
                if (this.Cheeses.Where(x => x.Id == product.ProductId).SingleOrDefault() == null)
                {
                    var newCheese = new Cheese
                    {
                        Id = product.ProductId,
                        Name = product.Name,
                        PriceValue = product.Price.HasValue ? (double)product.Price.Value : 0.00
                    };

                    this.Cheeses.Add(newCheese);
                }
                else
                {
                    foreach (var cheese in this.Cheeses.Where(cheese => cheese.Id == product.ProductId))
                    {
                        this.Cheeses.Remove(cheese);
                        break;
                    }
                }

                foreach (var cheese in Cheeses) cheese.Type = string.Empty;

                if (this.Cheeses.Count > 0) Cheeses.First().Type = "Cheeses:";

                break;

            case (int)Enums.SandwichesHoagies.Meats:
                if (this.Meats.Where(x => x.Id == product.ProductId).SingleOrDefault() == null)
                {
                    var newMeat = new Meat
                    {
                        Id = product.ProductId,
                        Name = product.Name,
                        PriceValue = product.Price.HasValue ? (double)product.Price.Value : 0.00
                    };

                    this.Meats.Add(newMeat);
                }
                else
                {
                    foreach (var meat in this.Meats.Where(meat => meat.Id == product.ProductId))
                    {
                        this.Meats.Remove(meat);
                        break;
                    }
                }

                foreach (var meat in Meats) meat.Type = string.Empty;

                if (this.Meats.Count > 0) Meats.First().Type = "Meats:";

                break;

Answer 1

假设有两件事：

1. Meat 和 Cheese 继承自 Ingredient 或实现 IIngredient
2. Meats和 Cheeses 集合是 IList

这里我们开始：

private void OuterMethod()
{
   switch(something)
   {
       case (int)Enums.SandwichesHoagies.Cheeses:
           HandleCase(product, this.Cheeses);
           break;
       case (int)Enums.SandwichesHoagies.Meats:
           HandleCase(product, this.Meats);
           break;
   }
}

private void HandleCase<T>(Product product, List<T> list) where T : Ingredient, new()
{
    if(list.Any(i => i.Id == product.ProductId))
    {
        list.Add(new T {
            Id = product.ProductId,
            Name = product.Name,
            PriceValue = product.PriceValue ?? 0.0;
        });
    }
    else
    {
        list.RemoveAll(i => i.Id == product.ProductId);
    }

    //NOTE: this part seems like a bad idea. looks like code smell.
    foreach (var i in list)
    {
        i.Type = string.Empty;
    }
    if (list.Count > 0)
    {
        list.First().Type = "Cheeses:";
    }
}

Answer 2

乍一看，您有一些可以访问的常用属性：Id、Name、PriceValue 和 Type。对我来说，这看起来像是一个基类或接口。这样，您可以首先将代码重构为方法

void YourMethod<T>(List<T> list, Product product) where T : IProduct, new() 
// IProduct being your interface or base class

，在这种情况下，当您引用 this.Meats 或 this.Cheeses 时，您应该引用 list，当您引用 Meat 或 Cheese 实例时，只需引用 T 即可。

看看这能让你走多远并进一步重构。

Answer 3

如果不知道所使用的类型（和基本类型/接口），就很难知道您的确切要求。我假设你正在使用某种 ORM，它无论如何都会吐出部分类。

使其易于使用的第一个要求是 Meat 和 Cheese 共享一个公共接口（或抽象类）。这应该是这样的基本内容。

interface IProduct {
    int Id { get; set; }
    String Name { get; set; }
    Double PriceValue { get; set; }
}

使用分部类的假设使得扩展您的类以使用此接口变得容易。

partial class Cheese : IProduct { }

我发现有趣的是，您有一种不同类型的产品，它具有不同的字段名称，但功能几乎相同。您是否应该保留与上述接口相同的名称，并使其也从该接口派生？不管怎样，假设你拥有的是这样的东西。

class Product {
    int ProductId { get; set; }
    String Name { get; set; }
    Price? Price { get; set; }
}

您要做的第一件事是使用工厂模式来创建特定产品。

public class ProductFactory {
    public T Create<T>(Product product) 
      where T : IProduct, new() {
        return new T {
            Id = product.ProductId,
            Name = product.Name,
            PriceValue = product.Price.HasValue 
                ? (double)product.Price.Value 
                : 0.00    
        };
    }
}

new() 约束需要 Cheese 和 Meat 类中的无参数构造函数。我认为这没有问题。您只需要调用 .Create(product);

接下来的部分，我需要假设您的 Cheeses 和 Meats 对象（或属性）也共享一个公共类（ICollection），或者您可以根据特定需求定义自己的。

public class ProductCollection : ICollection<IProduct> { ... }

检查产品是否存在的通用方法

Boolean ContainsProduct<T>(ProductCollection<T> collection, Product product) 
  where T : IProduct {
    return collection.Where(x => x.Id == product.Id).SingleOrDefault != null;
}

我对您在 foreach 循环内调用 .Remove 的想法表示怀疑。修改集合可能会导致用于循环遍历集合的枚举器出现问题。如果这是一个问题，我会找到更好的方法。