C# Generics/Dynamics Inheritance

Question

Let's say I have these classes:

public class BaseMapClass<T1, T2>
{
   protected T1 Thing1;
   protected T2 Thing2;
}

public class InstanceMapClass1 : BaseMapClass<Type1, Type2>
{
      public InstanceMapClass(Type1 x, Type2 y)
      {
         Thing1 = x;
         Thing2 = y
      }
}

public class InstanceMapClass2 : BaseMapClass<Type3, Type4>
{
      public InstanceMapClass(Type3 x, Type4 y)
      {
         Thing1 = x;
         Thing2 = y
      }
}

Now I have a third class, I'd ideally want to have two generic IEnumerables that take their type based on the generics of the type passed in BaseMapClass

public class Three<T> where T : BaseMapClass<dynamic, dynamic>
{
   IEnumerable<??> TypeXThings; // should be of the first dynamic type
   IEnumerable<??> TypeYThings; // should be of the second dynamic type
}

so if I created a new class

Three<InstanceMapClass1> three = new Three<InstanceMapClass1>();
Type1 t1 = three.TypeXThings.FirstOrDefault();

or

Three<InstanceMapClass2> another = new Three<InstanceMapClass2>();
Type3 t3 = another.TypeXThings.FirstOrDefault();

Using dynamics and generics is it possible to set the type of these IEnumerables to the generic types of the BaseMapClass at runtime? What I really want is to be able to pass in this one mapping class and then be able to create collections based on their generic parameters. I feel like I'm going about this the wrong way, but the only other way I can think of doing it is

public class Three<T1, T2, T3>
{
   IEnumerable<T2> Type1Things;
   IEnumerable<T3> Type2Things:
}

Thanks! Also, I realize this may make no sense so please let me know where clarification is needed.

dynamic and generics cannot be interchanged. BaseMap<T,V> for example is an open generic type. With open is meant that you cannot create an instance of it since the type placeholders have no value yet. When a generic type gets its generic type arguments e.g. string,string then you have created a closed generic type which can be instantiated. You can fill in the generic type arguments at run time and instantiate the type but a generic type instance is bound to the generic type arguments — Alois Kraus
– Alois Kraus, Commented Nov 3, 2011 at 20:13

Merlyn Morgan-Graham · Accepted Answer · 2011-11-03 20:23:15Z

3

From your question:

public class Three<T> where T : BaseMapClass<dynamic, dynamic>

dynamic isn't used this way, and has nothing to do with generics. It is basically an object that supports any method/property/field, and uses runtime compilation to pull up each method/property/field access.

BaseMapClass<int, string> myVar = new BaseMapClass<int, string>();

object myVarAsObject = myVar;
Console.WriteLine(myVarAsObject.Thing1); // Won't compile

dynamic myVarAsDynamic = myVar;
Console.WriteLine(myVarAsDynamic.Thing1); // Will compile to a runnable program

This isn't a magic bullet, and will still throw an exception at runtime - RuntimeBinderException - because Thing1/Thing2 are protected.

This is the blessing and the curse of dynamic's use of runtime compilation :)

Solution (to get your code to compile)

Your third example makes the most sense. Here it is combined with your existing code:

public class Three<T1, T2, T3> where T1 : BaseMapClass<T2, T3>
{
   IEnumerable<T2> Type1Things;
   IEnumerable<T3> Type2Things:
}

Though you'll still inherit:

protected T2 Thing1; // Note: T1 of base type becomes T2 of the outer type
protected T3 Thing2; // Note: T2 of base type becomes T3 of the outer type

If this isn't desirable, don't inherit from BaseMapClass, or change how it is defined.

Suggestions on your final design

If this isn't helping you solve your original problem, you might want to post your code on the Code Review site and see if you can get some feedback on your design.

My initial thoughts are that you should investigate if it would make sense to use interfaces in your design, rather than inheriting from concrete types.

Also see if there are existing types in the .Net framework that suit your purposes instead of inventing new ones (e.g. Tuple<T1, T2> or maybe Dictionary<T1, T2>).

edited Nov 3, 2011 at 20:23

answered Nov 3, 2011 at 20:02

Merlyn Morgan-Graham

59.4k16 gold badges132 silver badges189 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

asawyer Over a year ago

and uses reflections to pull up each method/property/field access I don't think this is accurate. I'm pretty sure its more like It loads a mini version of the compiler at runtime to resolve the types

Daniel Ahrnsbrak Over a year ago

Thanks, I think tuples is a reasonable suggestion. The main reason I want to do this is so that the user can use a more accessible type to pass into the Three class, but then the internal logic of the Three class will be able to know about the more restricted types that I'd rather the user of the library not mess around with.

Collectives™ on Stack Overflow

C# Generics/Dynamics Inheritance

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related