implab/ImplabNet Commit - r279:8714471e8d78

Container configuration cleanup, RC2

cin -

r279:8714471e8d78 v3

parent child

Context file:

r279:8714471e8d78

Expand all files

Implab.ServiceHost/Unity/UnityContainerExtensions.cs created 644 +40 0

@@ -0,0 +1,40
	1	using System.IO;
	2	using Unity;
	3
	4	namespace Implab.ServiceHost.Unity
	5	{
	6	public static class UnityContainerExtensions
	7	{
	8	public static IUnityContainer LoadXmlConfiguration(this IUnityContainer container, string file, ContainerConfigurationSchema schema) {
	9	Safe.ArgumentNotNull(container, nameof(container));
	10	var builder = new ContainerBuilder(container,schema);
	11	builder.LoadConfig(file);
	12	return builder.Container;
	13	}
	14
	15	public static IUnityContainer LoadXmlConfiguration(this IUnityContainer container, Stream stream, ContainerConfigurationSchema schema) {
	16	Safe.ArgumentNotNull(container, nameof(container));
	17	Safe.ArgumentNotNull(stream, nameof(stream));
	18
	19	if (schema == null)
	20	schema = ContainerConfigurationSchema.Default;
	21
	22	var builder = new ContainerBuilder(container,schema);
	23	var config = (ContainerElement)schema.Serializer.Deserialize(stream);
	24	if (config.Items != null) {
	25	foreach(var item in config.Items)
	26	item?.Visit(builder);
	27	}
	28
	29	return builder.Container;
	30	}
	31
	32	public static IUnityContainer LoadXmlConfiguration(this IUnityContainer container, Stream stream) {
	33	return LoadXmlConfiguration(container, stream, ContainerConfigurationSchema.Default);
	34	}
	35
	36	public static IUnityContainer LoadXmlConfiguration(this IUnityContainer container, string file) {
	37	return LoadXmlConfiguration(container, file, ContainerConfigurationSchema.Default);
	38	}
	39	}
	40	} No newline at end of file

Implab.Playground/Program.cs +18 -13

