/// <summary> /// Register a provided object instance within the component provider as an implementation of the provided /// interface type, using the default singleton lifetime. /// </summary> /// <typeparam name="TInterface">The interface type.</typeparam> /// <param name="instance">The object instance.</param> /// <exception cref="ArgumentNullException">instance - The component instance cannot be null</exception> /// <exception cref="ArgumentException"> /// </exception> public void Register <TInterface>(object instance) { if (instance == null) { throw new ArgumentNullException(nameof(instance), "The component instance cannot be null"); } var type = instance.GetType(); var interfaceType = typeof(TInterface); if (!interfaceType.IsAssignableFrom(type)) { throw new ArgumentException($"The component instance does not implement the interface '{interfaceType.FullName}'"); } var entry = new ComponentDescriptor(type, null, new[] { interfaceType }, null); entry.Designer = new InstancedDesigner(instance); if (implementedEntries.ContainsKey(interfaceType)) { throw new ArgumentException($"Conflicting implementation of '{interfaceType.FullName}'"); } implementedEntries.Add(interfaceType, entry); }
/// <summary> /// Register a provided object instance within the component provider using the default singleton lifetime. /// </summary> /// <param name="instance">The object instance.</param> /// <param name="names">An optional collection of identifiers which the components will be stored under.</param> public void Register(object instance, params string[] names) { if (instance == null) { throw new ArgumentNullException(nameof(instance), "The component instance cannot be null"); } if (names == null) { names = new string[0]; } var type = instance.GetType(); var implements = new List <Type>(GetImplementedTypes(type)); implements.Add(type); var entry = new ComponentDescriptor(type, null, Type.EmptyTypes, names); entry.Designer = new InstancedDesigner(instance); foreach (var implementedType in implements) { implementedEntries.AddIfMissing(implementedType, entry); } if (!typedEntries.ContainsKey(type)) { typedEntries.Add(type, entry); } foreach (var name in names) { if (name == null) { continue; } if (namedEntries.TryGetValue(name, out var existing)) { throw new ArgumentException($"Conflicting named '{name}' component, adding '{type.FullName}' against '{existing.Type.FullName}'"); } namedEntries.Add(name, entry); } }
/// <summary> /// Register a provided interface and concrete type within the component provider using the default singleton lifetime. /// </summary> /// <param name="interfaceType">The interface type.</param> /// <param name="concreteType">The concrete type.</param> /// <param name="names">An optional collection of identifiers which the components will be stored under.</param> /// <returns> /// A configurator which can be used to further configure the component state. /// </returns> public IComponentRegistration Register(Type interfaceType, Type concreteType, params string[] names) { var implements = new List <Type>(GetImplementedTypes(concreteType)); var hasName = names != null && names.Length != 0; if (names == null || names.Length == 0) { names = implements.Concat(new[] { interfaceType, concreteType }).Where(t => t != null).Distinct().Select(t => t.Name).ToArray(); } var constructor = CreateConstructor(concreteType); var entry = new ComponentDescriptor(concreteType, constructor, interfaceType != null ? new[] { interfaceType } : Type.EmptyTypes, names); entry.Designer = new SingletonDesigner(constructor); foreach (var implementedType in implements) { implementedEntries.AddIfMissing(implementedType, entry); } if (interfaceType != null) { if (implementedEntries.TryGetValue(interfaceType, out var existing) && !hasName) { throw new ArgumentException($"Conflicting '{interfaceType.FullName}' component, adding '{concreteType.FullName}' against '{existing.Type.FullName}'"); } if (existing == null) { implementedEntries.Add(interfaceType, entry); } } if (!typedEntries.ContainsKey(concreteType)) { typedEntries.Add(concreteType, entry); } foreach (var name in names) { if (name == null) { continue; } if (namedEntries.TryGetValue(name, out var existing)) { throw new ArgumentException($"Conflicting named '{name}' component, adding '{concreteType.FullName}' against '{existing.Type.FullName}'"); } namedEntries.Add(name, entry); } allEntries.Add(entry); if (ReflectionHelper.GetAttributeInherited <ConfigurationAttribute>(concreteType) != null) { configurationEntries.Add(entry); } return(new ComponentRegistration(new[] { entry })); }