C# .NET visual-studio-2008 abstract-class

我可以强制子类重写方法而不使其抽象吗？

发布于 2024-07-08 03:13:23 字数 182 浏览 6 评论 0原文

我有一个带有一些抽象方法的类，但我希望能够在设计器中编辑该类的子类。然而，设计者不能编辑子类，除非它可以创建父类的实例。所以我的计划是用存根替换抽象方法并将它们标记为虚拟 - 但如果我创建另一个子类，如果我忘记实现它们，我不会得到编译时错误。

有没有一种方法可以标记方法，以便它们必须由子类实现，而不将它们标记为抽象？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

围归者 2024-07-15 03:13:23

好吧，你可以做一些涉及 #if 的非常混乱的代码 - 即在 DEBUG 中它是虚拟的（对于设计者来说），但在 RELEASE 中它是抽象的。不过，维护起来确实很痛苦。

但除此之外：基本上，没有。如果您想要设计器支持，它就不能是抽象的，因此您只能使用“虚拟”（大概是抛出 NotImplementedException 的基本方法）。

当然，您的单元测试将检查这些方法是否已实现，是吗？ ;-p

实际上，通过泛型进行测试可能非常容易 - 即具有以下形式的通用测试方法：

[Test]
public void TestFoo() {
  ActualTest<Foo>();
}
[Test]
public void TestBar() {
  ActualTest<Bar>();
}

static void ActualTest<T>() where T : SomeBaseClass, new() {
  T obj = new T();
  Assert.blah something involving obj
}

Well you could do some really messy code involving #if - i.e. in DEBUG it is virtual (for the designer), but in RELEASE it is abstract. A real pain to maintain, though.

But other than that: basically, no. If you want designer support it can't be abstract, so you are left with "virtual" (presumably with the base method throwing a NotImplementedException).

Of course, your unit tests will check that the methods have been implemented, yes? ;-p

Actually, it would probably be quite easy to test via generics - i.e. have a generic test method of the form:

[Test]
public void TestFoo() {
  ActualTest<Foo>();
}
[Test]
public void TestBar() {
  ActualTest<Bar>();
}

static void ActualTest<T>() where T : SomeBaseClass, new() {
  T obj = new T();
  Assert.blah something involving obj
}

回复收藏 0 原文

坐在坟头思考人生 2024-07-15 03:13:23

您可以在类中使用对实现习惯用法的引用。

public class DesignerHappy
{
    private ADesignerHappyImp imp_;

    public int MyMethod()
    {
        return imp_.MyMethod()    
    }

    public int MyProperty
    {
        get { return imp_.MyProperty; }
        set { imp_.MyProperty = value; }
    }
}

public abstract class ADesignerHappyImp
{
    public abstract int MyMethod();
    public int MyProperty {get; set;}
}

DesignerHappy 只是公开您想要的接口，但将所有调用转发到实现对象。您可以通过子类化 ADesignerHappyImp 来扩展行为，这会强制您实现所有抽象成员。

您可以提供 ADesignerHappyImp 的默认实现，它用于默认初始化 DesignerHappy 并公开允许您更改实现的属性。

You could use the reference to implementation idiom in your class.

public class DesignerHappy
{
    private ADesignerHappyImp imp_;

    public int MyMethod()
    {
        return imp_.MyMethod()    
    }

    public int MyProperty
    {
        get { return imp_.MyProperty; }
        set { imp_.MyProperty = value; }
    }
}

public abstract class ADesignerHappyImp
{
    public abstract int MyMethod();
    public int MyProperty {get; set;}
}

DesignerHappy just exposes the interface you want but forwards all the calls to the implementation object. You extend the behavior by sub-classing ADesignerHappyImp, which forces you to implement all the abstract members.

You can provide a default implementation of ADesignerHappyImp, which is used to initialize DesignerHappy by default and expose a property that allows you to change the implementation.

回复收藏 0 原文