Geek Quizz IV: méthodes identiques ?


Combien de méthodes d’instance (non statique) de même nom une classe peut-elle contenir ? (et de même signature, oublions les overloads).


Mitsu


[Update] : Méthodes génériques: réponse au quizz
[Update] Quizz suivant: Geek Quizz V: révision sur les constructeurs

Comments (17)

  1. Zim says:

    Lors de l’implémentation explicite d’interface, considère-t-on que IInterfaceA.Method et IInterfaceB.Method sont de signature identique ?

  2. mitsu says:

    Oui ! Ma question n’est pas tout à fait exacte mais on se comprend. Cela fait donc déjà une solution.

  3. sailro says:

    deux méthodes de même nom avec par exemple un paramètre ‘int’ peuvent coexister s’il l’une déclare son paramètre avec le modificateur ‘ref’ ou ‘out’ par exemple. Par contre considère t-on que les signatures soient identiques? limite … Al’appel il ne peut y avoir ambiguité puisque l’on rappelle le modificateur.

  4. Simon says:

    Est-ce que les méthodes surdéfinies comptent?

    public class BaseClass

    {

       public void Foo();

    }

    public class ChildClass : BaseClass

    {

      public new void Foo();

    }

    étant donné que les 2 méthodes sont accessibles à partir d’une instance de ChildClass ?

  5. romagny13 says:

    humm de meme signature(même nom,même nombre de parametres) je pense qu’il ne peut y avoir qu’une seule ? non

    mais il doit y avoir un piege c’est trop evident :p

  6. mitsu says:

    De bonnes idées mais je ne garde valide que la signature avec les interfaces qui fait cohabiter dans des portées différentes des méthodes de même signature.

    Je pense cependant à une autre solution dont il faut se méfier. Un indice: cette solution n’existe que depuis C# 2.0. (il me semble même que j’en parle dans les webcasts "C# 2.0, un an après").

    Mitsu

  7. Bonsoir c’est interessant ces quizz

    bon je sais pas si c’est exactement la même chose que zim

    mais

    public interface interfaceDemo

       {

           string Method();

       }

       public class ChildInterfaceDemo : interfaceDemo

       {

           // implementation "classique"

           #region interfaceDemo Membres

           public string Method()

           {

               return "depuis Method()";

           }

           #endregion

           // force à utiliser cette methode depuis une instance de l’interface !! (.NET 2.0)

           #region interfaceDemo Membres

           string interfaceDemo.Method()

           {

               return "depuis interfaceDemo.Method()";

           }

           #endregion

       }

    //

    interfaceDemo interfaceDemo1 = new ChildInterfaceDemo();

               MessageBox.Show(interfaceDemo1.Method());

               ChildInterfaceDemo interfaceDemo2 = new ChildInterfaceDemo();

               MessageBox.Show(interfaceDemo2.Method());

    et la on a bien accès à deux méthodes de la même classe mais bon humm …

    je vais continuer à chercher

    vous n’auriez pas un indice ? :p

  8. mitsu says:

    On est tous d’accord avec Zim, mais il y a un autre cas.

    L’indice: c’est depuis .Net 2 only !

    (l’implémentation implicite ou explicite a toujours existé. En C# en tout cas…)

    Mitsu

  9. Simon says:

    public class MaClass<T>

    {

      public void Foo()

      {

         // Do something

      }

    }

    La méthode Foo éxiste autant de fois qu’il éxiste de "T". C’est ce que tu cherchais ?

  10. Stéphane says:

    Dans le même style :

    class Program

    {

    static void Main(string[] args)

    {

    MaClass<int> p = new MaClass<int>();

    p.Foo(5);

    p.Foo(6);

    Console.ReadLine();

    }

    }

    public class MaClass<T>

    {

    public void Foo(T param)

    {

    Console.WriteLine("Generics " + param);

    }

    public void Foo(int param)

    {

    Console.WriteLine(param);

    }

    }

    A l’exécution, on ne passe pas par la méthode avec le type générique.

  11. Tetranos says:

    Remarque (qui n’est pas une réponse puisque Mitsu parle de C# 2.0) :

    Soit une classe C avec une méthode M(). Il est possible de définir sur C plusieurs méthodes d’extensions M(). Cela ne sert à rien vu que seule la méthode M() de la classe est appelée mais ça compile et ça s’exécute…

    Les méthodes d’extensions sont statiques mais d’un point de vue syntaxique l’appel ressemble à une méthode d’instance.

  12. mathmax says:

    Dans le même ordre d’idée que Tetranos, on peut définir des méthode d’extensions sur différentes interfaces implémentées par notre classe C. On peut alors appelé chacune des méthodes propre à l’interface :

       class Program

       {

           static void Main(string[] args)

           {

               Test t = new Test();

               t.ShowMessage();

               ((IA)t).ShowMessage();

               ((IB)t).ShowMessage();

           }

       }

       public interface IA { }

       public interface IB { }

       public static class IExtensions

       {

           private Dictionary<IA, string> Property = new Dictionary<IA, string>();

           public static string GetProperty(this IA i)

           {

           }

           public static string SetProperty(this IA i)

           {

               if(Property.)

           }

           public static void ShowMessage(this IA i)

           {

               Console.WriteLine("méthode ShowMessage() de IA");

           }

           public static void ShowMessage(this IB i)

           {

               Console.WriteLine("méthode ShowMessage() de IB");

           }

       }

       public class Test : IA, IB

       {

           public void ShowMessage()

           {

               Console.WriteLine("méthode ShowMessage() de Test");

           }    

       }

  13. je ne pense que c’est ce qui est attendu mais j’ai remarqué que l’on peut encore en plus des interfaces utiliser une methode abstract

    exemple :

    public interface IA

       {

           string Method();

       }

       public interface IB

       {

           string Method();

       }

       public abstract class AbstractClass

       {

           public abstract string Method();

       }

       public class DemoClass : AbstractClass, IA, IB

       {

           string IA.Method()

           {

               return "depuis IA.Method()";

           }

           string IB.Method()

           {

               return "depuis IB.Method()";

           }

          public override string Method()

          {

              return "depuis abstract Method()";

          }

       }

             // Utilisation

              IA iA = new DemoClass();

               IB iB = new DemoClass();

               AbstractClass abstractClass = new DemoClass();

               MessageBox.Show(iA.Method());

               MessageBox.Show(iB.Method());

               MessageBox.Show(abstractClass.Method());

    ++

  14. Voici donc la réponse au post précédent sur les possibilités de déclarer des méthodes de signatures identiques

  15. Voici donc la réponse au post précédent sur les possibilités de déclarer des méthodes de signatures identiques

  16. Pourquoi donc ce code ne compile-t-il pas ? L’intérêt est bien évidemment de trouver sans compiler le

  17. Dargos says:

    et les methodes génériques, avec l’inférence de type !