implab/ImplabNet Commit - r277:963b17c275be

Refactoring...

cin -

r277:963b17c275be v3

parent child

Context file:

r277:963b17c275be

Expand all files

Implab.ServiceHost/Unity/AbstractContainerItem.cs created 644 +12 0

@@ -0,0 +1,12
	1	namespace Implab.ServiceHost.Unity {
	2
	3	/// <summary>
	4	/// Базовый класс для элеметов контейнера.
	5	/// </summary>
	6	/// <remarks>
	7	/// XmlSerializer требует использования классов при объявлении свойств, которые будут сериализованы <see cref="ContainerElement.Items"/>
	8	/// </remarks>
	9	public abstract class AbstractContainerItem {
	10	public abstract void Visit(ContainerBuilder builder);
	11	}
	12	} No newline at end of file

Implab.ServiceHost/Unity/ArrayParameterElement.cs created 644 +20 0

@@ -0,0 +1,20
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	public class ArrayParameterElement : InjectionParameterElement {
	6
	7	[XmlAttribute("itemsType")]
	8	public string ItemsType { get; set; }
	9
	10	[XmlElement("dependency", typeof(DependencyParameterElement))]
	11	[XmlElement("value", typeof(ValueParameterElement))]
	12	[XmlElement("serialized", typeof(SerializedParameterElement))]
	13	[XmlElement("default", typeof(DefaultParameterElement))]
	14	public InjectionParameterElement[] Items { get; set; }
	15
	16	public override void Visit(InjectionValueBuilder builder) {
	17	builder.Visit(this);
	18	}
	19	}
	20	} No newline at end of file

Implab.ServiceHost/Unity/FactoryAbstractRegistration.cs created 644 +11 0

@@ -0,0 +1,11
	1	namespace Implab.ServiceHost.Unity {
	2	public class FactoryAbstractRegistratrion : AbstractRegistration {
	3	public override void Visit(ContainerBuilder builder) {
	4	builder.Visit(this);
	5	}
	6
	7	public virtual void Visit(FactoryRegistrationBuilder builder) {
	8	base.Visit(builder);
	9	}
	10	}
	11	} No newline at end of file

Implab.ServiceHost/Unity/FactoryRegistrationBuilder.cs created 644 +36 0

@@ -0,0 +1,36
	1	using System;
	2	using Implab.Components;
	3	using Unity;
	4	using Unity.Injection;
	5	using Unity.Registration;
	6
	7	namespace Implab.ServiceHost.Unity
	8	{
	9	public class FactoryRegistrationBuilder : RegistrationBuilder {
	10
	11	internal InjectionMember Factory { get; private set; }
	12
	13	internal FactoryRegistrationBuilder(Type registrationType) : base(registrationType) {
	14	}
	15
	16	public void SetFactoryDelegate(Delegate factory) {
	17	Safe.ArgumentNotNull(factory, nameof(factory));
	18
	19	Factory = new DelegateInjectionFactory(factory);
	20	}
	21
	22	public void SetFactoryDependency<T>(string dependencyName, Func<T, object> factory) {
	23	Safe.ArgumentNotNull(factory, nameof(factory));
	24
	25	Factory = new InjectionFactory((c,t,name) => {
	26	var backend = c.Resolve<T>(dependencyName);
	27	return factory(backend);
	28	});
	29	}
	30
	31	public void SetFactoryDependency<TFac, TObj>(string dependencyName) where TFac : IFactory<TObj> {
	32
	33	Factory = new InjectionFactory(c => c.Resolve<TFac>(dependencyName).Create());
	34	}
	35	}
	36	} No newline at end of file

Implab.ServiceHost/Unity/InstanceAbstractRegistration.cs created 644 +12 0

@@ -0,0 +1,12
	1	namespace Implab.ServiceHost.Unity
	2	{
	3	public abstract class InstanceAbstractRegistration : AbstractRegistration {
	4	public override void Visit(ContainerBuilder builder) {
	5	builder.Visit(this);
	6	}
	7
	8	public virtual void Visit(InstanceRegistrationBuilder builder) {
	9	base.Visit(builder);
	10	}
	11	}
	12	} No newline at end of file

Implab.ServiceHost/Unity/InstanceRegistrationBuilder.cs created 644 +13 0

@@ -0,0 +1,13
	1	using System;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	public class InstanceRegistrationBuilder : RegistrationBuilder {
	6
	7	public InjectionValueBuilder ValueBuilder { get; private set; }
	8
	9	internal InstanceRegistrationBuilder(TypeResolver typeResolver, Type registrationType) : base(registrationType) {
	10	ValueBuilder = new InjectionValueBuilder(typeResolver, registrationType);
	11	}
	12	}
	13	} No newline at end of file

Implab.ServiceHost/Unity/TypeAbstractRegistration.cs created 644 +17 0

@@ -0,0 +1,17
	1	using System;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	public abstract class TypeAbstractRegistration : AbstractRegistration {
	6
	7	public abstract Type GetImplementationType(Func<string,Type> resolver);
	8
	9	override public void Visit(ContainerBuilder builder) {
	10	builder.Visit(this);
	11	}
	12
	13	public virtual void Visit(TypeRegistrationBuilder builder) {
	14	base.Visit(builder);
	15	}
	16	}
	17	} No newline at end of file

Implab.Playground/Program.cs +22 -3

             using System;
