2 ähnliche Methoden refactoren?

Hallo, ich habe hier Code dieser Art:

public string Method1(int someInt) //Unterschied
{
    if(someBoolean)
        return "test";

    if(someOtherBoolean)
    {
        return "dfjakdsad";
    }
    else
    {
        string myStr = getString(someInt) //Unterschied
        return myStr;
    }
}

public string Method1(decimal someDecimal)
 {
    if(someBoolean)
        return "test";

    if(someOtherBoolean)
    {
        return "dfjakdsad";
    }
    else
    {
        string myStr = getString(someDecimal)
        return myStr;
    }
 }

Die erste der beiden Methoden wird bereits mehrfach verwendet und die Signatur darf nicht verändert werden. Die zweite der beiden ist hinzu gekommen und enthält viel doppelten Code. Der Unterschied iust die Signatur und der Aufruf von getString(). Natürlich sind die beiden Methoden nur ein Beispiel. Wie könnte ich die sinnvoll refactoren?

Danke 😃

Schreit ja fast nach Generics und Delegates.

Definiere dir eine neue Methode, die einen Typparameter hat und einen Delegate nimmt, der den Parameter verwendet:

private string MethodG<T>(T input, Func<T, string> transform)
{
   if (!logicHere)
      return "not logical at all";
   return transform(input);
}

public string Method1(int input)
{
    return MethodG(input, i => i.ToString());
}
public string Method1(string input)
{
    return MethodG(input, s => s.TrimLeft('0'));
}

Dank Type-Inference und Lambda-Expressions kann man damit doch einiges an Code einsparen.
Dein getString dürfte dem transform entsprechen, den Rest darfst du dir selbst erarbeiten 😃

Hi,

[edit]Mist, zu spät...[/edit]

Es ist schwierig ein konkretes Refactoring vorzuschlagen, ohne die wirklichen Methoden und deren Bedeutung zu kennen.

Hier mal ein Beispiel, wie man die Methoden refaktorisieren könnte:

public string Method1(int someInt)
{
  // ggf. den delegaten auf getString cachen für höhere Effizienz
  return InternalMethod(someInt, getString);
}

public string Method1(decimal someDecimal)
{
  // ggf. den delegaten auf getString cachen für höhere Effizienz
  return InternalMethod(someDecimal, getString);
}

private string InternalMethod<T>(T value, Func<T, string> valueToString)
{
  if (someBoolean)
    return "test";

  if (someOtherBoolean)
  {
    return "dfjakdsad";
  }
  else
  {
    string myStr = valueToString(value); 
    return myStr;
  }
}

Oder eine Alternative ohne delegaten, wobei das ggf. nicht optimal ist, falls getString nicht aufgerufen werden darf, falls !someOtherBoolean und/oder der Aufruf teuer ist:

public string Method1(int someInt)
{
  return InternalMethod(getString(someInt));
}

public string Method1(decimal someDecimal)
{
  return InternalMethod(getString(someDecimal));
}

private string InternalMethod(string stringFromValue)
{
  if (someBoolean)
    return "test";

  if (someOtherBoolean)
  {
    return "dfjakdsad";
  }
  else
  {
    string myStr = stringFromValue;
    return myStr;
  }
}

Aber wie gesagt, ohne konkretere Informationen ist das schwierig.

Grüße,
Andre