List.OfType（）速度，替代数据结构

Question

Take a look at this code.

interface ILoader
{
}

interface ILoader<T>: ILoader
{
    T Load();
}

class CarLoader: ILoader<Car>
{
    ...
}

class TrainLoader: ILoader<Train>
{
    ...
}

class Container
{
     List<ILoader> loaders = new ILoader[] { new CarLoader(), new TrainLoader()};

     public T Load<T>()
     {
         // Finding right loader
         var loader = loaders.OfType<ILoader<Car>>.FirstOrDefault();
         return loader.Load();
     }
}

I've got about 100 of loaders and I need to load a lot of Trains, Cars, etc. I think that List of loaders is very slow (has OfType() linear complexity??), what do you suggest to use instead of list? Dictionary<Type,ILoader> or Hashtable<Type,ILoader> or HashSet<ILoader> ? How fast would be for example to use hashset.OfType<ILoader<Car>>() , same as list or faster?

Answer 1

Build a Dictionary<Type, ILoader> and populate it with the loaders. Then you can just do:

ILoader<T> loader = (ILoader<T>) loaderDictionary[typeof(T)];

On the other hand, if you've only got 100 items to look through, even a linear scan isn't exactly going to take long. Have you actually benchmarked a real usage situation and found this to be your bottleneck?

Answer 2

The Enumerable.OfType extension method does run in linear time and it is probably fast enough for your purposes. Don't micro-optimizate your code unless you have measured the performance and are sure that you need to optimize it.

Rather than concentrating on the performance you should first consider the suitability of your design. A good design in general does not need to inspect the types of the object - the information you need should be available in other ways. In this case for example you might want to ask if each loader is capable of loading an object by passing that object to a CanLoad method and returning true or false . This will make your design more flexible.

Loader loader = loaders.First(x => x.CanLoad(myObject));

Now you can have loaders that can load multiple types of objects.

If you want a new Loader each time and you want a one-to-one mapping another option is to also ask the object itself to create a suitable loader:

Loader loader = myObject.CreateLoader();

Each class can implement CreateLoader differently so that you get a Loader of the correct type for your object. By taking advantage of polymorphism this works without ever needing to ask an object what type it is.