interface & inheritance

C#, VS 2008 I have 4 cases say a,b,c,d, I plan to seperate them and create seperate classes the 4 cases have something in common, I put them in an interface and create a base class that implement the interface. now th开发者_高级运维ere are something in common between a&b, a&c, c&d, not sure how to make a good/clean implement

thanks

There are several options.

You could have c and d inherit from a, and d inherit from c. You could create a base class for each pair a/b, a/c, and c/d. You could duplicate functionality. You could provide the functionality via a helper class (static methods might be an option).

It really depends on what functionality is being shared, and the intended usage of the classes.

It depends on how the common things works and how they relate to and use private/protected data, but often composition can be a complement or alternative to inheritance.

Break out the common parts to helper classes that you use from the different implementations of a,b,c and d.

This is only possible if the implementation is not tightly coupled to the private data of each class.

As a general rule, you should only use inheritance if your objects are different kinds of the same object. If this is the case, then you can use inheritance to share implementation that's inherent in the definition of the base object.

If classes a,b,c and d aren't really different kinds of the same object then you can try encapsulating their common functionality in an internally referenced object.

public class a
{
    private CommonFunctionalityClass commonFunc;

    public a()
    {
        this.commonFunc = new CommonFunctionalityClass();
    }
} 

When you want to do the common stuff, you just call your instance of commonFunc. You can do this same encapsulation for a/b, b/c, and c/d where you share functionality via a has a relationship using an internally referenced object. That way you don't duplicate code, but you can share functionality flexibly.

public interface IABInterface
{
    //Whatever is common to A and B. It will have to be implemented in the classes
}

public interface IACInterface
{
    //Whatever is common to A and C. It will have to be implemented in the classes
}

public interface ICDInterface
{
    //Whatever is common to C and D. It will have to be implemented in the classes
}

public class ABCDBase
{
    //Whatever is common to all classes
}

public class A : ABCDBase, IABInterface, IACInterface
{
}

public class B : ABCDBase, IABInterface
{
}

public class C : ABCDBase, IACInterface, ICDInterface
{
}

public class D : ABCDBase, ICDInterface
{
}

You can create later in a static class extension methods for your interfaces to not duplicate the code for your methods in the Interfaces implementations (In other words, don't define methods in your interfaces, only properties). With refactoring can be really easy to implement the properties in your interfaces. It would be nice to have extension properties. Hopefuly in the future.

EDIT

Like this:

public static class Helper
{
    public static void IABMethod1(this IABInterface aOrBObject, arguments args)
    {
        //This will be available for any A or B object without duplicating any code
    }
}