Question

我知道你可以在java中做到这一点...我想知道如何使用c＃制作相同的方法或者使用不同的解决方案获得相同的结果

new SomeClass() {
    @Override
    public void someMethod() {
        // Do what you want
    }
};

Answer 1

如果你是定义类的人，你可以使用lambda表达式/委托来实现你想要实现的目标：

public class SomeClass
{
    public Action someMethod { get; set; }
}
public class Program
{
    static void Main()
    {
        var someClassInstance =
        new SomeClass()
        {
            someMethod =
            ()=>
            {
                // do what you want.
            }
        };

        someClassInstance.someMethod();
    }
}

或者，如果您只想允许设置lambda一次，请使用如下构造函数参数：

public class SomeClass
{
    public readonly Action someMethod;

    public SomeClass(Action someMethod) { this.someMethod = someMethod; }
}
public class Program
{
    static void Main()
    {
        var someClassInstance =
        new SomeClass
        (
            someMethod:
            ()=>
            {
                // do what you want.
            }
        );

        someClassInstance.someMethod();
    }
}

最后，如果您真的试图覆盖行为，请通过在任一版本的默认构造函数中设置它来为lambda提供默认实现：

public SomeClass()
{
    this.someMethod = this.defaultSomeMethod;
}
private void defaultSomeMethod()
{
}

更新：

如果要访问要添加方法的类实例的公共成员，请将以下构造函数重载添加到构造函数方法中：

    public SomeClass(Action<SomeClass> someMethod) { this.someMethod = ()=>someMethod(this); }

然后像这样使用它：

public class SomeClass
{
    public readonly Action someMethod;

    public SomeClass(Action<SomeClass> someMethod) { this.someMethod = ()=>someMethod(this); }
    public SomeClass(Action someMethod) { this.someMethod = someMethod; }
    public SomeClass()
    {
        this.someMethod = this.defaultSomeMethod;
    }
    private void defaultSomeMethod()
    {
    }
    public void SomeOtherMethod() {}
}
public class Program
{
    static void YMain()
    {
        var someClassInstance =
        new SomeClass
        (
            someMethod :
            @this=>
            {
                @this.SomeOtherMethod();
                // do other stuff
            }
        );

        someClassInstance.someMethod();
    }
}

Answer 2

Java和C＃关于类方法的主要区别在于，在Java中，默认情况下所有方法都是虚拟的，而在C＃中，默认情况下都是密封的。

这是一个设计选择（在C＃中），这是因为当你是一个班级的设计者时，你知道你的公共API的哪一部分你希望你的班级的消费者能够改变你的哪一部分。不希望他们这样做。

事实上在Java中，所有方法都是虚拟的，或多或少是一个设计缺陷，因为它打破了隔离原则。

不回到你的问题，@ tyree-jackson（即使用代表）的回答有用。但实际上你可以完全摆脱这个类，因为委托（这里是Action的一个实例）已经是一个引用类型，可以在方法调用中传递。

Answer 3

我可能在这里稍微提出了问题，但是......

建议你有一些基类：

public abstract class BaseClass()
{
    public abstract Method0();

    public virtual Method1()
    {
    }

    public Method2()
    {
    }
}

如果您有一个继承基类的类，可以通过以下方式覆盖方法：

public class SomeClass : BaseClass
{
    public override Method0()
    {
    }

    public override Method1()
    {
    }

    public new Method2()
    {
    }
}

如果你有SomeClass的实例，你可以调用所有的override（和new）方法。但是，如果您有BaseClass实例，则可以调用overriden而不是new方法。所以：

SomeClass test = new SomeClass();
test.Method0();// Calls overriden Method0
test.Method1();// Calls overriden Method1
test.Method2();// Calls new Method2

BaseClass test2 = new SomeClass();
test2.Method0();// Calls overriden Method0
test2.Method1();// Calls overriden Method1
test2.Method2();// Calls BaseClass's Method2

希望这会有所帮助

在创建类的新实例时重写

3 个答案: