我将创建很多像
这样的课程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方法
public static的{{1}}方法，其签名与Alternative Method，用于测试public static bool Test和Method是否为给定的生成输入集生成等效输出。这些类可能有其他方法作为助手。
有没有一种方法可以创建一个足够通用的界面，它需要上面的内容，但除此之外什么都不知道？或者它需要它的方法有某些签名？
例如，我可能有另一个类，如
Alternative所以我想要一个类似的界面（我知道下面的完全无效......）
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 interface InterviewQuestion
{
public static Method;
public static Alternative;
public static bool Test();
}
答案 0 :(得分：4)
Interfaces (C# Programming Guide)可以包含方法，属性，事件，索引器或这四种成员类型的任意组合......接口不能包含常量，字段，运算符，实例构造函数，析构函数或类型。接口成员自动公开，并且不能包含任何访问修饰符。 会员也不能是静态的。
这意味着您的界面看起来像
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
}
}
你的课程看起来像
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
}
}
或者您可以使用abstract class。然后你的实现看起来像
{{1}}
答案 1 :(得分：1)
其他答案评论了您尝试制作静态界面的事实。
我认为这里更深层次的问题是您正在尝试创建一个方法签名不一致的接口。
有没有办法可以创建一个足够通用的界面，它需要上面的内容，但除此之外什么都不知道？或者它需要它的方法有某些签名吗？
您基本上要求使用未知方法参数创建部分接口。接口必须具有明确定义的签名。
您可以做的是将参数分隔到不同的接口或类，例如
typings -v
1.0.3
即便如此，方法的返回类型必须是常量不变。
当然，public interface IInterviewQuestion
{
int Method(IQuestionInput qParams);
int Alternative(IQuestionInput qParams);
bool Test();
}
可能包含任何内容，这将取决于您需要如何使用这些问题。
答案 2 :(得分：1)
这样的事情怎么样？ ：
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();
}
}
您仍然使用常规接口并使用Singleton模式来模拟静态类
答案 3 :(得分：0)
您可以使用Monostate模式解决此问题。引用网站：
monostate是一个概念单身人士＆＃34; - a的所有数据成员 monostate是静态的，因此monostate的所有实例都使用相同的 （静态）数据。使用monostate的应用程序可以创建任意数量的应用程序 他们想要的实例，因为每个实例使用相同的数据。什么 我发现monostate类非常好，他们避免了所有的 关于必须访问类的特定实例的复杂性。 任何实例都与另一个实例一样好。我发现monostates确实添加了 对于那些沉浸在GOF单身人士中的人来说，这可能会有些困惑 一件坏事。
基本上，不是使用静态类，而是将它们作为常规类。但是，在内部，他们表现得像他们一样静止。成员变量是静态的，因此它们可以在类的实例之间共享。
此方法允许您针对类实现接口。这也意味着如果需要，可以通过接口依赖注入类。此外，如果您决定需要/需要特定于实例的数据，那么它就更容易实现。
注意：在您的情况下，没有状态，因此您要实现该模式以允许您根据具体类型实现接口或抽象类。
答案 4 :(得分：0)
您不能拥有静态接口。为了使接口受益，您必须使其成为常规成员方法。
你可以拥有这个界面：
public interface InterviewQuestion<T1, T2>
{
public Method<T1 arg1, T2 arg2>();
public Alternative<T1 arg1, T2 arg2>();
public bool Test();
}
然后你实现它的实现：
public class M2SA : InterviewQuestion<int[], int[]>
{
//...
}
以及对它的静态访问（或者通过T1访问它更加动态，例如，存储库，无论如何，这是最简单的静态方式）：
public static class InterviewQuestions
{
private static M2SA m2sa = new M2SA();
public static M2SA M2SA => m2sa;
// ...
}
访问：
InterviewQuestions.M2SA.Method(blah, blah);
在您开始编写非静态绑定到其中一个实现的代码之前，这并没有多大价值。您可以通过搜索条件（如T1或T2或两者或其他内容）找到实施方案。您可以创建一个没有泛型参数的接口，并为方法提供对象参数，这允许在不知道类型的情况下调用它。等