Wie deklariert man eine generische Einschränkung, die ein generischer Typ ist?

Question

Ich habe zwei generische abstrakte Typen: Entity y Association .

Sagen wir Entity sieht so aus:

public class Entity<TId>
{ 
//...
}

et Association sieht so aus:

public class Association<TEntity, TEntity2>
{
//...
}

Wie kann ich Assoziationen so einschränken, dass sie von jeder Entität sein können?

Ich kann dies wie folgt erreichen:

public class Association<TEntity, TId, TEntity2, TId2>
     where TEntity : Entity<TId>
     where TEntity2: Entity<TId2>
{
//...
}

Dies wird sehr mühsam, je mehr Typen sich von Association weil ich immer wieder TId und TId2 weitergeben muss. Gibt es einen einfacheren Weg, dies zu tun, außer einfach die Einschränkung zu entfernen?

Answer 1

Dieses Problem wird in der Regel dadurch gelöst, dass Sie Ihre generische Klasse ( Entity<TId> in diesem Fall) erben von einem gemeinsamen Nicht-Generika Klasse.

public abstract class EntityBase
{

}

public class Entity<TId> : EntityBase
{

}

Dies ermöglicht es Ihnen zu tun:

public class Association<TEntity, TEntity2>
    where TEntity : EntityBase
    where TEntity2 : EntityBase
{

}

Editar

Wenn es ein Problem ist, dass sie von einer gemeinsamen Klasse erben, dann könnte dies auch leicht mit einer Schnittstelle geschehen.

Answer 2

Si el Id Typen sind wichtig innerhalb der Association Definition können Sie einen umschließenden "Kontext" erstellen:

public static partial class EntityIds<TId1, TId2> {

    public class Association<TEntity1, TEntity2>
      where TEntity1 : Entity<TId1>
      where TEntity2 : Entity<TId2>
    {
      // ...
    }

}

Auf diese Weise kann die Association Klassendeklaration noch verständlich ist und die notwendigen Typargumente für ihre Typparameter beibehält.

Eine Werksmethode könnte Ihnen im Normalfall helfen:

public static class AssociationFactory {
  public static EntityIds<TId1, TId2>.Association<Entity<TId1>, Entity<TId2>> Create<TId1, TId2>(/*params...*/) {
    return new EntityIds<TId1, TId2>.Association<Entity<TId1>, Entity<TId2>>(/*params...*/);
  }
}

Wenn das zu viel ist und Sie keine Entitätsspezialisierungen haben, können Sie die Assoziation anders modellieren:

public class Association<TId1, TId2>
{
  // ... 
  Entity<TId1> Entity1 { get; set; }
  Entity<TId2> Entity2 { get; set; }
  // ...
}