3

We are having issues with a pattern, that is emerging in our C# solution.

Initial idea: We have a set of features (mostly calculations), that are needed in several projects. We imagined our solution to be modular - each feature implemented as a class library which can than be referenced as a .dll in other projects.

First Issue: What happened was, that libraries had classes, that specified the input data needed for doing the math. As a single library could be used in a number of projects we ended up coding mappings for each project, that ported the projects domain objects to the input data classes. This was tedious, as we were mostly doing a one-to-one conversion - the classes were basically the same.

Idea: We figured that we would solve our problem with using interfaces instead of classes to specify our input data. That way we could simply label our domain classes with interfaces and we wouldn't have to do the mappings anymore.

Current Issue: We now have a complete mayhem with interface definitions and the use of these interfaces in calculation methods. E.g.

public interface ILevel2Child
{
}

public interface ILevel1Child<TLevel2Child> 
    where TLevel2Child : ILevel2Child
{
    List<TLevel2Child> Children { get; }
}

public interface IParent<TLevel1Child, TLevel2Child>
    where TLevel1Child: ILevel1Child<ILevel2Child>
    where TLevel2Child: ILevel2Child
{
    List<TLevel1Child> Children { get; }
}

When we end up using the IParent interface in a method or interface, we keep dragging these insanely long signatures along.

Questions:

  1. Was our idea of using interfaces bad to begin with?
  2. If not, is something wrong with the way we specify our interfaces?
  3. If still not, is there any way we can stop this insane signature pattern?

Additional explanation: We started with 

public interface ILevel2Child
{
}

public interface ILevel1Child
{
    List<ILevel2Child> Children { get; }
}

public interface IParent
{
    List<ILevel1Child> Children { get; }
}

but that prevented us from doing 

public class Level2Child : ILevel2Child
{
}

public class Level1Child : ILevel1Child
{
    List<Level2Child> Children { get; }
}

public class Parent : IParent
{
    List<Level1Child> Children { get; }
}

and that was not acceptable.

Erik Philips
  • 53,428
  • 11
  • 128
  • 150
ogi
  • 41
  • 5
  • 2
    Why are you changing `List` property type to `List`? In any case if you must there is no problem to do it [explicitly](http://stackoverflow.com/q/4103300/1997232), then you can access/have both. – Sinatr Feb 01 '17 at 16:17
  • 1
    We need concrete classes because they implement multiple interfaces. So you are suggesting we duplicate those properties like so: `public class Parent : IParent { List Children {get;} List IParent.Children{get{return Children;}} }` ? – ogi Feb 02 '17 at 06:41

0 Answers0