この一般的なインターフェイスを作成することは可能ですか？

Question

は、私は、彼らがすべて実装することで

public static class M2SA 
{ 
    // Median of 2 sorted arrays 

    public static int Method (int[] A, int[] B) 
    { 
     int m = A.Length, n = B.Length; 
     if((m | n) == 0) 
      throw new ArgumentException("A and B cannot both be empty"); 
     int i = 0, j = 0, k = (m + n)/2; 
     while((i + j) < k) 
     { 
      if(i == m) ++j; 
      else if(j == n || A[i] <= B[j]) ++i; 
      else ++j; 
     } 
     if(i == m) return B[j]; 
     else if(j == n) return A[i]; 
     else return Math.Min(A[i],B[j]); 
    } 

    public static int Alternative (int[] A, int[] B) 
    { 
     if ((A.Length | B.Length) == 0) 
      throw new ArgumentException("A and B cannot both be empty"); 
     int[] mergedAndSorted = A.Concat(B).OrderBy(x => x).ToArray(); 
     return mergedAndSorted[mergedAndSorted.Length/2]; 
    } 

    public static bool Test() 
    { 
     return false;//Placeholder - haven't implemented yet 
    } 
} 

のようなクラスの多くを作成するつもりです

• という名前public static方法Method
• 同じを持っているAlternativeという名前public static方法署名がMethod
• のように、public static bool Testとして、MethodおよびAlternativeは、生成された入力のセットに対して同等の出力を生成します。

これらのクラスには、ヘルパーとして機能する他のメソッドが含まれている場合があります。

一般的なインターフェイスを一般的に作成する方法はありますか？上記以外には何も分かりません。あるいは、そのメソッドに特定のシグネチャが必要なのでしょうか？

例えば、私は、だから私は

public static interface InterviewQuestion 
{ 
    public static Method; 
    public static Alternative; 
    public static bool Test(); 
} 

（私は以下の知っている完全無効です...）のようなものであるインターフェイスをしたい

public static class UnstablePartition 
{ 

    public static void intswap(ref int a, ref int b) 
    { 
     // I'm amazed that there isn't already a method for this in the .NET library (???) 
     int temp = a; 
     a = b; 
     b = temp; 
    } 

    public delegate bool UnaryPredicate (int i); 

    public static void Method (int[] arr, UnaryPredicate pred) 
    { 
     for(int i = 0, j = arr.Length; i < j;) 
     { 
      if (!pred(arr[i])) ++i; 
      else if (pred(arr[j])) --j; 
      else intswap(ref arr[i],ref arr[j]); 
     } 
    } 

    public static void Alternative(int[] arr, UnaryPredicate pred) 
    { 
     int[] partioned = new int[arr.Length]; 
     for (int ai = 0, pi = 0, pj = partioned.Length; ai < arr.Length; ++ai) 
     { 
      if (pred(arr[ai])) partioned[pj--] = arr[ai]; 
      else partioned[pi++] = arr[ai]; 
     } 
     Array.Copy(partioned, arr, partioned.Length); 
    } 


    public static bool Test() 
    { 
     return false;//Placeholder - haven't implemented yet 
    } 

} 

のような別のクラスを持っているかもしれませんそれから私はそれを実装します

public static class M2SA : InterviewQuestion 

Answer 1

