C#：创建抽象类的实例而不定义新类

Question

我知道这可以用 Java 完成，因为我过去已经广泛使用过这种技术。 下面显示了 Java 中的示例。 （附加问题。这种技术叫什么？很难找到没有名称的示例。）

public abstract class Example {
   public abstract void doStuff();
}

public class StartHere{
   public static void main(string[] args){
      Example x = new Example(){
         public void doStuff(){
            System.out.println("Did stuff");
         }            
      };
      x.doStuff();
   }
}

现在，我的主要问题是，这也可以在 C# 中完成吗？如果可以，如何实现？

Answer 1

Java 技术称为“匿名内部类”， C# 中没有等效的。

Answer 2

使用巴巴表达式和类初始值设定项，您可以通过一些努力获得相同的行为。

public class Example {
    public Action DoStuff;
    public Action<int> DoStuffWithParameter;
    public Func<int> DoStuffWithReturnValue;
}

class Program {
    static void Main(string[] args) {
        var x = new Example() {
            DoStuff = () => {
                Console.WriteLine("Did Stuff");
            },
            DoStuffWithParameter = (p) => {
                Console.WriteLine("Did Stuff with parameter " + p);
            },
            DoStuffWithReturnValue = () => { return 99; }


        };

        x.DoStuff();
        x.DoStuffWithParameter(10);
        int value = x.DoStuffWithReturnValue();
        Console.WriteLine("Return value " + value);
        Console.ReadLine();
    }
}

我刚刚意识到这个解决方案的一个问题是，如果您要在 Example 类中创建字段，那么 lambda 表达式将无法访问这些字段。

但是，您没有理由不能将 Example 的实例传递给 lambda 表达式，这将使它们能够访问 example 可能持有的任何公共状态。 AFAIK 在功能上等同于 Java 匿名内部类。

PS 如果您打算对某个答案投反对票，请帮我们大家一个忙，并添加评论说明您不同意的原因:-)

Answer 3

通常，使用 Java 中的匿名内部类解决的问题可以使用 .Net 中的委托以更简洁的方式解决。 你的例子有点太简单了，无法确定你的意图。 如果您使用抽象类的目的是传递“行为”，请考虑仅使用 Action 委托。

public class StartHere{
   public static void main(string[] args){
      Action doStuff = () => Console.WriteLine("Did stuff");
      executeSomething(doStuff);
   }

   public static void executeSomething(Action action)
   {
      action();
   }
}

Answer 4

这在 C# 中是做不到的； 您需要声明一个新的类类型。 在 C# 中最接近的可能是命名的嵌套类：

public class StartHere{
    private class Foo : Example {
        public override void  doStuff()
        {
            Console.WriteLine("did stuff");
        }
    }
   public static void Main(string[] args){
      Example x = new Foo();
      x.doStuff();
   }
}

Answer 5

C# 不支持这一点，如果由我决定，也不应该如此。

java 中内部类的激增主要是由于缺乏 C# 所具有的委托或 lambda。 因此，虽然这种类型的功能目前是 Java 中“您唯一的希望”，但您通常可以使用 C# 中的其他机制来实现相同的目的。 Java 在这方面感觉就像用一只手弹钢琴。

（诚​​然，我们中的很多人已经非常擅长这种单手游戏；现在看来我们至少要等到 java 8 才能关闭......）

Answer 6

由于您的类仅代表一个操作，因此您可以在您的情况下使用委托，有一个现有的委托：

public delegate void Action();

这与您的类完全相同。

匿名类的声明更加清晰：

Action action = () => Console.WriteLine("Hello world");
action(); // invoke

您甚至可以使用闭包：

public void Hello(string name)
{
  Action action = () => Console.WriteLine("Hello " + name);
  action(); // will call the above lambda !
}

Answer 7

虽然所有好的答案都建议依赖 C# 3.0，

所以，为了完整起见，我将添加另一种既不使用 lambda 也不使用 Func 类型的解决方案（当然，正如 Matt Olenik 在评论中提到的那样，人们可以推广以下代表以相同的方式工作。）。 对于那些像我一样仍在使用 C# 2.0 的人。 也许不是最好的解决方案，但它确实有效。

public class Example
{
    public delegate void DoStuffDelecate();
    public DoStuffDelecate DoStuff;
    public delegate void DoStuffWithDelecate(int n);
    public DoStuffWithDelecate DoStuffWithParameter;
    public delegate int DoStuffWithReturnDelecate();
    public DoStuffWithReturnDelecate DoStuffWithReturnValue;
}

class Program
{
    static int MethodWithReturnValue()
    {
        return 99;
    }
    static void MethodForDelecate()
    {
        Console.WriteLine("Did Stuff");
    }
    static void MethodForDelecate(int n)
    {
        Console.WriteLine("Did Stuff with parameter " + n);
    }


    static void Main(string[] args)
    {
        var x = new Example();
        x.DoStuff = MethodForDelecate;
        x.DoStuffWithParameter = MethodForDelecate;
        x.DoStuffWithReturnValue = MethodWithReturnValue;

        x.DoStuff();
        x.DoStuffWithParameter(10);
        int value = x.DoStuffWithReturnValue();
        Console.WriteLine("Return value " + value);
        Console.ReadLine();
    }
}

Answer 8

您可以通过 .NET 中的 Mocking 来完成此任务。 然而，这个功能没有语言支持，我认为它会在 C# 4.0 中提供。 有许多用于模拟的库，包括：

• Moq
• RhinoMock

Answer 9

简而言之，不，您必须将其定义为单独的子类。 我认为这个功能将在 C# 4.0 中出现？

编辑： 不，C# 4.0 不会出现，这是我编造的。