Optionale Parameter für Schnittstellen

Verwendung von c# 4.0-Aufbau einer Schnittstelle und einer Klasse, die die Schnittstelle implementiert. Ich will erklären einen optionalen parameter in der Schnittstelle und haben es sich in der Klasse. Also, ich habe Folgendes:

 public interface IFoo
 {
      void Bar(int i, int j=0);
 }

 public class Foo
 {
      void Bar(int i, int j=0) { //do stuff }
 }

Diese kompiliert, aber es sieht nicht richtig aus. Das interface muss der optionale Parameter, weil es sonst spiegelt nicht richtig in der Schnittstelle Signatur der Methode.

Sollte ich überspringen Sie die optionalen parameter und benutzen Sie einfach eine nullable-Typ? Oder wird das so funktionieren wie Sie sollen ohne Nebenwirkungen oder Folgen?

InformationsquelleAutor der Frage bryanjonker | 2010-04-02

  1. 28

    Kann man das pre-optionale-Parameter alternative:

    public interface IFoo
{
    void Bar(int i, int j);
}

public static class FooOptionalExtensions
{
    public static void Bar(this IFoo foo, int i)
    {
        foo.Bar(i, 0);
    }
}

    Wenn Sie nicht wie das Aussehen der eine neue Sprache-Funktion, die Sie nicht haben, um es zu verwenden.

    InformationsquelleAutor der Antwort pdr

  2. 48

    Was ist wirklich seltsam ist, dass der Wert, den Sie setzen Sie für den optionalen parameter in der Schnittstelle tatsächlich einen Unterschied macht. Ich nehme an, Sie haben die Frage, ob der Wert eine Schnittstelle detail oder eine Implementierung detail. Hätte ich gesagt, das letztere aber die Dinge Verhalten sich ähnlich wie die früheren. Der folgende code gibt 1 0 2 5 3 7 zum Beispiel.

    //Output:
//1 0
//2 5
//3 7
namespace ScrapCSConsole
{
    using System;

    interface IMyTest
    {
        void MyTestMethod(int notOptional, int optional = 5);
    }

    interface IMyOtherTest
    {
        void MyTestMethod(int notOptional, int optional = 7);
    }

    class MyTest : IMyTest, IMyOtherTest
    {
        public void MyTestMethod(int notOptional, int optional = 0)
        {
            Console.WriteLine(string.Format("{0} {1}", notOptional, optional));
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyTest myTest1 = new MyTest();
            myTest1.MyTestMethod(1);

            IMyTest myTest2 = myTest1;
            myTest2.MyTestMethod(2);

            IMyOtherTest myTest3 = myTest1;
            myTest3.MyTestMethod(3);
        }
    }
}

    Was irgendwie interessant ist, ist, dass wenn Ihre Schnittstelle lässt sich ein parameter optional ist die Klasse die es nicht haben, das gleiche zu tun:

    //Optput:
//2 5
namespace ScrapCSConsole
{
    using System;

    interface IMyTest
    {
        void MyTestMethod(int notOptional, int optional = 5);
    }

    class MyTest : IMyTest
    {
        public void MyTestMethod(int notOptional, int optional)
        {
            Console.WriteLine(string.Format("{0} {1}", notOptional, optional));
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyTest myTest1 = new MyTest();
            //The following line won't compile as it does not pass a required
            //parameter.
            //myTest1.MyTestMethod(1);

            IMyTest myTest2 = myTest1;
            myTest2.MyTestMethod(2);
        }
    }
}

    Dem, was scheint, ein Fehler jedoch ist, dass, wenn Sie die Schnittstelle implementieren, die explizit den Wert, den Sie geben in der Klasse für die optionale Wert ist sinnlos. Wie im folgenden Beispiel könnten Sie den Wert 9? Dies bedeutet nicht, geben sogar eine Warnung beim kompilieren.

    //Optput:
//2 5
namespace ScrapCSConsole
{
    using System;

    interface IMyTest
    {
        void MyTestMethod(int notOptional, int optional = 5);
    }

    class MyTest : IMyTest
    {
        void IMyTest.MyTestMethod(int notOptional, int optional = 9)
        {
            Console.WriteLine(string.Format("{0} {1}", notOptional, optional));
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyTest myTest1 = new MyTest();
            //The following line won't compile as MyTest method is not available
            //without first casting to IMyTest
            //myTest1.MyTestMethod(1);

            IMyTest myTest2 = new MyTest();            
            myTest2.MyTestMethod(2);
        }
    }
}

    InformationsquelleAutor der Antwort Martin Brown

  3. 3

    Was ist mit sowas?

    public interface IFoo
{
    void Bar(int i, int j);
}

public static class IFooExtensions 
{
    public static void Baz(this IFoo foo, int i, int j = 0) 
    {
        foo.Bar(i, j);
    }
}

public class Foo
{
    void Bar(int i, int j) { /* do stuff */ }
}

    InformationsquelleAutor der Antwort Dave

  4. 3

    Sie nicht haben, um die parameter, die optional in der Implementierung. Ihr code machen etwas mehr Sinn, dann:

     public interface IFoo
 {
      void Bar(int i, int j = 0);
 }

 public class Foo
 {
      void Bar(int i, int j) { //do stuff }
 }

    Diese Weise, es ist eindeutig, was der default Wert ist. In der Tat, ich bin ziemlich sicher, dass der Standardwert in der Implementierung wird keine Wirkung haben, da das interface stellt einen Standard für die it.

    InformationsquelleAutor der Antwort Tor Haugen

  5. 2

    Die Sache zu prüfen, ist, was passiert, wenn Mocking-frameworks verwendet werden, die basierend auf der Reflexion von der Oberfläche.
    Wenn der optionale Parameter definiert die Schnittstelle, Standard-Wert übergeben werden würde, basierend auf was ist in der Schnittstelle deklariert sind.
    Ein Problem ist, dass es gibt nichts stoppen Sie von der Einstellung der verschiedenen optionalen Werte auf die definition.

    InformationsquelleAutor der Antwort Hitesh

  6. 1

    Sieht beiseite, das wird genau das tun, was es klingt wie, die Sie erreichen möchten.

    InformationsquelleAutor der Antwort MojoFilter

Schreibe einen Kommentar