+            using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using Implab.Diagnostics;
             using Implab.ServiceHost.Unity;
             using Implab.Xml;
             using Unity;
             using Unity.Injection;
             using Unity.Registration;
             namespace Implab.Playground {
                 public class Foo {
                     public class Bar {
                     }
                     public string Name { get; set; }
                     public int IntValue { get; set; }
                     public string StringValue { get; set; }
+                    public void AddRange(Foo[] items) {
+                        Console.WriteLine($"AddRange: Foo[]");
+                    }
                 }
                 public interface IContainer<T> {
                     T Instance { get; set; }
                 }
                 public class Container<T> : IContainer<T> {
                     public Container() {
                     }
                     public Container(T instance) {
                         Instance = instance;
                     }
                     public T Instance { get; set; }
                     public void SetInstance(T value) {
                         Instance = value;
                     }
+                    public void AddRange(List<T> items) {
+                        Console.WriteLine($"AddRange: {typeof(List<T>)}");
+                    }
+                    public void AddRange(T[] items) {
+                        Console.WriteLine($"AddRange: T[] ofType {typeof(T[])}");
+                    }
                 }
                 public class Program {
                     static void Main(string[] args) {
+                        var listener = new SimpleTraceListener(Console.Out);
+                        var source = Trace<TypeResolver>.TraceSource;
+                        source.Switch.Level = SourceLevels.All;
+                        source.Listeners.Add(listener);
                         var stopwatch = new Stopwatch();
                         stopwatch.Start();
                         var ctx = new ContainerBuilder();
                         Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");
+                        stopwatch.Restart();
                         ctx.LoadConfig("data/sample.xml");
                         Console.WriteLine($"Loaded: {stopwatch.ElapsedMilliseconds}");
                         var container = ctx.Container;
+                        stopwatch.Restart();
                         var instace1 = container.Resolve<IContainer<string>>();
                         Console.WriteLine($"Resolved1: {stopwatch.ElapsedMilliseconds}");
+                        stopwatch.Restart();
                         var instace2 = container.Resolve<IContainer<Foo>>();
                         Console.WriteLine($"Resolved2: {stopwatch.ElapsedMilliseconds}");
                         DisplayContainerRegistrations(container);
                     }
                     static void DisplayContainerRegistrations(IUnityContainer theContainer) {
                         string regName, regType, mapTo, lifetime;
                         Console.WriteLine("Container has {0} Registrations:",
                                 theContainer.Registrations.Count());
                         foreach (ContainerRegistration item in theContainer.Registrations) {
                             regType = item.RegisteredType.FullName;
                             mapTo = item.MappedToType.FullName;
                             regName = item.Name ?? "[default]";
                             lifetime = item.LifetimeManager.LifetimeType.Name;
                             if (mapTo != regType) {
                                 mapTo = " -> " + mapTo;
                             } else {
                                 mapTo = string.Empty;
                             }
                             lifetime = lifetime.Substring(0, lifetime.Length - "LifetimeManager".Length);
                             Console.WriteLine("+ {0}{1}  '{2}'  {3}", regType, mapTo, regName, lifetime);
                         }
                     }
                 }
             }

Implab.Playground/data/sample.xml +19 0

             <?xml version="1.0" encoding="UTF-8"?>
             <container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
                 <namespace name="System"/>
+                <namespace name="System.Collections.Generic"/>
                 <namespace name="Implab.Playground"/>
                 <!-- foo1 -->
                 <register name="foo1" type="Foo">
                     <property name="Name">
                         <value>FOO!</value>
                     </property>
                 </register>
                 <!-- foo2 -->
                 <register name="foo2" type="Foo">
                     <property name="Name">
                         <value>GOOD</value>
                     </property>
                     <property name="IntValue">
                         <value>2</value>
                     </property>
                 </register>
                 <register type="Foo">
+                    <method name="AddRange">
+                        <array itemsType="Foo">
+                            <dependency name="foo2"/>
+                        </array>
+                    </method>
                 </register>
                 <register type="IContainer{}" mapTo="Container{}">
                     <constructor/>
                     <method name="SetInstance">
                         <dependency type="T"/>
                     </method>
+                    <method name="AddRange">
+                        <array itemsType="T">
+                            <dependency name="foo2"/>
+                        </array>
+                    </method>
+                </register>
+                <register type="List{}">
+                    <constructor />
                 </register>
                 <register type="IContainer{String}" mapTo="Container{String}">
                     <constructor/>
                     <method name="SetInstance">
                         <dependency type="String" name="name1"/>
                     </method>
                 </register>
                 <serialized type="Foo+Bar">
                     <Bar xmlns="" id="1">
                         <Name>Baaar</Name>
                     </Bar>
                 </serialized>
                 <value name="connection1" type="String"><![CDATA[Connect me <here>!]]></value>
                 <value name="name1" type="String" value="Hello!"/>