Interfaces (C# Programming Guide)には、メソッド、プロパティ、イベント、インデクサ、またはこれらの4つのメンバタイプの任意の組み合わせを含めることができます...インターフェイスには、定数、フィールド、演算子、インスタンスコンストラクタ、デストラクタ、または型を含めることはできません。インターフェイスメンバは自動的に公開され、アクセス修飾子は含まれません。 メンバも静的にすることはできません。

それはあなたのインターフェースが

public interface InterviewQuestion 
{ 
    int Method(int[] a, int[] b); 
    int Alternative(int[] a, int[] b); 
    bool Test(); 
} 

のようになります。そして、あなたのクラスは

public class M2SA : InterviewQuestion 
{ 
    public int Alternative(int[] a, int[] b) 
    { 
     // implementation 
    } 

    public int Method(int[] a, int[] b) 
    { 
     // implementation 
    } 

    public bool Test() 
    { 
     // implementation 
    } 
} 

public class UnstablePartition : InterviewQuestion 
{ 
    public int Alternative(int[] a, int[] b) 
    { 
     // implementation 
    } 

    public int Method(int[] a, int[] b) 
    { 
     // implementation 
    } 

    public bool Test() 
    { 
     // implementation 
    } 
} 

ようになりそれともabstract classを使用できることを意味します。実装は次のようになります

public abstract class InterviewQuestion 
{ 
    public abstract int Method(int[] a, int[] b); 
    public abstract int Alternative(int[] a, int[] b); 
    public abstract bool Test(); 
} 

public class M2SA : InterviewQuestion 
{ 
    public override int Alternative(int[] a, int[] b) 
    { 
     // implementation 
    } 

    public override int Method(int[] a, int[] b) 
    { 
     // implementation 
    } 

    public override bool Test() 
    { 
     // implementation 
    } 
} 

public class UnstablePartition : InterviewQuestion 
{ 
    public override int Alternative(int[] a, int[] b) 
    { 
     // implementation 
    } 

    public override int Method(int[] a, int[] b) 
    { 
     // implementation 
    } 

    public override bool Test() 
    { 
     // implementation 
    } 
} 

Answer 2

これを回避するには、Monostateパターンを使用できます。ウェブサイトから引用します。

monostateは「概念的なシングルトン」である - monostateのすべてのデータメンバーがそうmonostateのすべてのインスタンスは、同じ （静的）データを使用して、静的です。モノスタティットを使用するアプリケーションは、それぞれのインスタンスが同じデータを使用しているので、必要な数だけ任意の数の インスタンスを作成できます。何が 私はmonostateクラスについて非常に良い見つける彼らはクラスの特定のインスタンスにアクセスすることについての 合併症のすべてを避けることです。 いずれのインスタンスも別のインスタンスと同じ良好です。私は単調増加がGOFシングルトンで浸されている人にいくつかの混乱を 追加することを発見しました、これは 悪いことかもしれません。

基本的に、静的なクラスを持つ代わりに、それらを通常のクラスにします。しかし、内部的には静的な振る舞いをしています。メンバー変数はスタティックなので、クラスのインスタンス間で共有することができます。

この方法では、クラスに対してインターフェイスを実装できます。また、必要に応じて、そこからインタフェースを介して依存関係を注入することもできます。また、インスタンス固有のデータが必要な線を決定する必要がありますが、実装が簡単です。

注：あなたのケースでは状態はないので、具体的なタイプに対してインターフェースまたは抽象クラスを実装できるようにパターンを実装しています。

Answer 3

その他の回答は、静的インターフェイスを作成しようとしているという事実にコメントしています。

ここで深刻な問題は、一貫性のないメソッドシグネチャでインターフェイスを作成しようとしていることです。

上記の要件を満たすだけの一般的なインターフェイスを作成する方法はありますか？あるいは、そのメソッドに特定のシグネチャが必要なのでしょうか？

基本的に、未知のメソッドパラメータで部分的なインターフェイスを作成するように求めています。インタフェースには明確な署名が必要です。

あなたができることは、パラメータを別のインターフェイスやクラスに分けることです。それでも

public interface IInterviewQuestion 
{ 
    int Method(IQuestionInput qParams); 
    int Alternative(IQuestionInput qParams); 
    bool Test(); 
} 

、メソッドの戻り値の型は定数不変でなければなりません。

もちろん、IQuestionInputにはおそらく何かが含まれていて、どのように役立つかは質問の使い方によって異なります。

Answer 4

このようなものはどうですか？ ：

public interface InterviewQuestion<T, TResult> 
{ 
    TResult Method (Func<T, TResult> func); 
    TResult Alternative (Func<T, TResult> func); 
    bool Test (); 
} 

public class M2SA : InterviewQuestion<Tuple<int[], int[]>, int> 
{ 
    private static Lazy<M2SA> lazy = new Lazy<M2SA>(() => new M2SA(), true); 

    public static M2SA Instance => lazy.Value; 

    public int Alternative (Func<Tuple<int[], int[]>, int> func) 
    { 
     throw new NotImplementedException(); 
    } 

    public int Method (Func<Tuple<int[], int[]>, int> func) 
    { 
     throw new NotImplementedException(); 
    } 

    public bool Test () 
    { 
     throw new NotImplementedException(); 
    } 
} 

あなたはまだ定期的なインターフェースを使用して、あなたは静的なインタフェースを持つことができない静的なクラス

Answer 5

を模倣するSingletonパターンを使用します。インターフェイスの利点を生かすためには、それを通常のメンバーメソッドにする必要があります。あなたの実装がそれを実装する

その後

public interface InterviewQuestion<T1, T2> 
{ 
    public Method<T1 arg1, T2 arg2>(); 
    public Alternative<T1 arg1, T2 arg2>(); 
    public bool Test(); 
} 

：

あなたはこのインタフェース持つことができ、よりダイナミック例えばT1によるアクセスをすることにより

public class M2SA : InterviewQuestion<int[], int[]> 
{ 
    //... 
} 

そして、それへのスタティックアクセス（または、リポジトリ、何でも、これはここで最も静かな静的な方法です）：

public static class InterviewQuestions 
{ 
    private static M2SA m2sa = new M2SA(); 
    public static M2SA M2SA => m2sa; 

    // ... 
} 

Acces s：

これは、実装の1つに静的にバインドされていないコードの記述を開始するまではあまり価値がありません。 T1やT2、またはその両方などの検索条件で実装を見つけることができます。ジェネリック引数なしでインターフェイスを作成し、メソッドにオブジェクト引数を渡すと、型を知らなくても呼び出すことができます。その他