CODEWITHSUNDEEP
c#templatesgenerics
Sanctus2099
Sanctus2099

Reputation: 1723

Generic handling in c#

So, I have a little bit of an issue that I can't exactly wrap my head around.

So, I have a base class called Property, and I have a lot of classes that derive from that one, like IntProperty, ColorProperty and so on. Now, I also have a few of them that are of the enum type and currently they are all separate classes. I'd like to make it a generic class but here's the issue with this:

In a different part of the code I need to handle all of them. Keep in mind I can't use virtual functions for this (I'm doing something with the UnityEditor).

Currently, I have a function that takes a Property as a parameter and then I do this for all types that derive from Property:

if(property is IntProperty)
{
       IntProperty intProperty = property as IntProperty;
       intProperty.theValue = specific_int_function();
}

That specific_int_function is the same for all enum values privided I have the T from a generic.

Ideally I'd like to do something like this (pseud-ish code):

(using T)
{
   if(property is EnumProperty<T>)
   {
      EnumProperty<T> enumProperty = property as EnumProperty<T>;
      enumProperty.value = (T)my_enum_value_function(typeof(T));
   }
}

Any idea about how I could make all this code nicer?

Hopefully I provided all the relevant information.

Edit:

It's not so much that I can't use virtual functions in those classes but I can't call any of the specific functions in that particular file. I have 2 compilation groups and only one can access those functions (EditorGUI functions for people who know what I'm talking about)

Regards, Lorin

Upvotes: 1

Views: 83

Answers (2)

user743382
user743382

Reputation:

Keep in mind I can't use virtual functions for this (I'm doing something with the UnityEditor).

That's really what you should be doing. If you can't, then fine, but I'm leaving this note here for the benefit of other people will be reading this question and answer too.

In my experience, the least difficult way of achieving this is with a helper class, because it lets you avoid some of the reflection complexity that you would have to deal with if you used a generic helper method.

abstract class EnumPropertyHelper {
  public abstract void DoSomething(Property property);
}
class EnumPropertyHelper<T> : EnumPropertyHelper {
  public override void DoSomething(Property property) {
    EnumProperty<T> enumProperty = property as EnumProperty<T>;
    enumProperty.value = (T)my_enum_value_function(typeof(T));
  }
}

Then,

if (property.GetType().IsGenericType
    && property.GetType().GetGenericTypeDefinition() == typeof(EnumProperty<>)) {
  var helperType = typeof(EnumPropertyHelper<>).MakeGenericType(property.GetType().GetGenericTypeArguments());
  var helper = (EnumPropertyHelper)Activator.CreateInstance(helper);
  helper.DoSomething(property);
}

But you do need to jump through hoops similar to this one whatever you end up doing, because C# and .NET don't allow you to have generic code in non-generic methods.

Upvotes: 1

Blue Granny
Blue Granny

Reputation: 800

You could use add a function pointer to the class, and each constructor could implement it's own function?

Add a property Func<void> functionPTR = null

In each class you'd have a function such as

void specific_int_function() {
  //Do Something
}

In the class constructor

functionPTR = specific_int_function;

And then in the generic class

void GenericHandler() {
  functionPTR();
}

I'm not sure about the syntax, but this should give you the performance you're going for.

Read up on function pointers to see how to define the return value and function parameters.

Upvotes: 0

Related Questions