+                <factory name="foo3" type="FooFactory">
+                    <parameter name="FooName"><![CDATA[Wired "" objecty <> name @#$%^&]]></parameter>
+                </factory>
             </container>

Implab.ServiceHost/Unity/AbstractMemberInjection.cs ~~Implab.ServiceHost/Unity/AbstractInjectionElement.cs~~ renamed +1 -1

             using System;
             namespace Implab.ServiceHost.Unity {
                 /// <summary>
                 /// Base class for injections, each injection is applied to the type registration context.
                 /// </summary>
-                public abstract class AbstractInjectionElement {
+                public abstract class AbstractMemberInjection {
                     internal abstract void Visit(TypeRegistrationBuilder context);
                 }
             }

Implab.ServiceHost/Unity/AbstractRegistration.cs +13 -2

             using System;
             using System.Xml.Serialization;
             using Unity.Lifetime;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity
             {
-                public abstract class AbstractRegistration : ContainerItemElement {
+                /// <summary>
+                /// Базовая информаци о регистрации в контейнере: тип, имя и время жизни
+                /// </summary>
+                public abstract class AbstractRegistration : AbstractContainerItem {
                     /// <summary>
                     /// An optional name for a registration in the container
                     /// </summary>
                     [XmlAttribute("name")]
                     public string Name {
                         get; set;
                     }
-                    [XmlElement("signleton", typeof(SimgletonLifetimeElement))]
+                    [XmlElement("signleton", typeof(SingletonLifetimeElement))]
                     [XmlElement("context", typeof(ContextLifetimeElement))]
                     [XmlElement("container", typeof(ContainerLifetimeElement))]
                     [XmlElement("hierarchy", typeof(HierarchicalLifetimeElement))]
                     public LifetimeElement Lifetime {get; set;}
                     /// <summary>
                     /// A type specification for the service registration,
                     /// </summary>
                     [XmlAttribute("type")]
                     public string RegistrationType { get; set; }
+                    public virtual Type GetRegistrationType(Func<string,Type> resolver) {
+                        return resolver(RegistrationType);
+                    }
+                    public virtual void Visit(RegistrationBuilder builder) {
+                        Lifetime?.Visit(builder);
+                    }
                 }
             }

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
                 [XmlRoot("assembly", Namespace = Schema.ContainerConfigurationNamespace)]
-                public class AssemblyElement : ContainerItemElement {
+                public class AssemblyElement : AbstractContainerItem {
                     [XmlAttribute("name")]
                     public string AssemblyName { get; set; }
-                    public override void Visit(ContainerBuilder context) {
+                    public override void Visit(ContainerBuilder builder) {
-                        context.Visit(this);
+                        builder.Visit(this);
                     }
                 }
             }

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class ConstructorInjectionElement : AbstractInjectionElement {
+                public class ConstructorInjectionElement : AbstractMemberInjection {
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
+                    [XmlElement("array", typeof(ArrayParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
                     internal override void Visit(TypeRegistrationBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/ContainerBuilder.cs +28 -35

             using System;
             using System.Collections.Generic;
             using System.Text.RegularExpressions;
             using Implab.Diagnostics;
             namespace Implab.ServiceHost.Unity {
                 using System.Linq;
                 using System.Reflection;
                 using System.Text;
                 using global::Unity;
                 using global::Unity.Registration;
                 using Implab.Xml;
                 using static Trace<ContainerBuilder>;
                 public class ContainerBuilder {
                     readonly TypeResolver m_resolver;
                     readonly UnityContainer m_container;
                     readonly ContainerConfigurationSchema m_schema;
                     public UnityContainer Container {
                         get {
                             return m_container;
                         }
                     }
                     public ContainerBuilder() : this(null, null) {
                     }
                     public ContainerBuilder(UnityContainer container, ContainerConfigurationSchema schema) {
                         m_container = container ?? new UnityContainer();
                         m_resolver = new TypeResolver();
                         m_schema = schema ?? ContainerConfigurationSchema.Default;
                     }
                     public Type ResolveType(string typeReference) {
                         return m_resolver.Resolve(typeReference);
                     }
-                    internal void Visit(RegisterElement registerElement) {
-                        var registrationType = ResolveType(registerElement.RegistrationType);
+                    internal void Visit(TypeAbstractRegistration typeRegistration) {
-                        var implementationType = string.IsNullOrEmpty(registerElement.MapToType) ? registrationType : ResolveType(registerElement.MapToType);
+                        var registrationType = typeRegistration.GetRegistrationType(ResolveType);
+                        var implementationType = typeRegistration.GetImplementationType(ResolveType) ?? registrationType;
                         var registrationContext = new TypeRegistrationBuilder(
                             m_resolver,
                             registrationType,
                             implementationType
                         );
-                        if (registerElement.Injectors != null) {
+                        typeRegistration.Visit(registrationContext);
-                            foreach (var injector in registerElement.Injectors) {
-                                injector.Visit(registrationContext);
                         m_container.RegisterType(
                             registrationContext.RegistrationType,
                             registrationContext.ImplementationType,
-                            registerElement.Name,
+                            typeRegistration.Name,
-                            registerElement.Lifetime?.GetLifetimeManager(this),
+                            registrationContext.Lifetime,
                             registrationContext.Injections
                         );
                     }
-                    internal void Visit(SerializedElement serializedElement) {
+                    internal void Visit(InstanceAbstractRegistration instanceRegistration) {
-                        var registrationType = ResolveType(serializedElement.RegistrationType);
+                        var registrationType = instanceRegistration.GetRegistrationType(ResolveType);
-                        var valueBuilder = new InjectionValueBuilder(m_resolver, null);
-                        valueBuilder.Visit(serializedElement);
+                        var builder = new InstanceRegistrationBuilder(m_resolver, registrationType);
+                        instanceRegistration.Visit(builder);
                         m_container.RegisterInstance(
-                            registrationType,
+                            builder.ValueBuilder.ValueType,
-                            serializedElement.Name,
+                            instanceRegistration.Name,
-                            valueBuilder.Value,
+                            builder.ValueBuilder.Value,
-                            serializedElement.Lifetime?.GetLifetimeManager(this)
+                            builder.Lifetime
                         );
                     }
-                    internal void Visit(ValueElement valueElement) {
+                    internal void Visit(FactoryAbstractRegistratrion factoryRgistration) {
-                        var registrationType = ResolveType(valueElement.RegistrationType);
+                        var registrationType = factoryRgistration.GetRegistrationType(ResolveType);
-                        var valueBuilder = new InjectionValueBuilder(m_resolver, null);
-                        valueBuilder.Visit(valueElement);
+                        var builder = new FactoryRegistrationBuilder(registrationType);
-                        m_container.RegisterInstance(
+                        factoryRgistration.Visit(builder);
-                            registrationType,
-                            valueElement.Name,
+                        m_container.RegisterType(
-                            valueBuilder.Value,
+                            builder.RegistrationType,
-                            valueElement.Lifetime?.GetLifetimeManager(this)
+                            factoryRgistration.Name,
+                            builder.Lifetime,
+                            builder.Factory
                         );
                     }
                     internal void Visit(NamespaceElement namespaceElement) {
                         m_resolver.AddNamespace(namespaceElement.Name);
                     }
                     internal void Visit(AssemblyElement assemblyElement) {
                         Assembly.Load(assemblyElement.AssemblyName);
                     }
                     internal void Visit(IncludeElement includeElement) {
                         Include(includeElement.Href);
                     }
                     public void Include(string file) {
                         var includeContext = new ContainerBuilder(m_container, m_schema);
                         includeContext.LoadConfig(file);
                     }
                     public void LoadConfig(string file) {
                         var config = m_schema.LoadFile(file);
-                        Visit(config);
+                        config.Visit(this);
                     }
-                    internal void Visit(ContainerElement containerElement) {
-                        foreach (var item in containerElement.Items)
-                            item.Visit(this);
                 }
             }

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

             using System;
             using System.Collections.Generic;
             using System.IO;
             using System.Reflection;
             using System.Xml;
             using System.Xml.Serialization;
             using Implab.Components;
             namespace Implab.ServiceHost.Unity {
                 public class ContainerConfigurationSchema {
                     public static ContainerConfigurationSchema Default { get; private set; } = CreateDefault();
                     readonly LazyAndWeak<XmlSerializer> m_seralizer;
                     readonly XmlAttributeOverrides m_overrides = new XmlAttributeOverrides();
                     readonly XmlAttributes m_containerItems = new XmlAttributes();
                     public XmlSerializer Serializer {
                         get {
                             return m_seralizer.Value;
                         }
                     }
                     public ContainerConfigurationSchema() {
                         m_overrides.Add(typeof(ContainerElement), nameof(ContainerElement.Items), m_containerItems);
                         m_seralizer = new LazyAndWeak<XmlSerializer>(() => new XmlSerializer(typeof(ContainerElement), m_overrides));
                     }
                     public void RegisterContainerElement(Type type, string name) {
                         Safe.ArgumentNotNull(type, nameof(type));
                         Safe.ArgumentNotEmpty(name, nameof(name));
-                        if(!type.IsSubclassOf(typeof(ContainerItemElement)))
+                        if(!type.IsSubclassOf(typeof(AbstractContainerItem)))
-                            throw new Exception($"RegisterContainerElement '{name}': {type} must be subclass of {typeof(ContainerItemElement)}");
+                            throw new Exception($"RegisterContainerElement '{name}': {type} must be subclass of {typeof(AbstractContainerItem)}");
                         m_containerItems.XmlElements.Add(
                             new XmlElementAttribute(name, type)
                         );
                     }
-                    public void RegisterContainerElement<T>(string name) where T : ContainerItemElement {
+                    public void RegisterContainerElement<T>(string name) where T : AbstractContainerItem {
                         RegisterContainerElement(typeof(T), name);
                     }
                     public ContainerElement LoadFile(string file) {
                         using (var reader = XmlReader.Create(file)) {
                             return (ContainerElement)Serializer.Deserialize(reader);
                         }
                     }
                     static ContainerConfigurationSchema CreateDefault() {
                         var schema = new ContainerConfigurationSchema();
                         schema.RegisterContainerElement<RegisterElement>("register");
                         schema.RegisterContainerElement<SerializedElement>("serialized");
                         schema.RegisterContainerElement<ValueElement>("value");
                         schema.RegisterContainerElement<IncludeElement>("include");
                         schema.RegisterContainerElement<AssemblyElement>("assembly");
                         schema.RegisterContainerElement<NamespaceElement>("namespace");
                         return schema;
                     }
                 }
             }

Implab.ServiceHost/Unity/ContainerElement.cs +5 -3

             using Implab.Xml;
             using System.Collections.Generic;
             using System.Xml;
             using System.Xml.Schema;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("container", Namespace = Schema.ContainerConfigurationNamespace)]
-                public class ContainerElement : ContainerItemElement {
+                public class ContainerElement : AbstractContainerItem {
-                    public List<ContainerItemElement> Items { get; set; } = new List<ContainerItemElement>();
+                    public List<AbstractContainerItem> Items { get; set; } = new List<AbstractContainerItem>();
                     public override void Visit(ContainerBuilder context) {
-                        context.Visit(this);
+                        if (Items != null)
+                            foreach(var item in Items)
+                                item.Visit(context);
                     }
                 }
             }

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

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

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

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

Implab.ServiceHost/Unity/DefaultParameterElement.cs +3 -2

             namespace Implab.ServiceHost.Unity
             {
-                public class DefaultParameterElement : InjectionParameterElement, ITextValue {
+                public class DefaultParameterElement : InjectionParameterElement {
                     public string Value {
                         get { return null; }
                     }
                     public override void Visit(InjectionValueBuilder builder) {
-                        builder.Visit(this);
+                        var type = builder.ResolveInjectedValueType(TypeName);
+                        builder.SetValue(type, Safe.CreateDefaultValue(type));
                     }
                 }
             }

Implab.ServiceHost/Unity/DependencyParameterElement.cs +3 -2

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class DependencyParameterElement : InjectionParameterElement, IDependencyReference {
+                public class DependencyParameterElement : InjectionParameterElement {
                     [XmlAttribute("name")]
                     public string DependencyName { get; set; }
                     [XmlAttribute("optional")]
                     public bool Optional { get; set; }
                     public override  void Visit(InjectionValueBuilder builder) {
-                        builder.Visit(this);
+                        var type = builder.ResolveInjectedValueType(TypeName);
+                        builder.SetDependencyReference(type, DependencyName, Optional);
                     }
                 }
             }

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

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

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("include", Namespace = Schema.ContainerConfigurationNamespace)]
-                public class IncludeElement : ContainerItemElement {
+                public class IncludeElement : AbstractContainerItem {
                     [XmlAttribute("href")]
                     public string Href { get; set; }
                     public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

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

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

Implab.ServiceHost/Unity/InjectionValueBuilder.cs +45 -20

             using System;
+            using System.Collections.Generic;
             using System.ComponentModel;
+            using System.Linq;
             using System.Xml.Serialization;
             using Unity.Injection;
             namespace Implab.ServiceHost.Unity {
                 public class InjectionValueBuilder {
                     readonly TypeResolver m_resolver;
                     public Type DefaultType { get; private set; }
-                    public Type ValueType { get; set; }
+                    public Type ValueType { get; private set; }
                     public object Value { get; set; }
-                    public InjectionParameterValue Injection {
+                    internal InjectionParameterValue Injection {
                         get {
                             if (Value != null)
                                 return InjectionParameterValue.ToParameter(Value);
                             return new InjectionParameter(ValueType, null);
                         }
                     }
-                    internal InjectionValueBuilder(TypeResolver resolver, Type acceptsType) {
+                    internal InjectionValueBuilder(TypeResolver resolver, Type defaultType) {
                         m_resolver = resolver;
-                        DefaultType = acceptsType;
+                        DefaultType = defaultType;
                     }
-                    public Type ResolveType(string typeSpec) {
+                    public Type ResolveInjectedValueType(string typeSpec) {
                         if (string.IsNullOrEmpty(typeSpec)) {
                             if (DefaultType == null)
                                 throw new Exception("The type must be specified");
                             return DefaultType;
                         }
                         return m_resolver.Resolve(typeSpec);
                     }
-                    public void Visit(ITextValue value) {
+                    public Type ResolveType(string typeSpec) {
-                        ValueType = ResolveType(value.TypeName);
+                        return m_resolver.Resolve(typeSpec);
+                    }
-                        Value = string.IsNullOrEmpty(value.Value) ?
+                    public void SetValue(Type type, object value) {
-                            Safe.CreateDefaultValue(ValueType) :
+                        ValueType = type;
-                            TypeDescriptor.GetConverter(ValueType).ConvertFromString(value.Value);
+                        Value = value;
+                    }
+                    public void SetValue<T>(T value) {
+                        SetValue(typeof(T), value);
+                    }
+                    public void SetDependencyReference(Type type, string name, bool optional) {
+                        ValueType = type;
+                        Value = optional ? (object)new OptionalParameter(type, name) : new ResolvedParameter(type, name);
                     }
-                    public void Visit(ISerializedValue value) {
+                    internal void Visit(ArrayParameterElement arrayParameter) {
-                        ValueType = ResolveType(value.TypeName);
+                        Type itemsType = null;
+                        var arrayType = string.IsNullOrEmpty(arrayParameter.TypeName) ? null : ResolveType(arrayParameter.TypeName);
-                        var serializer = new XmlSerializer(ValueType);
+                        if (!string.IsNullOrEmpty(arrayParameter.ItemsType)) {
+                            itemsType = ResolveType(arrayParameter.ItemsType);
-                        using (var reader = value.GetReader())
+                            if (arrayType == null)
-                            Value = new InjectionParameter(ValueType, serializer.Deserialize(reader));
+                                arrayType = itemsType.MakeArrayType();
+                        } else {
+                            itemsType = arrayType?.GetInterface(typeof(IEnumerable<>).FullName)?.GetGenericArguments()[0];
                         }
-                    public void Visit(IDependencyReference value) {
+                        if (itemsType == null)
-                        ValueType = ResolveType(value.TypeName);
+                            throw new Exception("Failed to determine array elements type");
-                        Value = new ResolvedParameter(ValueType, value.DependencyName);
+                        InjectionParameterValue[] injections = (arrayParameter.Items ?? new InjectionParameterElement[0])
+                            .Select(x => {
+                                var builder = new InjectionValueBuilder(m_resolver, itemsType);
+                                x.Visit(builder);
+                                return builder.Injection;
+                            })
+                            .ToArray();
+                        var array = itemsType.IsGenericParameter ? (object)new GenericResolvedArrayParameter(itemsType.Name, injections) : new ResolvedArrayParameter(itemsType, injections);
+                        ValueType = arrayType;
+                        Value = array;
                     }
                 }
             }

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

@@ -1,10 +1,5
1	using Unity.Lifetime;	1	namespace Implab.ServiceHost.Unity {
2		2	public abstract class LifetimeElement {
3	namespace Implab.ServiceHost.Unity	3	public abstract void Visit(RegistrationBuilder builder);
4	{
5	public abstract class LifetimeElement
6	{
7	public abstract LifetimeManager GetLifetimeManager(ContainerBuilder ctx);
8
9	}	4	}
10	} No newline at end of file	5	}

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class MethodInjectionElement : AbstractInjectionElement {
+                public class MethodInjectionElement : AbstractMemberInjection {
                     [XmlAttribute("name")]
                     public string Name { get; set; }
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
+                    [XmlElement("array", typeof(ArrayParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
                     internal override void Visit(TypeRegistrationBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
                 [XmlRoot("namespace", Namespace = Schema.ContainerConfigurationNamespace)]
-                public class NamespaceElement : ContainerItemElement {
+                public class NamespaceElement : AbstractContainerItem {
                     [XmlAttribute("name")]
                     public string Name { get; set; }
                     public override void Visit(ContainerBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class PropertyInjectionElement : AbstractInjectionElement {
+                public class PropertyInjectionElement : AbstractMemberInjection {
                     [XmlAttribute("name")]
                     public string Name { get; set; }
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
+                    [XmlElement("array", typeof(ArrayParameterElement))]
                     public InjectionParameterElement Value { get; set; }
                     internal override void Visit(TypeRegistrationBuilder context) {
                         context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/RegisterElement.cs +12 -4

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

Implab.ServiceHost/Unity/RegistrationBuilder.cs +22 0

             using System;
             using System.Collections.Generic;
             using System.ComponentModel;
             using System.Linq;
             using System.Xml.Serialization;
             using Implab.Xml;
             using Unity.Injection;
+            using Unity.Lifetime;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity {
+                /// <summary>
+                /// Базовый класс для формирования записей в контейнере, созволяет указать время жизни для записи
+                /// </summary>
                 public abstract class RegistrationBuilder {
                     public Type RegistrationType {
                         get;
                         private set;
                     }
+                    internal LifetimeManager Lifetime { get; set; }
                     protected RegistrationBuilder(Type registrationType) {
                         RegistrationType = registrationType;
                     }
+                    internal void Visit(SingletonLifetimeElement simgletonLifetime) {
+                        Lifetime = new SingletonLifetimeManager();
+                    }
+                    internal void Visit(ContainerLifetimeElement containerLifetime) {
+                        Lifetime = new ContainerControlledLifetimeManager();
+                    }
+                    internal void Visit(HierarchicalLifetimeElement hierarchicalLifetime) {
+                        Lifetime = new HierarchicalLifetimeManager();
+                    }
+                    internal void Visist(ContextLifetimeElement contextLifetime) {
+                        Lifetime = new PerResolveLifetimeManager();
+                    }
                 }
             }

Implab.ServiceHost/Unity/SerializedElement.cs +9 -23

             using System;
             using System.Xml;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
-                public class SerializedElement : AbstractRegistration, ISerializedValue {
+                public class SerializedElement : InstanceAbstractRegistration {
                     [XmlAttribute("href")]
                     public string Location { get; set; }
                     [XmlAttribute("serializedType")]
                     public string SerializedType { get; set; }
                     [XmlAnyElement]
                     public XmlElement[] Content { get; set; }
-                    string ISerializedValue.TypeName {
+                    public override void Visit(InstanceRegistrationBuilder builder) {
-                        get {
+                        base.Visit(builder);
-                            return string.IsNullOrEmpty(SerializedType) ? RegistrationType : SerializedType;
-                    public string TypeName => throw new NotImplementedException();
-                    public override void Visit(ContainerBuilder context) {
-                        context.Visit(this);
-                    public XmlReader GetReader() {
+                        var parameter = new SerializedParameterElement {
-                        if (!string.IsNullOrEmpty(Location))
+                            TypeName = SerializedType,
-                            return XmlReader.Create(Location);
+                            Location = Location,
-                        if (Content != null && Content.Length > 0)
+                            Content = Content
-                            return Content[0].CreateNavigator().ReadSubtree();
+                        };
+                        parameter.Visit(builder.ValueBuilder);
-                        throw new Exception("No content found, expected XML document");
-                    public void Visit(InjectionValueBuilder builder) {
-                        throw new NotImplementedException();
                     }
                 }
             }

Implab.ServiceHost/Unity/SerializedParameterElement.cs +7 -2

             using System;
             using System.Xml;
             using System.Xml.Schema;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
-                public class SerializedParameterElement : InjectionParameterElement, ISerializedValue {
+                public class SerializedParameterElement : InjectionParameterElement {
                     [XmlAttribute("href")]
                     public string Location { get; set; }
                     [XmlAnyElement]
                     public XmlElement[] Content { get; set; }
                     public XmlReader GetReader() {
                         if (!string.IsNullOrEmpty(Location))
                             return XmlReader.Create(Location);
                         if (Content != null && Content.Length > 0)
                             return Content[0].CreateNavigator().ReadSubtree();
                         throw new Exception("No content found, expected XML document");
                     }
                     public override void Visit(InjectionValueBuilder builder) {
-                        builder.Visit(this);
+                        var type = builder.ResolveInjectedValueType(TypeName);
+                        var serializer = new XmlSerializer(type);
+                        using(var reader = GetReader())
+                            builder.SetValue(type, serializer.Deserialize(reader));
                     }
                 }
             }

Implab.ServiceHost/Unity/SingletonLifetimeElement.cs ~~Implab.ServiceHost/Unity/SimgletonLifetimeElement.cs~~ renamed +3 -5

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

Implab.ServiceHost/Unity/TypeReferenceParser.cs +16 -2

             using System;
             using System.Collections.Generic;
             using System.Text.RegularExpressions;
             namespace Implab.ServiceHost.Unity {
                 internal class TypeReferenceParser {
                     enum TokenType {
                         None,
                         Word,
                         Dot,
                         Comma,
                         OpenList,
                         CloseList,
+                        OpenArray,
+                        CloseArray,
                         Eof
                     }
-                    readonly Regex _tokens = new Regex(@"([\w\+]+)|\s*([\.{},])\s*");
+                    readonly Regex _tokens = new Regex(@"([\w\+]+)|\s*([\.{},\[\]])\s*");
                     TokenType m_token;
                     string m_tokenValue;
                     int m_pos;
                     int m_tokenPos;
                     readonly string m_text;
                     TokenType Token { get { return m_token; } }
                     string TokenValue { get { return m_tokenValue; } }
                     int TokenPos { get { return m_tokenPos; } }
                     public TypeReferenceParser(string text) {
                         Safe.ArgumentNotEmpty(text, nameof(text));
                         m_text = text;
                     }
                     bool ReadToken() {
                         if (m_pos >= m_text.Length) {
                             m_token = TokenType.Eof;
                             m_tokenValue = null;
                             return false;
                         }
                         var m = _tokens.Match(m_text, m_pos);
                         if (m.Success) {
                             m_tokenPos = m_pos;
                             m_pos += m.Length;
                             if (m.Groups[1].Success) {
                                 m_token = TokenType.Word;
                                 m_tokenValue = m.Groups[1].Value;
                             } else if (m.Groups[2].Success) {
                                 m_tokenValue = null;
                                 switch (m.Groups[2].Value) {
                                     case "{":
                                         m_token = TokenType.OpenList;
                                         break;
                                     case "}":
                                         m_token = TokenType.CloseList;
                                         break;
                                     case ".":
                                         m_token = TokenType.Dot;
                                         break;
                                     case ",":
                                         m_token = TokenType.Comma;
                                         break;
+                                    case "[":
+                                        m_token = TokenType.OpenArray;
+                                        break;
+                                    case "]":
+                                        m_token = TokenType.CloseArray;
+                                        break;
                                 }
                             }
                             return true;
                         }
                         throw new FormatException($"Failed to parse '{m_text}' at pos {m_pos}");
                     }
                     public TypeReference Parse() {
                         var result = ReadTypeReference();
-                        if (ReadToken())
+                        if (Token != TokenType.Eof)
                             ThrowUnexpectedToken();
                         return result;
                     }
                     string[] ReadTypeName() {
                         var parts = new List<string>();
                         string current = null;
                         bool stop = false;
                         while ((!stop) && ReadToken()) {
                             switch (Token) {
                                 case TokenType.Word:
                                     if (current != null)
                                         ThrowUnexpectedToken();
                                     current = TokenValue;
                                     break;
                                 case TokenType.Dot:
                                     if (current == null)
                                         ThrowUnexpectedToken();
                                     parts.Add(current);
                                     current = null;
                                     break;
                                 default:
                                     stop = true;
                                     break;
                             }
                         }
                         if (current != null)
                             parts.Add(current);
                         if (parts.Count == 0)
                             return null;
                         return parts.ToArray();
                     }
                     TypeReference ReadTypeReference() {
                         var parts = ReadTypeName();
                         if (parts == null)
                             return null;
                         var typeReference = new TypeReference {
                             Namespace = string.Join(".", parts, 0, parts.Length - 1),
                             TypeName = parts[parts.Length - 1]
                         };
                         switch (Token) {
                             case TokenType.OpenList:
                                 typeReference.GenericParameters = ReadTypeReferenceList();
                                 if (Token != TokenType.CloseList)
                                     ThrowUnexpectedToken();
                                 ReadToken();
                                 break;
                         }
                         return typeReference;
                     }
+                    int CountDimentions() {
+                        return 0;
+                    }
                     TypeReference[] ReadTypeReferenceList() {
                         var list = new List<TypeReference>();
                         do {
                             var typeReference = ReadTypeReference();
                             list.Add(typeReference);
                         } while (Token == TokenType.Comma);
                         return list.ToArray();
                     }
                     void ThrowUnexpectedToken() {
                         throw new FormatException($"Unexpected '{Token}' at pos {TokenPos}: -->{m_text.Substring(TokenPos, Math.Min(m_text.Length - TokenPos, 10))}");
                     }
                 }
             }

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

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using Unity.Injection;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity {
                 public class TypeRegistrationBuilder : RegistrationBuilder {
                     readonly TypeResolver m_resolver;
                     readonly List<InjectionMember> m_injections = new List<InjectionMember>();
-                    public InjectionMember[] Injections { get { return m_injections.ToArray(); } }
+                    internal InjectionMember[] Injections { get { return m_injections.ToArray(); } }
                     public Type ImplementationType {
                         get;
                         private set;
                     }
                     internal TypeRegistrationBuilder(TypeResolver resolver, Type registrationType, Type implementationType) : base(registrationType) {
                         ImplementationType = implementationType;
                         // when registering a generic mapping, register all generic parameter names as local types
                         if (ImplementationType.IsGenericTypeDefinition) {
                             m_resolver = new TypeResolver(resolver);
                             foreach (var p in ImplementationType.GetGenericArguments())
                                 m_resolver.AddMapping(p.Name, p);
                         } else {
                             m_resolver = resolver;
                         }
                     }
                     internal void Visit(ConstructorInjectionElement constructorInjection) {
                         var parameters = constructorInjection.Parameters?
                             .Select(x => {
                                 var valueBuilder = new InjectionValueBuilder(m_resolver, null);
                                 x.Visit(valueBuilder);
                                 return valueBuilder.Injection;
                             })
                             .ToArray();
                         var injection = parameters != null ? new InjectionConstructor(parameters) : new InjectionConstructor();
                         m_injections.Add(injection);
                     }
                     internal void Visit(MethodInjectionElement methodInjection) {
                         var valueContext = new InjectionValueBuilder(m_resolver, null);
                         var parameters = methodInjection.Parameters?
                             .Select(x => {
                                 var valueBuilder = new InjectionValueBuilder(m_resolver, null);
                                 x.Visit(valueBuilder);
                                 return valueBuilder.Injection;
                             })
                             .ToArray();
                         var injection = parameters != null ? new InjectionMethod(methodInjection.Name, parameters) : new InjectionMethod(methodInjection.Name);
                         m_injections.Add(injection);
                     }
                     internal void Visit(PropertyInjectionElement propertyInjection) {
                         if (propertyInjection.Value == null)
                             throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
                         var propertyType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
                         var valueContext = new InjectionValueBuilder(m_resolver, propertyType);
                         propertyInjection.Value.Visit(valueContext);
                         var injection = new InjectionProperty(propertyInjection.Name, valueContext.Injection);
                         m_injections.Add(injection);
                     }
                 }
             }

Implab.ServiceHost/Unity/TypeResolver.cs +12 -16

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using Implab.Diagnostics;
-            namespace Implab.ServiceHost.Unity
+            namespace Implab.ServiceHost.Unity {
                 using static Trace<TypeResolver>;
-                public class TypeResolver
+                public class TypeResolver {
                     readonly Dictionary<string, Type> m_cache = new Dictionary<string, Type>();
                     Regex _nsRx = new Regex(@"^\w+(\.\w+)*$", RegexOptions.Compiled);
                     readonly LinkedList<string> m_namespases = new LinkedList<string>();
                     LinkedListNode<string> m_insertAt;
                     readonly TypeResolver m_parent;
                     public TypeResolver() : this(null) {
                     }
                     public TypeResolver(TypeResolver parent) {
                         m_parent = parent;
                         m_insertAt = new LinkedListNode<string>(string.Empty);
                         m_namespases.AddFirst(m_insertAt);
                     }
                     public void AddNamespace(string ns) {
                         Safe.ArgumentMatch(ns, nameof(ns), _nsRx);
                         if (m_insertAt != null)
                             m_namespases.AddAfter(m_insertAt, ns);
                         else
                             m_namespases.AddFirst(ns);
                     }
                     public void AddMapping(string typeName, Type type) {
                         Safe.ArgumentNotEmpty(typeName, nameof(typeName));
                         Safe.ArgumentNotNull(type, nameof(type));
                         m_cache[typeName] = type;
                     }
                     public Type Resolve(TypeReference reference) {
                         var args = reference.IsGeneric && !reference.IsOpenGeneric ? reference.GenericParameters?.Select(Resolve).ToArray() : null;
                         var argc = reference.IsGeneric ? reference.GenericParameters.Length : 0;
                         Type resolved;
                         if (!m_cache.TryGetValue(reference.ToString(), out resolved)) {
                             resolved = ResolveInternal(reference, args, argc);
                             if (resolved == null)
                                 throw new Exception($"Failed to resolve {reference}");
                             m_cache[reference.ToString()] = resolved;
                         }
                         return resolved;
                     }
                     public Type Resolve(string typeSpec) {
                         return Resolve(TypeReference.Parse(typeSpec));
                     }
                     Type ResolveInternal(TypeReference reference, Type[] args, int argc) {
                         var resolved = ProbeInNamespaces(
                             String.Join(".", new[] { reference.Namespace, reference.TypeName }.Where(x => !string.IsNullOrEmpty(x))),
                             args,
                             argc,
                             reference.IsArray,
                             reference.ToString()
                         );
                         if (resolved == null && m_parent != null)
-                            resolved = m_parent.Resolve(reference);
+                            resolved = m_parent.ResolveInternal(reference, args, argc);
                         return resolved;
                     }
                     public Type ProbeInNamespaces(string localName, Type[] args, int argc, bool isArray, string referenceName) {
                         foreach (var ns in m_namespases) {
-                            var typeName = FormatName(new [] { ns, localName}, argc, args, isArray);
+                            var typeName = FormatName(new[] { ns, localName }, argc);
                             var resolved = Probe(typeName);
                             if (resolved != null) {
+                                if (args != null && args.Length > 0) {
+                                    resolved = resolved.MakeGenericType(args);
+                                }
+                                if (isArray)
+                                    resolved = resolved.MakeArrayType();
                                 Log("Probe succeed {0} in '{1}': {2} -> {3}", referenceName, ns, typeName, resolved.AssemblyQualifiedName);
                                 return resolved;
                             } else {
                                 Log("Probe failed {0} in '{1}': {2}", referenceName, ns, typeName);
                             }
                         }
                         return null;
                     }
                     Type Probe(string typeName) {
                         var assemblies = AppDomain.CurrentDomain.GetAssemblies();
                         foreach (var assembly in assemblies) {
                             var type = assembly.GetType(typeName);
                             if (type != null)
                                 return type;
                         }
                         return null;
                     }
-                    string FormatName(string[] parts, int argc, Type[] args, bool isArray) {
+                    string FormatName(string[] parts, int argc) {
                         var builder = new StringBuilder();
                         builder.Append(String.Join(".", parts.Where(x => !string.IsNullOrEmpty(x))));
                         if (argc > 0) {
                             builder.Append('`');
                             builder.Append(argc);
                         }
-                        if (args!= null && args.Length > 0) {
-                            builder.Append('[');
-                            builder.Append(string.Join(",", args.Select(x => $"[{x.AssemblyQualifiedName}]")));
-                            builder.Append(']');
-                        if(isArray)
-                            builder.Append("[]");
                         return builder.ToString();
                     }
                 }
             }

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class ValueElement : AbstractRegistration, ITextValue {
+                public class ValueElement : InstanceAbstractRegistration {
                     [XmlAttribute("value")]
                     public string Value { get; set; }
                     [XmlText]
                     public string Text { get; set; }
-                    string ITextValue.Value {
+                    string GetTextValue() {
-                        get {
                         return string.IsNullOrEmpty(Value) ? Text : Value;
                     }
                     public string TypeName {
                         get {
                             return RegistrationType;
                         }
                     }
-                    public override void Visit(ContainerBuilder context) {
+                    public override void Visit(InstanceRegistrationBuilder builder) {
-                        context.Visit(this);
+                        base.Visit(builder);
+                        var parameter = new ValueParameterElement {
+                            Value = Value,
+                            Text = Text
+                        };
+                        parameter.Visit(builder.ValueBuilder);
                     }
                 }
             }

Implab.ServiceHost/Unity/ValueParameterElement.cs +11 -3

+            using System.ComponentModel;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class ValueParameterElement : InjectionParameterElement, ITextValue {
+                public class ValueParameterElement : InjectionParameterElement {
-                    [XmlText]
                     [XmlAttribute("value")]
                     public string Value { get; set; }
+                    [XmlText]
+                    public string Text { get; set; }
+                    string GetTextValue() {
+                        return string.IsNullOrEmpty(Value) ? Text : Value;
+                    }
                     public override void Visit(InjectionValueBuilder builder) {
-                        builder.Visit(this);
+                        var type = builder.ResolveInjectedValueType(TypeName);
+                        builder.SetValue(type, TypeDescriptor.GetConverter(type).ConvertFromString(GetTextValue()));
                     }
                 }
             }

Implab.ServiceHost/docs/XmlConfiguration.md ~~Implab.ServiceHost/Unity/readme.md~~ renamed 0 0

NO CONTENT: file renamed from Implab.ServiceHost/Unity/readme.md to Implab.ServiceHost/docs/XmlConfiguration.md

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

NO CONTENT: file was removed

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

NO CONTENT: file was removed

Implab.ServiceHost/Unity/IDependencyReference.cs removed 0 -10

NO CONTENT: file was removed

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

NO CONTENT: file was removed

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

NO CONTENT: file was removed

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

NO CONTENT: file was removed

Implab.ServiceHost/Unity/ITextValue.cs removed 0 -9

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