public void InstantiateBindings() { foreach (IList <Binding> bindingList in binder.Values) { foreach (Binding binding in bindingList) { this.Get(binding.Key, binding.Name, false); } } if (exceptions.Count != 0) { IList <string> previousString = new List <string>(); string exceptionString = "Bindings not found for the following:\n"; for (int i = 0; i < exceptions.Count; i++) { BindingNotFoundException bindingNotFoundException = exceptions[i]; if (!previousString.Contains(bindingNotFoundException.Message)) { previousString.Add(bindingNotFoundException.Message); exceptionString += bindingNotFoundException.Message + "\n"; for (int x = i; x < exceptions.Count; x++) { BindingNotFoundException nextException = exceptions[x]; if (bindingNotFoundException.Message.Equals(nextException.Message)) { if (nextException.BaseClass != null) { exceptionString += "\tin class " + nextException.BaseClass + "\n"; } } } } } throw new BindingNotFoundException(exceptionString); } //Initialize commands foreach (KeyValuePair <Type, IList <Type> > pairs in signalsToCommands) { Signal s = (Signal)this.Get(pairs.Key, "", true); foreach (Type commands in pairs.Value) { s.AddCommand(commands); } } }
private object Get(Type keyClazz, string name = "", bool throwExceptions = true) { if (keyClazz.Equals(typeof(IBinder))) { return(this); } try { //Check to see if the instance is cached try { return(GetCachedBinding(keyClazz, name, throwExceptions)); } catch (Exception) { } IList <Binding> bindings; try { bindings = binder[keyClazz]; } catch (KeyNotFoundException ex) { if (!keyClazz.IsInterface) { bindings = new List <Binding>(); Binding bin = new Binding(keyClazz); bin.Value = keyClazz; bindings.Add(bin); binder[keyClazz] = bindings; } else { throw ex; } } foreach (Binding namedBinding in bindings) { if (namedBinding.Name.Equals(name)) { Type type = namedBinding.Value as Type; if (type == null) { //return namedBinding.Value; CachedBinding b = new CachedBinding(keyClazz, namedBinding.Value, name); //AddToCachedBinder(keyClazz, b); return(b.Activate()); } if (Convert.GetTypeCode(namedBinding.Value) != TypeCode.Object) { CachedBinding b = new CachedBinding(type, namedBinding.Value, name); AddToCachedBinder(keyClazz, b); return(b.Activate()); } //Reflect the constructor ConstructorInfo[] constructorInfoArray = type.GetConstructors(); foreach (ConstructorInfo constructorInfo in constructorInfoArray) { foreach (Attribute attr in constructorInfo.GetCustomAttributes(false)) { if (attr is Inject) { ParameterInfo[] parameterInfoArray = constructorInfo.GetParameters(); object[] paramArray = new object[parameterInfoArray.Length]; int i = 0; foreach (ParameterInfo parameterInfo in parameterInfoArray) { Type parameterType = parameterInfo.ParameterType; string parameterName = ""; foreach (Attribute parameterAttrs in parameterInfo.GetCustomAttributes(false)) { if (parameterAttrs is Named) { Named namedAttr = parameterAttrs as Named; parameterName = namedAttr.Name; } } paramArray[i] = this.Get(parameterType, parameterName, throwExceptions); if (paramArray[i] == null) { exceptions[exceptions.Count - 1].BaseClass = type; } i++; } //Cache and return the instance CachedBinding cachedBinding = new CachedBinding(type, paramArray, name); cachedBinding.Singleton = namedBinding.Singleton; return(GetInstanceAndCache(keyClazz, cachedBinding, throwExceptions)); } } } //Cache and return the instance CachedBinding cached = new CachedBinding(type, name); cached.Singleton = namedBinding.Singleton; return(GetInstanceAndCache(keyClazz, cached, throwExceptions)); } } throw new Exception(); } catch (Exception) { //Set-up the exception BindingNotFoundException bindingNotFoundException; if (name.Equals("")) { bindingNotFoundException = new BindingNotFoundException("Binding not found for " + keyClazz.ToString() + "."); } else { bindingNotFoundException = new BindingNotFoundException("Binding named " + name + " not found for " + keyClazz.ToString() + "."); } if (throwExceptions) { throw bindingNotFoundException; } else { exceptions.Add(bindingNotFoundException); return(null); } } }