How to extract a superclass to encapsulate common code?

Question

I have an application which uses plugins. After creating several of them I've found that a big chunk of code is repeated here and there on them so I want to extract a super "plugin base".

Previous the refactor I had the following structure:

After the refactor I have the next one:

I currently don't find a way to model the fact that the plugin engine has a property settings of type plugin settings and the plugin engine base has a property settings of type plugin settings base . I feel that somehow should be a way to declare that the settings property of the plugin engine base should be a "cast" of the settings property of the plugin engine and to model the fact that they both are the same property.

I'm not sure if the problem is explained enough. Feel free to ask for clarifications.

Thanks.

Answer 1

You can use generics. Create generic base class and specify generic parameter constraint to be of type PluginSettingsBase .

abstract class PluginEngineBase<T>
   where T: PluginSettingsBase
{
   public abstract T Settings { get; set; }
}

Inherit from base class parametrized by PluginsSettings class (thus it is inherited from PluginSettingsBase )

class PluginEngine : PluginEngineBase<PluginsSettings>
{
   public PluginSettings Settings { get; set; }
}

Same with PluginData .

Answer 2

An approach I found:

Base class:

class PluginEngineBase
{
    public PluginSettingsBase Settings { get; set; }
}

Inheritor:

class PluginEngine : PluginEngineBase
{
    public PluginSettings Settings
    {
        get
        {
            return (PluginSettings)base.Settings;
        }
        set
        {
            base.Settings = value;
        }
    }
}