ObjectionStore.cs :  » Build-Systems » CruiseControl.NET » Objection » C# / CSharp Open Source

using System;
using System.Collections;
using System.Reflection;

namespace Objection{
  public class ObjectionStore : ObjectSource, ObjectionManager
  {
    private ImplementationResolver implementationResolver;
    private ConstructorSelectionStrategy constructorSelectionStrategy;
    private Hashtable typedInstances;
    private Hashtable implementationTypes;
    private Hashtable dependencyImplementations;
    private Hashtable namedTypes;
    private Hashtable dependencyImplementationsForNames;
    private Hashtable namedInstances;

    public ObjectionStore() : this (
      new NMockAwareImplementationResolver(),
      new MaxLengthConstructorSelectionStrategy()) 
    { }

    public ObjectionStore(ImplementationResolver implementationResolver, ConstructorSelectionStrategy constructorSelectionStrategy)
    {
      this.implementationResolver = implementationResolver;
      this.constructorSelectionStrategy = constructorSelectionStrategy;
      typedInstances = new Hashtable();
      implementationTypes = new Hashtable();
      dependencyImplementations = new Hashtable();
      namedTypes = new Hashtable();
      dependencyImplementationsForNames = new Hashtable();
      namedInstances = new Hashtable();
      AddInstanceForType(typeof(ObjectSource), this);
      AddInstanceForType(typeof(ObjectionManager), this);
      AddInstanceForType(typeof(ObjectionStore), this);
    }

    public void AddInstanceForType(Type type, object instance)
    {
      typedInstances[type] = instance;
    }

    public void AddInstance(params object[] objects)
    {
      foreach (object o in objects)
      {
        AddInstanceForType(o.GetType(), o);
      }
    }

    public void SetImplementationType(Type parentType, Type implementationType)
    {
      implementationTypes[parentType] = implementationType;
    }

    public DecoratableByType AddTypeForName(string name, Type type)
    {
      namedTypes[name] = new ObjectionType(type);
      return (DecoratableByType) namedTypes[name];
    }

    public DecoratableByType AddInstanceForName(string name, object instance)
    {
      namedInstances[name] = new ObjectionObject(instance);
      return (DecoratableByType) namedInstances[name];
    }

    public void SetDependencyImplementationForName(string name, Type dependencyType, Type implementationType)
    {
      if (dependencyImplementationsForNames[name] == null)
        dependencyImplementationsForNames[name] = new Hashtable();

      ((Hashtable) dependencyImplementationsForNames[name])[dependencyType] = implementationType;
    }

    public void SetDependencyImplementationForType(Type typeWithDependency, Type dependencyParentType, Type dependencyImplementationType)
    {
      if (dependencyImplementations[typeWithDependency] == null)
        dependencyImplementations[typeWithDependency] = new Hashtable();

      ((Hashtable) dependencyImplementations[typeWithDependency])[dependencyParentType] = dependencyImplementationType;
    }

    public object GetByType(Type type)
    {
      return GiveObjectByType(type, null);
    }

    public object GetByName(string name)
    {
      ObjectionObject namedInstance = namedInstances[name] as ObjectionObject;
      if (namedInstance == null)
      {
        ObjectionType namedType = (ObjectionType) namedTypes[name];
      
        if (namedType == null)
          throw new ApplicationException("Unknown object name : " + name);
        else
          return Instantiate(namedType, name);
      }
      else
      {
        if (namedInstance.Decorator != null)
        {
          return Instantiate(namedInstance.Decorator, name, namedInstance.Instance);
        }
        else
        {
          return namedInstance.Instance;
        }
      }
    }

    private object GiveObjectByType(Type type, string name)
    {
      object result = typedInstances[type];
      if (result == null)
      {
        result = Instantiate(type, name);
      }
      return result;
    }

    private object Instantiate(ObjectionType ObjectionType, string id, params object[] args)
    {
      object baseObject = Instantiate(ObjectionType.Type, id, args);

      ObjectionType decorator = ObjectionType.Decorator;
      if (decorator != null)
        return Instantiate(decorator, id, baseObject);
      else
        return baseObject;
    }

    private object Instantiate(Type type, string identifier, params object[] args)
    {
      if (implementationTypes[type] != null)
      {
        return Instantiate((Type) implementationTypes[type], identifier, args);
      }
      if (type.IsInterface)
      {
        implementationTypes[type] = implementationResolver.ResolveImplementation(type);
        return Instantiate((Type) implementationTypes[type], identifier, args);
      }

      ArrayList arguments = new ArrayList();
      ConstructorInfo constructor = constructorSelectionStrategy.GetConstructor(type);

      if (constructor == null)
      {
        throw new Exception("Unable to select constructor for Type " + type.FullName);
      }

      int paramCount = 0;
      foreach (ParameterInfo parameter in constructor.GetParameters())
      {
        if (paramCount < args.Length)
        {
          arguments.Add(args[paramCount]);
        }
        else
        {
          try
          {
            Type dependencyType = OverrideWithSpecifiedDependencyImplementationIfNecessary(type, parameter.ParameterType, identifier);
            arguments.Add(GiveObjectByType(dependencyType, identifier));
          }
          catch (Exception e)
          {
            throw new Exception("Failed to instantiate Type " + type.FullName, e);
          }
        }
        paramCount++;
      }

      try
      {
        return constructor.Invoke((object[]) arguments.ToArray(typeof (object)));  
      }
      catch (Exception e)
      {
        string message = "Unable to instante " + type.FullName + " using the following args: ";
        foreach (object arg in arguments)
        {
          message += arg.ToString();
          message += ", ";
        }
        throw new Exception(message, e);
      }      
    }

    private Type OverrideWithSpecifiedDependencyImplementationIfNecessary(Type typeBeingInstantiated, Type staticDependencyType, string identifier)
    {
      Hashtable dependencyTypes;
      if (identifier != null)
      {
        dependencyTypes = (Hashtable) dependencyImplementationsForNames[identifier];
        if (dependencyTypes != null && dependencyTypes[staticDependencyType] != null)
        {
          return (Type) dependencyTypes[staticDependencyType];
        }      
      }
      dependencyTypes = (Hashtable) dependencyImplementations[typeBeingInstantiated];
      if (dependencyTypes != null && dependencyTypes[staticDependencyType] != null)
      {
        return (Type) dependencyTypes[staticDependencyType];
      }
      return staticDependencyType;
    }
  }
}