Optionale Parameter für Schnittstellen

Question

Verwenden von C# 4.0 - Erstellen einer Schnittstelle und einer Klasse, die die Schnittstelle implementiert. Ich möchte einen optionalen Parameter in der Schnittstelle deklarieren und in der Klasse spiegeln lassen. Also, habe ich folgendes:

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

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

Dies kompiliert, aber es sieht nicht richtig aus. Die Schnittstelle benötigt die optionalen Parameter, da sie sonst in der Interface-Methodensignatur nicht korrekt reflektiert wird.

Sollte ich den optionalen Parameter überspringen und nur einen NULL-fähigen Typ verwenden? Oder wird dies wie beabsichtigt ohne Nebenwirkungen oder Konsequenzen funktionieren?

Answer 1

Sie konnten die Pre-optional-Parameter Alternative betrachten:

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 das Aussehen einer neuen Sprache-Funktion nicht gefällt, müssen Sie sie nicht benutzen.

Answer 2

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

Answer 3

Was ist mit so etwas?

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 */ } 
} 

Answer 4

Was ist wirklich seltsam ist, dass der Wert, den Sie für den optionalen Parameter in der Schnittstelle setzen tatsächlich macht einen Unterschied. Ich nehme an, Sie müssen in Frage stellen, ob der Wert ein Interface-Detail oder ein Implementierungsdetail ist. Ich hätte letzteres gesagt, aber die Dinge verhalten sich wie das erste. Der folgende Code gibt zum Beispiel 1 0 2 5 3 7 aus.

// 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); 
     } 
    } 
} 

Welche interessant ist, ist, dass, wenn Ihre Schnittstelle einen Parameter optional die Klasse macht die Umsetzung nicht das gleiche zu tun hat:

// 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); 
     } 
    } 
} 

Was jedoch ein Fehler zu sein scheint, ist, dass, wenn Sie implementieren die Schnittstelle explizit Der Wert, den Sie in der Klasse für den optionalen Wert angeben, ist sinnlos. Wie könnten Sie im folgenden Beispiel den Wert 9 verwenden? Dies gibt nicht einmal 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); 
     } 
    } 
} 

Answer 5

Sie müssen den Parameter in der Implementierung nicht optional machen. Ihr Code wird 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 } 
} 

Auf diese Weise ist es eindeutig, was der Standardwert ist. Ich bin mir ziemlich sicher, dass der Standardwert in der Implementierung keine Auswirkungen hat, da die Schnittstelle einen Standard dafür bietet.

Answer 6

Was zu beachten ist, passiert, wenn Mocking-Frameworks verwendet werden, die auf der Reflexion der Schnittstelle basieren. Wenn optionale Parameter in der Schnittstelle definiert sind, wird der Standardwert basierend auf den Angaben in der Schnittstelle übergeben. Ein Problem besteht darin, dass Sie nichts daran hindern können, unterschiedliche optionale Werte für die Definition festzulegen.