Parametry opcjonalne dla interfejsów

Question

Korzystanie z C# 4.0 - tworzenie interfejsu i klasy implementującej interfejs. Chcę zadeklarować opcjonalny parametr w interfejsie i umieścić go w klasie. Tak, mam następujące:

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

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

To kompiluje, ale nie wygląda dobrze. Interfejs musi mieć opcjonalne parametry, ponieważ w przeciwnym razie nie odzwierciedla poprawnie w sygnaturze metody interfejsu.

Czy powinienem pominąć opcjonalny parametr i po prostu użyć typu zerowego? A może to działa zgodnie z przeznaczeniem bez żadnych skutków ubocznych lub konsekwencji?

Answer 1

można rozważyć alternatywę-pre-opcjonalne parametry:

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

Jeśli nie podoba Ci się wygląd nowej funkcji języka, nie trzeba go używać.

Answer 2

Wygląda na to, że zrobi dokładnie to, co brzmi, jak chcesz osiągnąć.

Answer 3

Co powiesz na coś takiego?

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

Co jest naprawdę dziwne jest to, że wartość można umieścić za pomocą opcjonalnego parametru w interfejsie faktycznie robi różnicę. Przypuszczam, że musisz zapytać, czy wartość jest szczegółem interfejsu, czy szczegółem implementacji. Powiedziałbym to drugie, ale rzeczy zachowują się jak poprzednie. Poniższy kod wyprowadza na przykład 1 0 2 5 3 7.

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

Jaki jest rodzaj interesujące jest to, że jeśli interfejs sprawia, że ​​parametr opcjonalny klasy wykonawczych nie musi zrobić to samo:

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

Co wydaje się być błędem jest jednak, że jeśli Interfejs jest jawnie implementowany, wartość podana w klasie dla wartości opcjonalnej jest bezcelowa. Jak w poniższym przykładzie można użyć wartości 9? To nawet nie daje ostrzeżenia podczas kompilacji.

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

Nie trzeba wprowadzać opcjonalnego parametru do implementacji. Twój kod będzie miał trochę więcej sensu niż:

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

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

W ten sposób jest jednoznaczne, jaka jest wartość domyślna. W rzeczywistości jestem pewien, że wartość domyślna w implementacji nie będzie miała żadnego efektu, ponieważ interfejs zapewnia dla niej domyślną wartość.

Answer 6

Należy wziąć pod uwagę to, co się dzieje, gdy używane są makiety, które działają w oparciu o odbicie interfejsu. Jeśli w interfejsie zdefiniowano opcjonalne parametry, wartość domyślna zostanie przekazana w oparciu o deklarację w interfejsie. Jedną z kwestii jest to, że nic nie stoi na przeszkodzie, aby ustawić różne opcjonalne wartości w definicji.