在这种情况下如何使用委托/泛型？

Question

I have 2 enums enum1, enum2.

I have two functions :

bool func1(int param1 , enum1 type)
bool func1(int param1 , enum2 type)

Both functions have exactly similar structure. Only difference in all conditions is: func1 has enum1.str1 is used in all comparisons and func2 has enum2.str2 is used in all comparisons

Since both functions are similar, I want to combine the two.. What is the best way to do it?

func1(int param1, enum1 type)
{

      if (type.Equals(enum1.abc))
      {
        // do something
      }
      else if(type.Equals(enum1.def))
      {
    // do something
      }

}


func2(int param1, enum2 type)
{

      if (type.Equals(enum2.abcd))
      {
        // do something
      }
      else if(type.Equals(enum2.defg))
      {
    // do something
      }

}

Answer 1

There are two ways to handle this that are simple and the decision to do this depends on the compatibility of enum1 and enum2 .

If they are 100% compatible, then you can imagine this:

bool Func1(int param1, enum1 type)
{
     switch (type) {
         case enum1.abc:
         // ...
         break
         // ...
     }
}

bool Func2(int param1, enum2 type) { Func1(param1, ToEnum1(type)) }

private static enum1 ToEnum1(enum2 type)
{
    switch(type)
    {
        case enum2.abc: return enum1.abc;
        // ...
        default: throw new NotImplementedException("missed a case!");
    }
}

Now, why am I using a function with a switch to convert instead of casting? The answer is to catch the bug when you have change the layout of one enum and not the other - that's bad.

If the types aren't compatible, consider that you could define a 3rd enum which consists of all the overlapping values plus all the non-overlapping values - you're essentially creating a proper union of the two enumerated types. Convert to that write Func1 based on the third enum. You can (and probably should) make the third type private to the class that's doing the work.

In essence they are essentially the same solution, it's just that in the first case one of the enumerated types is already the same as the third type.

Answer 2

If the underlying enum values match:

bool Func1(int param1, enum1 type)
{
    return Func2(param1, (enum2)type);
}

If they are different:

bool Func1(int param1, enum1 type)
{
    switch (type)
    {
        case enum1.abc: return Func2(param1, enum2.abc);
        case enum1.def: return Func2(param1, enum2.def);
    }
}

Answer 3

It doesn't sound like generics is necessarily the best solution here. If you're primarily interested in reducing code reuse, you might try something like this instead:

func1(int param1, enum1 type)
{
    if (type.Equals(enum1.abc))
    {
        doSomethingAbc(param1);
    }
    else if(type.Equals(enum1.def))
    {
        doSomethingDef(param1);
    }
}


func2(int param1, enum2 type)
{
    if (type.Equals(enum2.abc))
    {
        doSomethingAbc(param1);
    }
    else if(type.Equals(enum2.def))
    {
        doSomethingDef(param1);
    }
}

private void doSomethingAbc(int param1) { ... }
private void doSomethingDef(int param1) { ... }