How do I declare a list of types, and later instantiate one?

Question

I have a case where I have some classes that each process a type of token. They all descend from a base handler class (simplified down a bit, so excuse any anti-compile typos):

public abstract class TokenClassBase { public static bool HandlesTokenType(TokenKind AType) { return handledTokens.Contains(AType); } protected virtual void HandleToken(AToken) { } } public class TokenClass1 : TokenClassBase { public static new bool HandlesTokenType(TokenKind AKind) { return AKind == TokenKind.type1; } public override void HandleToken(AToken) { //do some work } } // public class TokenClass2... etc

I also have a worker class where I'd like to store a list of these handlers, and later instantiate one of the handlers to process a token:

public class MyWorker { private List<Type> handlers; public MyWorker() { handlers = new List<Type>; handlers.Add(typeof(TokenClass1)); handlers.Add(typeof(TokenClass2)); //... etc } protected virtual void HandleToken(AToken) { foreach (TokenBaseClass handler in handlers) { if (handler.HandlesToken(AToken)) { instantiate(handler); handler.HandleToken(AToken); break; } } } }

My question is, how do I handle the last foreach? Is this even possible - or is there a better way? I like the extensibility of being able to add new types in the future, just by adding them to the handlers list (or even passing them in from outside). I'm using c#, framework 3.5+.

Jon Skeet · Accepted Answer · 2011-04-24 19:51:58Z

It's not possible like this, no - because your list is a list of types, not references to instances of that type.

The closest you can easily come, assuming that there's a parameterless constructor for each type, is:

foreach (Type handlerType in handlers) { // Create an instance of the handler type TokenBaseClass handler = (TokenBaseClass) Activator.CreateInstance(handlerType); if (handler.HandlesToken(AToken)) { handler.HandleToken(AToken); break; } }

EDIT: In answer to your question in the comments, I would handle this slightly differently.

I would change your List<Type> to a List<Func<TokenKind, TokenClassBase>>. In other words, a list of factory functions, from TokenKind to TokenClassBase. The function for each type would depend on the type, but it would either return an instance of TokenClassBase, or null if that TokenKind couldn't be handled.

Then you'd use:

foreach (var handlerFactory in handlerFactories) { TokenBaseClass handler = handlerFactory(AToken); if (handler != null) { handler.HandleToken(AToken); break; } }

The way that you'd create the delegates would depend on the exact nature of your code, but you could either use a lambda expression or a method group conversion, probably from a static method.

You can also have the handlers implement ICloneable (if you want to clone an instance per 'serivce request')
@sehe: Yes, but you'd still need to have a list of instances, rather than a list of types.
Aha, I misread your comment, and assumed that the types were already being stored by their instances. Reading too fast, sry. Still ICloneable rings on-topic here :)
Ah, the Activator.CreateInstance is what I was looking for to replace my 'instantiate(handler)' line. Is there any way to call a static method (HandlesToken) in the class without doing this? Essentially I want to ask, "can this class handle the task", before I instantiate it.
@Jon: Thanks, this provides a good direction. I'm a bit hazy on the last step of filling the handlerFactories list with a reference to a static method; do you mean I'd use handlerFactories.Add(TokenKind.type1, TokenClass1.HandleToken) ?

Random832 · Accepted Answer · 2011-04-24 19:34:30Z

You may want to look at the Activator.CreateInstance method.

Your loop would be

foreach (Type handlerType in handlers) { if (...not sure how you'd do this part...) { TokenBaseClass handler = (TokenBaseClass)Activator.CreateInstance(handlerType); handler.HandleToken(AToken); break; } }

For the missing piece, you'd basically need a list of what tokens each type can handle. If it's a 1-1 relationship, you might consider a Dictionary<TokenKind,Type>. Or, to avoid reflection entirely, use a Dictionary<TokenKind,Func<TokenClassBase>> and each value is () => new TokenClass1().

Why do you want a list of types instead of a list of instances anyway?

Collectives™ on Stack Overflow

How do I declare a list of types, and later instantiate one?

2 Answers 2

7 Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

7 Comments

Comments

Related