Estensioni C #

Question

In genere utilizzo i metodi di estensione con molta parsimonia. Quando mi sento in dovere di scrivere un metodo di estensione, a volte voglio sovraccaricare il metodo. La mia domanda è: cosa ne pensi dei metodi di estensione che chiamano altri metodi di estensione? Cattiva pratica? Sembra sbagliato, ma non riesco davvero a definire il perché.

Ad esempio, il secondo metodo CaselessIs chiama il primo:

public static bool CaselessIs(this string s, string compareTo)
{
    return string.Compare(s, compareTo, true) == 0;
}

public static bool CaselessIs(this string s, IEnumerable<string> compareTo)
{
    foreach(string comparison in compareTo)
    {
        if (s.CaselessIs(comparison))
        {
            return true;
        }
    }

    return false;
}

Sarebbe più appropriato non farlo? Il rovescio della medaglia sarebbe che viola DRY.

public static bool CaselessIs(this string s, string compareTo)
{
    return string.Compare(s, compareTo, true) == 0;
}

public static bool CaselessIs(this string s, IEnumerable<string> compareTo)
{
    foreach(string comparison in compareTo)
    {
        if (string.Compare(s, comparison, true) == 0)
        {
            return true;
        }
    }

    return false;
}

Answer 1

Dovrei dire che i controlli DRY qui. Personalmente, non vedo nulla di sbagliato in un metodo di estensione che chiama un altro metodo di estensione, specialmente se quell'altra estensione è contenuta nello stesso assembly. Complessivamente, le chiamate al metodo sono appena tradotte dal compilatore da:

extended.ExtensionMethod(foo);

a:

StaticType.ExtensionMethod(extended, foo);

Non vedo alcun problema nel concatenare due metodi statici insieme, quindi transitivamente non vedo alcun problema nel concatenare due metodi di estensione.

Answer 2

Personalmente non vedo alcun problema, il secondo scenario che ritengo più sbagliato ....

Answer 3

Perfettamente giusto. Perché dovrebbe essere sbagliato?

Mentre stai definendo un metodo di estensione, stai implicitamente prendendo di mira il framework 3.0 (in realtà le estensioni del compilatore delle nuove lingue) quindi non c'è niente di sbagliato nell'usare solo un'altra estensione per fare il lavoro.

Esaminando i commenti non c'è niente di sbagliato in nessuna versione, nemmeno se il "altro" l'estensione era in un'altra libreria, almeno non nel senso di "usare" un'estensione da un'altra. Le estensioni sono solo una funzione di sintassi che aiuta a comprendere meglio la logica sottostante tra il codice, aggiungendo alcune normali operazioni a una classe ... in realtà sono solo chiamate mascherate ai metodi e in questo modo dovresti applicare esattamente la stessa restrizione che usi con chiamate di metodo.

Answer 4

Non ho alcun problema con me stesso, anche se, se ti fa sentire meglio, potresti sicuramente usare la versione statica:

public static bool CaselessIs(this string s, IEnumerable<string> compareTo)
{
   foreach(string comparison in compareTo)
   {
      if (Extensions.CaselessIs(s, comparison))
      {
         return true;
      }
   }

   return false;
}

Personalmente, in questo esempio, l'avrei chiamato CaselessMatches, e avrei avuto la singolare chiamata al plurale ... ma questo è solo pignolo, suppongo.

Answer 5

Non vedo nulla di sbagliato in questo. Supponiamo che tu crei un someClass.ToMySpecialString (). Perché non dovresti essere in grado di sovraccaricarlo se someClass.ToString () ha già più sovraccarichi?