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 +23 -4

             using System;
+            using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using Implab.Diagnostics;
                     public string StringValue { get; set; }
+                    public void AddRange(Foo[] items) {
+                        Console.WriteLine($"AddRange: Foo[]");
+                    }
                 }
                 public interface IContainer<T> {
                     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);

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>
                 <register type="Foo">
+                    <method name="AddRange">
+                        <array itemsType="Foo">
+                            <dependency name="foo2"/>
+                        </array>
+                    </method>
                 </register>
                 <register type="IContainer{}" mapTo="Container{}">
                     <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}">
                 <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

                 /// <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

             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
                         get; set;
                     }
-                    [XmlElement("signleton", typeof(SimgletonLifetimeElement))]
+                    [XmlElement("signleton", typeof(SingletonLifetimeElement))]
                     [XmlElement("context", typeof(ContextLifetimeElement))]
                     [XmlElement("container", typeof(ContainerLifetimeElement))]
                     [XmlElement("hierarchy", typeof(HierarchicalLifetimeElement))]
                     [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

             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) {

Implab.ServiceHost/Unity/ContainerBuilder.cs +31 -38

                         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,
                             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);
+                        var builder = new InstanceRegistrationBuilder(m_resolver, registrationType);
-                        valueBuilder.Visit(serializedElement);
+                        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);
+                        var builder = new FactoryRegistrationBuilder(registrationType);
-                        valueBuilder.Visit(valueElement);
+                        factoryRgistration.Visit(builder);
-                        m_container.RegisterInstance(
+                        m_container.RegisterType(
-                            registrationType,
+                            builder.RegistrationType,
-                            valueElement.Name,
+                            factoryRgistration.Name,
-                            valueBuilder.Value,
+                            builder.Lifetime,
-                            valueElement.Lifetime?.GetLifetimeManager(this)
+                            builder.Factory
                         );
                     }
                     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

                         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);
                     }

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

             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

             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

             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; }
                     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

             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

             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("include", Namespace = Schema.ContainerConfigurationNamespace)]
-                public class IncludeElement : ContainerItemElement {
+                public class IncludeElement : AbstractContainerItem {
                     [XmlAttribute("href")]
                     public string Href { get; set; }

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

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

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;
                     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);
                         }
                     }