@@ -94,22 +94,27 namespace Implab.Playground {
94	source.Switch.Level = SourceLevels.All;	94	source.Switch.Level = SourceLevels.All;
95	source.Listeners.Add(listener);	95	source.Listeners.Add(listener);
96		96
97	var ~~resolver~~ = new ~~TypeResolver~~();	97	var stopwatch = new Stopwatch();
98	resolver.AddNamespace("System");	98	stopwatch.Start();
99	resolver.AddNamespace("System.Collections.Generic");	99
100	resolver.AddNamespace("Implab.Playground");	100	var container = new UnityContainer();
101	resolver.AddMapping("string", typeof(string));	101
102	resolver.AddMapping("listOf`1", typeof(List<>));	102	Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");
		103	stopwatch.Restart();
		104
		105	container.LoadXmlConfiguration("data/sample.xml");
103		106
104	var spec = TypeReference.Parse("Container{listOf{string}}+Bar{List{string}}");	107	Console.WriteLine($"Loaded: {stopwatch.ElapsedMilliseconds}");
105		108
106	var t = resolver.Resolve(spec, true);	109	stopwatch.Restart();
		110	var instace1 = container.Resolve<IContainer<string>>();
		111	Console.WriteLine($"Resolved1: {stopwatch.ElapsedMilliseconds}");
107		112
108	Console.WriteLine("{0}", t);	113	stopwatch.Restart();
109	Console.WriteLine("Spec: {0}", spec);	114	var instace2 = container.Resolve<IContainer<Foo>>();
110	Console.WriteLine("IsGenericType: {0}", t.IsGenericType);	115	Console.WriteLine($"Resolved2: {stopwatch.ElapsedMilliseconds}");
111	Console.WriteLine("IsGenericTypeDefinition: {0}", t.IsGenericTypeDefinition);	116
112	Console.WriteLine("ContainsGenericParameters: {0}", t.ContainsGenericParameters);	117	DisplayContainerRegistrations(container);
113	}	118	}
114		119
115	static void DisplayContainerRegistrations(IUnityContainer theContainer) {	120	static void DisplayContainerRegistrations(IUnityContainer theContainer) {

Implab.ServiceHost/Unity/AbstractMemberInjection.cs +2 -2

                 /// <summary>
                 /// Base class for injections, each injection is applied to the type registration context.
                 /// </summary>
-                public abstract class AbstractMemberInjection {
+                public abstract class AbstractMemberInjection : ITypeMemberInjection {
-                    internal abstract void Visit(TypeRegistrationBuilder context);
+                    public abstract void Visit(TypeRegistrationBuilder builder);
                 }
             }

Implab.ServiceHost/Unity/AbstractRegistration.cs +9 -3

                 /// <summary>
                 /// Базовая информаци о регистрации в контейнере: тип, имя и время жизни
                 /// </summary>
-                public abstract class AbstractRegistration : AbstractContainerItem {
+                public abstract class AbstractRegistration : AbstractContainerItem, IRegistration {
                     /// <summary>
                     /// An optional name for a registration in the container
                     [XmlAttribute("type")]
                     public string RegistrationType { get; set; }
+                    public virtual LifetimeManager GetLifetime(ContainerBuilder builder) {
+                        return Lifetime?.GetLifetime(builder);
+                    }
                     public virtual Type GetRegistrationType(Func<string,Type> resolver) {
                         return resolver(RegistrationType);
                     }
-                    public virtual void Visit(RegistrationBuilder builder) {
+                    public virtual Type GetRegistrationType(ContainerBuilder builder) {
-                        Lifetime?.Visit(builder);
+                        return builder.ResolveType(RegistrationType);
                     }
                 }
             }

Implab.ServiceHost/Unity/ConstructorInjectionElement.cs +2 -2

                     [XmlElement("array", typeof(ArrayParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
-                    internal override void Visit(TypeRegistrationBuilder context) {
+                    public override void Visit(TypeRegistrationBuilder builder) {
-                        context.Visit(this);
+                        builder.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/ContainerBuilder.cs +5 -71

@@ -7,11 +7,11 namespace Implab.ServiceHost.Unity {
7		7
8	readonly TypeResolver m_resolver;	8	readonly TypeResolver m_resolver;
9		9
10	readonly UnityContainer m_container;	10	readonly IUnityContainer m_container;
11		11
12	readonly ContainerConfigurationSchema m_schema;	12	readonly ContainerConfigurationSchema m_schema;
13		13
14	public UnityContainer Container {	14	public IUnityContainer Container {
15	get {	15	get {
16	return m_container;	16	return m_container;
17	}	17	}
@@ -20,66 +20,14 namespace Implab.ServiceHost.Unity {
20	public ContainerBuilder() : this(null, null) {	20	public ContainerBuilder() : this(null, null) {
21	}	21	}
22		22
23	public ContainerBuilder(UnityContainer container, ContainerConfigurationSchema schema) {	23	public ContainerBuilder(IUnityContainer container, ContainerConfigurationSchema schema) {
24	m_container = container ?? new UnityContainer();	24	m_container = container ?? new UnityContainer();
25	m_resolver = new TypeResolver();	25	m_resolver = new TypeResolver();
26	m_schema = schema ?? ContainerConfigurationSchema.Default;	26	m_schema = schema ?? ContainerConfigurationSchema.Default;
27	}	27	}
28		28
29	public Type ResolveType(string typeReference) {	29	public Type ResolveType(string typeReference) {
30	return m_resolver.Resolve(typeReference, true);	30	return string.IsNullOrEmpty(typeReference) ? null : m_resolver.Resolve(typeReference, true);
31	}
32
33
34	internal void Visit(TypeAbstractRegistration typeRegistration) {
35	var registrationType = typeRegistration.GetRegistrationType(ResolveType);
36	var implementationType = typeRegistration.GetImplementationType(ResolveType) ?? registrationType;
37
38	var registrationContext = new TypeRegistrationBuilder(
39	m_resolver,
40	registrationType,
41	implementationType
42	);
43
44	typeRegistration.Visit(registrationContext);
45
46	m_container.RegisterType(
47	registrationContext.RegistrationType,
48	registrationContext.ImplementationType,
49	typeRegistration.Name,
50	registrationContext.Lifetime,
51	registrationContext.Injections
52	);
53	}
54
55	internal void Visit(InstanceAbstractRegistration instanceRegistration) {
56	var registrationType = instanceRegistration.GetRegistrationType(ResolveType);
57
58	var builder = new InstanceRegistrationBuilder(m_resolver, registrationType);
59
60	instanceRegistration.Visit(builder);
61
62	m_container.RegisterInstance(
63	builder.ValueBuilder.ValueType,
64	instanceRegistration.Name,
65	builder.ValueBuilder.Value,
66	builder.Lifetime
67	);
68	}
69
70	internal void Visit(FactoryAbstractRegistratrion factoryRgistration) {
71	var registrationType = factoryRgistration.GetRegistrationType(ResolveType);
72
73	var builder = new FactoryRegistrationBuilder(registrationType);
74
75	factoryRgistration.Visit(builder);
76
77	m_container.RegisterType(
78	builder.RegistrationType,
79	factoryRgistration.Name,
80	builder.Lifetime,
81	builder.Factory
82	);
83	}	31	}
84		32
85	public void Visit(ITypeRegistration registration) {	33	public void Visit(ITypeRegistration registration) {
@@ -136,25 +84,11 namespace Implab.ServiceHost.Unity {
136	m_container.RegisterInstance(	84	m_container.RegisterInstance(
137	builder.RegistrationType ?? builder.ValueBuilder.ValueType,	85	builder.RegistrationType ?? builder.ValueBuilder.ValueType,
138	registration.Name,	86	registration.Name,
139	builder.ValueBuilder.~~Injection~~,	87	builder.ValueBuilder.Value,
140	builder.Lifetime	88	builder.Lifetime
141	);	89	);
142	}	90	}
143		91
144	public void Visit(IFactoryRegistration registration) {
145	Safe.ArgumentNotNull(registration, nameof(registration));
146
147	var registrationType = registration.GetRegistrationType(this);
148
149	var builder = new FactoryRegistrationBuilder(registrationType);
150
151	if (registration.MemberInjections != null) {
152	foreach(var member in registration.MemberInjections)
153	member?.Visit(builder);
154	}
155
156	}
157
158	public void AddNamespace(string ns) {	92	public void AddNamespace(string ns) {
159	m_resolver.AddNamespace(ns);	93	m_resolver.AddNamespace(ns);
160	}	94	}

Implab.ServiceHost/Unity/ContainerLifetimeElement.cs +4 -2

             namespace Implab.ServiceHost.Unity
             {
                 public class ContainerLifetimeElement : LifetimeElement {
-                    public override void Visit(RegistrationBuilder builder) {
+                    public override LifetimeManager GetLifetime(ContainerBuilder builder) {
-                        builder.Visit(this);
+                        return new ContainerControlledLifetimeManager();
                     }
                 }
             }

Implab.ServiceHost/Unity/ContextLifetimeElement.cs +2 -2

             namespace Implab.ServiceHost.Unity
             {
                 public class ContextLifetimeElement : LifetimeElement {
-                    public override void Visit(RegistrationBuilder builder) {
+                    public override LifetimeManager GetLifetime(ContainerBuilder builder) {
-                        builder.Visist(this);
+                        return new PerResolveLifetimeManager();
                     }
                 }
             }

Implab.ServiceHost/Unity/DependencyParameterElement.cs +1 -1

                     public override  void Visit(InjectionParameterBuilder builder) {
                         var type = builder.ResolveInjectedValueType(TypeName);
-                        builder.SetDependencyReference(type, DependencyName, Optional);
+                        builder.SetDependency(type, DependencyName, Optional);
                     }
                 }
             }

Implab.ServiceHost/Unity/FactoryActivator.cs +46 -12

@@ -1,29 +1,63
1	using System;	1	using System;
		2	using System.Collections.Generic;
		3	using System.Reflection;
		4	using Implab.Components;
		5	using Unity;
		6	using Unity.Injection;
		7	using Unity.Lifetime;
2		8
3	namespace Implab.ServiceHost.Unity {	9	namespace Implab.ServiceHost.Unity {
4	public class FactoryActivator : ~~FactoryAbstract~~Registratrion {	10	public class FactoryActivator : ITypeRegistration {
		11
		12	class FactoryInjector : ITypeMemberInjection {
		13	public InjectionFactory Factory { get; set; }
		14	public void Visit(TypeRegistrationBuilder builder) {
		15	builder.AddInjectionMember(Factory);
		16	}
		17	}
		18
5		19
6	public Type FactoryType { get; set; }	20	public Type FactoryType { get; set; }
7		21
8	public string FactoryName { get; set; }	22	public string FactoryName { get; set; }
9		23
10	public ~~new~~ Type RegistrationType { get; set; }	24	public Type RegistrationType { get; set; }
11		25
12	public override void Visit(FactoryRegistrationBuilder builder) {	26	public LifetimeManager Lifetime { get; set; }
13	base.Visit(builder);
14		27
15	builder.GetType()	28	public IEnumerable<ITypeMemberInjection> MemberInjections {
16	.~~GetMethod~~(	29	get {
17	nameof(FactoryRegistrationBuilder.SetFactoryDependency)	30	yield return new FactoryInjector {
18	, new[] { typeof(string) }	31	Factory = (InjectionFactory)GetType()
19	)	32	.GetMethod(nameof(CreateInjectionFactory), BindingFlags.Static \| BindingFlags.NonPublic)
20	.MakeGenericMethod(FactoryType, RegistrationType)	33	.MakeGenericMethod(FactoryType, RegistrationType)
21	.Invoke(~~builder~~, new[] { FactoryName });	34	.Invoke(null, new [] { FactoryName })
		35	};
		36	}
22	}	37	}
23		38
24	public override Type GetRegistrationType(Func<string, Type> resolver) {	39	public string Name { get; set; }
		40
		41	public Type GetRegistrationType(ContainerBuilder builder) {
25	return RegistrationType;	42	return RegistrationType;
26	}	43	}
27		44
		45	public LifetimeManager GetLifetime(ContainerBuilder builder) {
		46	return Lifetime;
		47	}
		48
		49	public Type GetImplementationType(ContainerBuilder builder) {
		50	return null;
		51	}
		52
		53	/// <summary>
		54	/// Указывает зависимость, реализующую интерфейс <see cref="IFactory{TObj}"/>,
		55	/// которая будет использоваться в качестве фабрики для создания объектов
		56	/// </summary>
		57	/// <param name="dependencyName"></param>
		58	static InjectionFactory CreateInjectionFactory<TFac, TObj>(string dependencyName) where TFac : IFactory<TObj> {
		59
		60	return new InjectionFactory(c => c.Resolve<TFac>(dependencyName).Create());
		61	}
28	}	62	}
29	} No newline at end of file	63	}

Implab.ServiceHost/Unity/FactoryElement.cs +3 -3

                 /// Расширяет стандартную регистрацию типа до фабрики, вместе с регистрацией
                 /// самой фабрики создаются регистрации сервисов, которые она предоставляет.
                 /// </summary>
-                public class FactoryElement : RegisterElement {
+                public class FactoryElement : RegisterElement, ITypeRegistration {
                     /// <summary>
                     /// Записи о сервисах, которые создаются данной фабрикой.
                                     FactoryName = Name,
                                     FactoryType = factoryType
                                 };
-                                activator.Visit(builder);
+                                builder.Visit(activator);
                             }
                         } else {
                             // если регистрация явно не задана, в качестве сервиса для регистрации
                                 FactoryType = factoryType
                             };
-                            activator.Visit(builder);
+                            builder.Visit(activator);
                         }
                     }
                 }

Implab.ServiceHost/Unity/HierarchicalLifetimeElement.cs +2 -2

             namespace Implab.ServiceHost.Unity
             {
                 public class HierarchicalLifetimeElement : LifetimeElement {
-                    public override void Visit(RegistrationBuilder builder) {
+                    public override LifetimeManager GetLifetime(ContainerBuilder builder) {
-                        builder.Visit(this);
+                        return new HierarchicalLifetimeManager();
                     }
                 }
             }

Implab.ServiceHost/Unity/InjectionParameterElement.cs +1 -1

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public abstract class InjectionParameterElement {
+                public abstract class InjectionParameterElement : IInjectionParameter {
                     [XmlAttribute("type")]
                     public string TypeName { get; set; }

Implab.ServiceHost/Unity/InjectionValueBuilder.cs +62 -17

             using System;
+            using System.Collections;
             using System.Collections.Generic;
             using System.ComponentModel;
             using System.Linq;
                     public Type ValueType { get; private set; }
-                    public object Value { get; set; }
+                    object m_value;
-                    internal InjectionParameterValue Injection {
+                    public object Value {
                         get {
-                            if (Value != null)
+                            if (!ValueSpecified)
-                                return InjectionParameterValue.ToParameter(Value);
+                                throw new InvalidOperationException("The regular value must be set (dependency or array are not situable in this context)");
+                            return m_value;
+                        }
+                    }
+                    public bool ValueSpecified { get; private set; }
+                    InjectionParameterValue m_injection;
-                            return new InjectionParameter(ValueType, null);
+                    public InjectionParameterValue Injection {
+                        get {
+                            if (m_injection == null)
+                                throw new InvalidOperationException("The injection parameter is not specified");
+                            return m_injection;
                         }
                     }
+                    public bool InjectionSpecified {
+                        get { return m_injection != null; }
+                    }
                     internal InjectionParameterBuilder(TypeResolver resolver, Type defaultType) {
                         m_resolver = resolver;
                         DefaultType = defaultType;
                     }
                     public Type ResolveType(string typeSpec) {
-                        return m_resolver.Resolve(typeSpec, true);
+                        return string.IsNullOrEmpty(typeSpec) ? null : m_resolver.Resolve(typeSpec, true);
                     }
                     public void SetValue(Type type, object value) {
+                        Safe.ArgumentNotNull(type, nameof(type));
                         ValueType = type;
-                        Value = value;
+                        m_value = value;
+                        ValueSpecified = true;
+                        m_injection = new InjectionParameter(type, value);
                     }
-                    public void SetValue<T>(T value) {
+                    public void SetDependency(Type type, string name, bool optional) {
-                        SetValue(typeof(T), value);
+                        Safe.ArgumentNotNull(type, nameof(type));
-                    public void SetDependencyReference(Type type, string name, bool optional) {
                         ValueType = type;
-                        Value = optional ? (object)new OptionalParameter(type, name) : new ResolvedParameter(type, name);
+                        ValueSpecified = false;
+                        m_value = null;
+                        m_injection = optional ? (InjectionParameterValue)new OptionalParameter(type, name) : new ResolvedParameter(type, name);
                     }
                     internal void Visit(ArrayParameterElement arrayParameter) {
                         Type itemsType = null;
                         var arrayType = string.IsNullOrEmpty(arrayParameter.TypeName) ? null : ResolveType(arrayParameter.TypeName);
+                        if (arrayType == null)
+                            arrayType = DefaultType;
                         if (!string.IsNullOrEmpty(arrayParameter.ItemsType)) {
                             itemsType = ResolveType(arrayParameter.ItemsType);
-                            if (arrayType == null)
+                            arrayType = itemsType.MakeArrayType();
-                                arrayType = itemsType.MakeArrayType();
                         } else {
-                            itemsType = arrayType?.GetInterface(typeof(IEnumerable<>).FullName)?.GetGenericArguments()[0];
+                            itemsType = GetItemsType(arrayType);
                         }
                         if (itemsType == null)
                             .ToArray();
                         var array = itemsType.IsGenericParameter ?
-                            (object)new GenericResolvedArrayParameter(itemsType.Name, injections) :
+                            (InjectionParameterValue)new GenericResolvedArrayParameter(itemsType.Name, injections) :
                             new ResolvedArrayParameter(itemsType, injections);
                         ValueType = arrayType;
-                        Value = array;
+                        m_value = null;
+                        ValueSpecified = false;
+                        m_injection = array;
+                    }
+                    Type GetItemsType(Type collectionType) {
+                        if (collectionType == null)
+                            return null;
+                        Type itemsType = null;
+                        if (collectionType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) {
+                            itemsType = collectionType.GetGenericArguments()[0];
+                        } else if (collectionType == typeof(IEnumerable)) {
+                            itemsType = typeof(object);
+                        } else {
+                            itemsType = collectionType.GetInterface(typeof(IEnumerable<>).FullName)?.GetGenericArguments()[0];
+                        }
+                        return itemsType;
                     }
                 }
             }

Implab.ServiceHost/Unity/LifetimeElement.cs +3 -1

+            using Unity.Lifetime;
             namespace Implab.ServiceHost.Unity {
                 public abstract class LifetimeElement {
-                    public abstract void Visit(RegistrationBuilder builder);
+                    public abstract LifetimeManager GetLifetime(ContainerBuilder builder);
                 }
             }

Implab.ServiceHost/Unity/MethodInjectionElement.cs +1 -1

                     [XmlElement("array", typeof(ArrayParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
-                    internal override void Visit(TypeRegistrationBuilder context) {
+                    public override void Visit(TypeRegistrationBuilder context) {
                         context.Visit(this);
                     }
                 }

Implab.ServiceHost/Unity/PropertyInjectionElement.cs +1 -1

                     [XmlElement("array", typeof(ArrayParameterElement))]
                     public InjectionParameterElement Value { get; set; }
-                    internal override void Visit(TypeRegistrationBuilder context) {
+                    public override void Visit(TypeRegistrationBuilder context) {
                         context.Visit(this);
                     }
                 }

Implab.ServiceHost/Unity/RegisterElement.cs +11 -8

             using System;
+            using System.Collections.Generic;
             using System.Xml.Serialization;
             using Unity.Lifetime;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("register", Namespace = Schema.ContainerConfigurationNamespace)]
-                public class RegisterElement : TypeAbstractRegistration  {
+                public class RegisterElement : AbstractRegistration, ITypeRegistration  {
                     /// <summary>
                     /// An optional type which is registered as a service in the container, must be assignable to <see cref="ProvidesType">.
                     [XmlElement("method", typeof(MethodInjectionElement))]
                     public AbstractMemberInjection[] Injectors { get; set; }
-                    public override Type GetImplementationType(Func<string, Type> resolver) {
+                    IEnumerable<ITypeMemberInjection> ITypeRegistration.MemberInjections {
-                        return string.IsNullOrEmpty(MapToType) ? null : resolver(MapToType);
+                        get {
+                            return Injectors;
+                        }
                     }
-                    public override void Visit(TypeRegistrationBuilder builder) {
+                    public Type GetImplementationType(ContainerBuilder builder) {
-                        if(Injectors != null)
+                        return builder.ResolveType(MapToType);
-                            foreach(var injector in Injectors)
-                                injector.Visit(builder);
                     }
+                    public override void Visit(ContainerBuilder builder) {
+                        builder.Visit(this);
+                    }
                 }
             }

Implab.ServiceHost/Unity/SerializedElement.cs +14 -11

             using System;
+            using System.Collections.Generic;
             using System.Xml;
             using System.Xml.Serialization;
-            namespace Implab.ServiceHost.Unity
+            namespace Implab.ServiceHost.Unity {
+                public class SerializedElement : AbstractRegistration, IInstanceRegistration {
-                public class SerializedElement : InstanceAbstractRegistration {
                     [XmlAttribute("href")]
                     public string Location { get; set; }
                     [XmlAnyElement]
                     public XmlElement[] Content { get; set; }
-                    public override void Visit(InstanceRegistrationBuilder builder) {
+                    public IEnumerable<IInjectionParameter> MemberInjections {
-                        base.Visit(builder);
+                        get {
+                            yield return new SerializedParameterElement {
+                                TypeName = SerializedType,
+                                Location = Location,
+                                Content = Content
+                            };
+                        }
+                    }
-                        var parameter = new SerializedParameterElement {
+                    public override void Visit(ContainerBuilder builder) {
-                            TypeName = SerializedType,
+                        builder.Visit(this);
-                            Location = Location,
-                            Content = Content
-                        };
-                        parameter.Visit(builder.ValueBuilder);
                     }
                 }
             }

Implab.ServiceHost/Unity/SingletonLifetimeElement.cs +4 -2

+            using Unity.Lifetime;
             namespace Implab.ServiceHost.Unity
             {
                 public class SingletonLifetimeElement : LifetimeElement {
-                    public override void Visit(RegistrationBuilder builder) {
+                    public override LifetimeManager GetLifetime(ContainerBuilder builder) {
-                        builder.Visit(this);
+                        return new SingletonLifetimeManager();
                     }
                 }
             }

Implab.ServiceHost/Unity/TypeRegistrationBuilder.cs +6 0

                         var injection = new InjectionProperty(propertyInjection.Name, valueContext.Injection);
                         m_injections.Add(injection);
                     }
+                    public void AddInjectionMember(InjectionMember injection) {
+                        Safe.ArgumentNotNull(injection, nameof(injection));
+                        m_injections.Add(injection);
+                    }
                 }
             }

Implab.ServiceHost/Unity/TypeResolver.cs +1 0

                     }
                     public Type Resolve(string typeSpec, bool throwOnFail) {
+                        Safe.ArgumentNotEmpty(typeSpec, nameof(typeSpec));
                         var typeReference = TypeReference.Parse(typeSpec);
                         return Resolve(typeReference, throwOnFail);
                     }

Implab.ServiceHost/Unity/ValueElement.cs +14 -9

+            using System.Collections.Generic;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class ValueElement : InstanceAbstractRegistration {
+                public class ValueElement : AbstractRegistration, IInstanceRegistration {
                     [XmlAttribute("value")]
                     public string Value { get; set; }
                         }
                     }
-                    public override void Visit(InstanceRegistrationBuilder builder) {
+                    public IEnumerable<IInjectionParameter> MemberInjections {
-                        base.Visit(builder);
+                        get {
-                        var parameter = new ValueParameterElement {
+                            yield return new ValueParameterElement {
-                            Value = Value,
+                                Value = Value,
-                            Text = Text
+                                Text = Text
-                        };
+                            };
-                        parameter.Visit(builder.ValueBuilder);
+                    }
+                    public override void Visit(ContainerBuilder builder) {
+                        builder.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/FactoryAbstractRegistration.cs removed 0 -11

NO CONTENT: file was removed

Implab.ServiceHost/Unity/FactoryRegistrationBuilder.cs removed 0 -54

NO CONTENT: file was removed

Implab.ServiceHost/Unity/IFactoryMemberInjection.cs removed 0 -5

NO CONTENT: file was removed

Implab.ServiceHost/Unity/IFactoryRegistration.cs removed 0 -7

NO CONTENT: file was removed

Implab.ServiceHost/Unity/InstanceAbstractRegistration.cs removed 0 -12

NO CONTENT: file was removed

Implab.ServiceHost/Unity/TypeAbstractRegistration.cs removed 0 -17

NO CONTENT: file was removed

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages