Non ho capito bene quello che chiedi ma mi pare tu abbia le idee un po' confuse per quanto riguarda interfacce, classi astratte e classi.
Cerco di chiarire qualche concetto base di OOP con un semplice esempio; supponiamo di avere la seguente interfaccia con 3 metodi:
public interface IMyInterface
{
string Method1();
string Method2();
string Method3();
}
Ora supponiamo di avere la necessità di creare 2 classi che abbiano lo stesso comportamente (identica implementazione) del metodo 1, un comportamento predefinito (ma overridable) del metodo 2 e un'implementazione specifica del metodo 3 (l'esempio mi pare copra tutte le casistiche possibili, giusto?)
A questo punto l'ideale è creare una classe base astratta che:
- implementi in modo definitivo Method1
- implementi Method2 ma lo renda sovrascrivibile
- non implementi Method3 (abstract), lasciando l'implementazione alle classi concrete
La classe astratta sarà:
public abstract class MyBaseClass : IMyInterface
{
public string Method1()
{
return "M1 from BaseClass";
// (le classi per fare l'override dovranno usare "new")
}
public virtual string Method2()
{
return "M2 from BaseClass";
// (è "virtual", per cui le classi potranno farne l'override)
}
public abstract string Method3();
// (è "abstract ", per cui le classi dovranno farne l'override)
}
Ora le classi, derivando da MyBaseClass implementeranno di conseguenza anche l'interfaccia IMyInterface:
public class MyClass1 : MyBaseClass
{
public override string Method3()
{
return "M3 from Class1";
}
}
public class MyClass2 : MyBaseClass
{
public override string Method2()
{
return "M2 from Class2";
}
public override string Method3()
{
return "M3 from Class2";
}
}
Supponiamo di volere in una terza classe reimplementare anche Method1:
public class MyClass3 : MyBaseClass
{
public new string Method1()
{
return "M1 from Class3";
}
public override string Method2()
{
return "M2 from Class3";
}
public override string Method3()
{
return "M3 from Class3";
}
}
Detto questo possiamo avere:
MyClass1 c1 = new MyClass1();
Console.WriteLine(c1.Method1());
Console.WriteLine(c1.Method2());
Console.WriteLine(c1.Method3());
Che produrrà:
M1 from BaseClass
M2 from BaseClass
M3 from Class1
Oppure:
MyClass2 c2 = new MyClass2();
Console.WriteLine(c2.Method1());
Console.WriteLine(c2.Method2());
Console.WriteLine(c2.Method3());
Che produrrà:
M1 from BaseClass
M2 from Class2
M3 from Class2
E ancora:
MyClass3 c3 = new MyClass3();
Console.WriteLine(c3.Method1());
Console.WriteLine(c3.Method2());
Console.WriteLine(c3.Method3());
Che produrrà:
M1 from Class3
M2 from Class3
M3 from Class3
Si noti però che:
IMyInterface c = new MyClass3();
Console.WriteLine(c.Method1());
Console.WriteLine(c.Method2());
Console.WriteLine(c.Method3());
Produrrà:
M1 from BaseClass
M2 from Class3
M3 from Class3
HTH