-                    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 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);
+                            if (arrayType == null)
+                                arrayType = itemsType.MakeArrayType();
+                        } else {
+                            itemsType = arrayType?.GetInterface(typeof(IEnumerable<>).FullName)?.GetGenericArguments()[0];
+                        }
-                        using (var reader = value.GetReader())
+                        if (itemsType == null)
-                            Value = new InjectionParameter(ValueType, serializer.Deserialize(reader));
+                            throw new Exception("Failed to determine array elements type");
-                    public void Visit(IDependencyReference value) {
+                        InjectionParameterValue[] injections = (arrayParameter.Items ?? new InjectionParameterElement[0])
-                        ValueType = ResolveType(value.TypeName);
+                            .Select(x => {
-                        Value = new ResolvedParameter(ValueType, value.DependencyName);
+                                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("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) {

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

             namespace Implab.ServiceHost.Unity
             {
                 [XmlRoot("namespace", Namespace = Schema.ContainerConfigurationNamespace)]
-                public class NamespaceElement : ContainerItemElement {
+                public class NamespaceElement : AbstractContainerItem {
                     [XmlAttribute("name")]
                     public string Name { get; set; }

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("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) {

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

             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">.
                     [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.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

@@ -4,7 +4,7 using System.Xml.Serialization;
4		4
5	namespace Implab.ServiceHost.Unity	5	namespace Implab.ServiceHost.Unity
6	{	6	{
7	public class SerializedElement : AbstractRegistration, ~~ISerializedValue~~ {	7	public class SerializedElement : InstanceAbstractRegistration {
8	[XmlAttribute("href")]	8	[XmlAttribute("href")]
9	public string Location { get; set; }	9	public string Location { get; set; }
10		10
@@ -15,29 +15,15 namespace Implab.ServiceHost.Unity
15	[XmlAnyElement]	15	[XmlAnyElement]
16	public XmlElement[] Content { get; set; }	16	public XmlElement[] Content { get; set; }
17		17
18	string ISerializedValue.TypeName {	18	public override void Visit(InstanceRegistrationBuilder builder) {
19	get {	19	base.Visit(builder);
20	return string.IsNullOrEmpty(SerializedType) ? RegistrationType : SerializedType;
21	}
22	}
23
24	public string TypeName => throw new NotImplementedException();
25
26	public override void Visit(ContainerBuilder context) {
27	context.Visit(this);
28	}
29		20
30	public XmlReader GetReader() {	21	var parameter = new SerializedParameterElement {
31	if (!string.IsNullOrEmpty(Location))	22	TypeName = SerializedType,
32	return XmlReader.Create(Location);	23	Location = Location,
33	if (Content != ~~null~~ && Content.~~Length~~ > 0)	24	Content = Content
34	return Content[0].CreateNavigator().ReadSubtree();	25	};
35		26	parameter.Visit(builder.ValueBuilder);
36	throw new Exception("No content found, expected XML document");
37	}
38
39	public void Visit(InjectionValueBuilder builder) {
40	throw new NotImplementedException();
41	}	27	}
42	}	28	}
43	} No newline at end of file	29	}

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

             namespace Implab.ServiceHost.Unity
             {
-                public class SerializedParameterElement : InjectionParameterElement, ISerializedValue {
+                public class SerializedParameterElement : InjectionParameterElement {
                     [XmlAttribute("href")]
                     public string Location { get; set; }
                     }
                     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

                         CloseList,
+                        OpenArray,
+                        CloseArray,
                         Eof
                     }
-                    readonly Regex _tokens = new Regex(@"([\w\+]+)|\s*([\.{},])\s*");
+                    readonly Regex _tokens = new Regex(@"([\w\+]+)|\s*([\.{},\[\]])\s*");
                     TokenType m_token;
                                     case ",":
                                         m_token = TokenType.Comma;
                                         break;
+                                    case "[":
+                                        m_token = TokenType.OpenArray;
+                                        break;
+                                    case "]":
+                                        m_token = TokenType.CloseArray;
+                                        break;
                                 }
                             }
                             return true;
                     public TypeReference Parse() {
                         var result = ReadTypeReference();
-                        if (ReadToken())
+                        if (Token != TokenType.Eof)
                             ThrowUnexpectedToken();
                         return result;
                     }
                         return typeReference;
                     }
+                    int CountDimentions() {
+                        return 0;
+                    }
                     TypeReference[] ReadTypeReferenceList() {
                         var list = new List<TypeReference>();

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

                     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;

Implab.ServiceHost/Unity/TypeResolver.cs +18 -22

             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);
                         var argc = reference.IsGeneric ? reference.GenericParameters.Length : 0;
                         Type resolved;
-                        if(!m_cache.TryGetValue(reference.ToString(), out resolved)) {
+                        if (!m_cache.TryGetValue(reference.ToString(), out resolved)) {
                             resolved = ResolveInternal(reference, args, argc);
                             if (resolved == null)
                                 throw new Exception($"Failed to resolve {reference}");
                     Type ResolveInternal(TypeReference reference, Type[] args, int argc) {
                         var resolved = ProbeInNamespaces(
-                            String.Join(".", new [] { reference.Namespace, reference.TypeName }.Where(x => !string.IsNullOrEmpty(x)) ),
+                            String.Join(".", new[] { reference.Namespace, reference.TypeName }.Where(x => !string.IsNullOrEmpty(x))),
                             args,
                             argc,
                             reference.IsArray,
                         );
                         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 {
                     Type Probe(string typeName) {
                         var assemblies = AppDomain.CurrentDomain.GetAssemblies();
-                        foreach(var assembly in assemblies) {
+                        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) {
+                        return builder.ToString();
-                            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 +10 -7

             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;
-                            return string.IsNullOrEmpty(Value) ? Text : Value;
                     }
                     public string TypeName {
                         }
                     }
-                    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