Question

我想请求下面处理这种情况的最佳方法。

我想用不同的参数为不同的实例调用 populate 函数。我在每个继承类中实现了 populate 函数。但我不知道使用它数百次的最佳方法是什么。

（例如 index 将是世界上的国家总数）。

public enum TCountry
{
   tAustralia,
   tUnitedKingdom,
   .. etc..
}
public enum TCity
{
   tSydney,
   tLondon,
   ... etc..
}
public int ProcessData ( string population, int index)
{
   switch (index)
   {
      case 0: 
         TypeAust aus = new TypeAust();
         retun aus.poulate( population, tAustralia, tSydney);
         // Different calculation Sydney -Aus
         DisplayAus(); // Display for Sydney - Aus

      case 1: 
         TypeUK uk = new TypeUK();
         retun uk.poulate( population, tUnitedKingdom, tLondon);
         // Different calculation for Londond - UK
         DisplayUK(); // Display for London - UK
      ....
      ... etc..
   }
}

先谢谢

Answer 1

我建议采用不同的设计。不要使用该case语句，而是将所有类型放入集合中并调用populate，而不知道您正在使用哪种特定类型。

 List<TypeCountry> countries = new List<TypeCountry>() { new TypeUK(), TypeAus(), TypeUS() //ect };
 //use this list all throughout the program

而不是你切换语句，你可以这样做;

  return countries[index].populate( //args go here );

然后你可以做其他的事情，比如;

  int worldPop = countries.Aggregate((c, n) => c.Populate(//args) + n.Populate(//args));

通常，您需要停止对每种类型进行处理，就好像它与下一种类型不同。将您的逻辑移动到基类中，删除必须按名称引用类型的代码，或者需要对其继承类型进行特定检查。对于几乎所有情况，您都应该能够拥有基类类型的集合并传递它并对其进行处理，而无需知道您正在处理的特定实例的类型。如果情况并非如此，那么你做的继承是错误的。如果你有那么大的案例陈述，那么即使使用继承也没有意义，因为据我所知，你没有得到任何好处。

Answer 2

我必须看到更多您的实际需求和架构，但您可以查看泛型。

public int ProcessData<T>(string population) where T : BaseCountry, new() {
    var country = new T();
    Display(country);
    return country.Populate(population);
}

public void Display<T>(T country) where T : BaseCountry { ... }

您将使用ProcessData，如：

ProcessData<TypeAust>(99);

您的显示方法也是通用的。这样，您的流程数据方法始终受限于使用任何实现BaseCountry的方法。 BaseCountry将定义一个抽象或虚拟的Populate（）方法。

Answer 3

你可以这样做，所以逻辑分为不同的类：

public enum TCountry
{
   tAustralia,
   tUnitedKingdom
}
public enum TCity
{
   tSydney,
   tLondon
}

public abstract class TypeCountry
{
    public abstract int Populate(string population);
}

public class TypeAust : TypeCountry
{
    public override int Populate(string population)
    {
        // do your calculation with tAustralia, tSydney...
    }
}

public class TypeUK: TypeCountry
{
    public override int Populate(string population)
    {
        // do your calculation with tUnitedKingdom, tLondon...
    }
}

public static class TypeCountryFactory
{
    public static TypeCountry GetCountry(TCountry country)
    {
        switch (country)
        {
            case TCountry.tAustralia:
                return new TypeAust();
            case TCountry.tUnitedKingdom:
                return new TypeUK();
        }
    }
}

public int ProcessData (string population, int TCountry)
{
    TypeCountry country = TypeCountryFactory.GetCountry(TCountry);

    return country.Populate(population);
}

c＃中具有不同参数的多个函数

3 个答案: