C＃表继承Abstract类并实现接口。

Question

I need to have a multiple Form classes in my project. So was thinking about putting everything those forms will have in common, together in abstract class. This class will have inheriet Form class and also an interface. Sth like that:

public interface IMyForm
{
void Init();
}

public abstract class AMyForm : Form, IMyForm
{
    void IBrowser.Init()
    {
        throw new NotImplementedException();
    }     
}

public partial class MainClass : AMyForm 
{

// But here the warning is shown (That i have to add override keyword),
// but when i do, The error is shown that i cannot override from non abstract thing 
    public void Init() 
    {
    }
}

Could u tell me how to achieve that ?

Answer 1

While Jon Skeets answer is correct for general programming, I would advise AGAINST using abstract classes on Forms and User controls. First issue is, that designer won't be able to create an instance of the abstract class and thus will not be able to display a form that inherits FROM the abstract form in the designer. Meaning that you will not be able to add new controls to form via designer, unless - as suggested in comments below - you add a surrogate class that implements the abstract class and is then used as a base for other inherited forms, eg: AbstractMyForm -> MyFormSurrogate -> MyForm .

Second and larger issue is in my opinion, that this means that you are trying to stick logic into forms. This is usually not desired, especially if you end up coupling your business logic to your display technology, in this case Winforms . My advice would be to try to use the Model View Presenter pattern to separate as much logic as possible in ordinary classes (using abstract classes, interfaces, etc.) and then data bind them to the form. If there are visual parts that are shared (eg: a group of checkboxes), make user controls for such parts and just reuse them on forms.

I hope I didn't presume too much of your knowledge of working with winforms, but I had similar questions when I started getting into GUI development.

Answer 2

You just want to not use explicit interface implementation in your abstract class:

public abstract class AMyForm : Form, IMyForm
{
    public virtual void Init()
    {
        throw new NotImplementedException();
    }     
}

Or just make it abstract:

public abstract class AMyForm : Form, IMyForm
{
    public abstract void Init();
}

In both cases, you then just override it in your concrete class.

Alternatively, if you really want to use explicit interface implementation in your abstract class, you should use it again in your concrete class:

public partial class MainClass : AMyForm, IMyForm
{
    void IMyForm.Init() 
    {
        // Stuff
    }
}

The downside is that any subclass of AMyForm which doesn't do this will basically have the broken IMyForm implementation. Using the first approach is better here.

EDIT: Or, as per supercat's suggestion:

public abstract class AMyForm : Form, IMyForm
{
    void IBrowser.Init()
    {
        InitImpl();
        // And anything else you need...
    }     

    // Or abstract...
    protected virtual void InitImpl()
    {
    }
}

Then override InitImpl in your concrete class.

Answer 3

With abstract classes not showing in design view; you can get around it by adding a compiler if statement to the abstract class to make it not abstract at design time.

#if RELEASE
    public abstract class AbstractForm : Form, IInterface
#else
    public class AbstractForm : Form, IInterface
#endif
    {
        // Your abstract code here.
    }

It's a nice little hack that works quite effectively. You can use the same trick to switch between virtual and abstract methods between design time and run time.

ADDENDUM:

It should be noted that using abstract forms is unneeded. It is more efficient and creates less potential problems to inherit from a non-abstract Form.

public partial class Screen : Form, IInterface
{
    // Base Class here, complete with .designer.cs and .resx
    public Screen()
    {
        InitialiseComponent();
    }

    #region IInterface imported methods
    public partial void SomeMethod()
    {
        // Do something.
    }
    #endregion
}

And then, if you wanted to create a Logon Screen for example:

public partial class LogonScreen : Screen, IInterface
{
    // Derived Class here, complete with .designer.cs and .resx
    public Screen()
    {
        InitialiseComponent();
    }

    #region IInterface imported methods
    public partial void SomeMethod()
    {
        // Do more somethings!
    }
    #endregion
}