implab/ImplabNet Commit - r272:9d1cca834b05

preview version of Unity xml configuration

cin -

r272:9d1cca834b05 v3

parent child

Context file:

r272:9d1cca834b05

Collapse all files

Implab.ServiceHost/Unity/RegistrationContext.cs created 644 +119 0

@@ -0,0 +1,119
	1	using System;
	2	using System.Collections.Generic;
	3	using System.ComponentModel;
	4	using System.Linq;
	5	using System.Xml.Serialization;
	6	using Implab.Xml;
	7	using Unity.Injection;
	8	using Unity.Registration;
	9
	10	namespace Implab.ServiceHost.Unity {
	11	class RegistrationContext {
	12	readonly TypeResolver m_resolver;
	13
	14	List<InjectionMember> m_injections = new List<InjectionMember>();
	15
	16	Type m_defaultType;
	17
	18	public Type RegistrationType {
	19	get;
	20	private set;
	21	}
	22
	23	public Type ImplementationType {
	24	get;
	25	private set;
	26	}
	27
	28	public RegistrationContext(TypeResolver resolver, string typeSpec, string implSpec) {
	29	RegistrationType = resolver.Resolve(string.IsNullOrEmpty(typeSpec) ? implSpec : typeSpec);
	30
	31
	32	ImplementationType = string.IsNullOrEmpty(implSpec) ? RegistrationType : resolver.Resolve(implSpec);
	33
	34	if (RegistrationType.IsGenericTypeDefinition) {
	35	m_resolver = new TypeResolver(resolver);
	36
	37	foreach (var p in ImplementationType.GetGenericArguments())
	38	m_resolver.AddMapping(p.Name, p);
	39	} else {
	40	m_resolver = resolver;
	41	}
	42
	43
	44	}
	45
	46	public InjectionMember[] Injections {
	47	get {
	48	return m_injections.ToArray();
	49	}
	50	}
	51
	52	public void Visit(ConstructorInjectionElement constructorInjection) {
	53	var parameters = constructorInjection.Parameters?.Select(x => x.Resolve(this)).ToArray();
	54
	55	var injection = parameters != null ? new InjectionConstructor(parameters) : new InjectionConstructor();
	56	m_injections.Add(injection);
	57	}
	58
	59	public void Visit(MethodInjectionElement methodInjection) {
	60	var parameters = methodInjection.Parameters?.Select(x => x.Resolve(this)).ToArray();
	61
	62	var injection = parameters != null ? new InjectionMethod(methodInjection.Name, parameters) : new InjectionMethod(methodInjection.Name);
	63	m_injections.Add(injection);
	64	}
	65
	66	public void Visit(PropertyInjectionElement propertyInjection) {
	67	if (propertyInjection.Value == null)
	68	throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
	69
	70	try {
	71	m_defaultType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
	72
	73	var parameter = propertyInjection.Value.Resolve(this);
	74	var injection = new InjectionProperty(propertyInjection.Name, parameter);
	75	m_injections.Add(injection);
	76
	77	} finally {
	78	m_defaultType = null;
	79	}
	80
	81	}
	82
	83	Type ResolveParameterType(InjectionParameterElement injectionParameter) {
	84	if (string.IsNullOrEmpty(injectionParameter.TypeName)) {
	85	if (m_defaultType == null)
	86	throw new Exception($"A type must be specified for the parameter {injectionParameter}");
	87	return m_defaultType;
	88	}
	89	return m_resolver.Resolve(injectionParameter.TypeName);
	90	}
	91
	92	public object Resolve(DefaultParameterElement defaultParameter) {
	93	var type = ResolveParameterType(defaultParameter);
	94
	95	return Safe.CreateDefaultValue(type);
	96	}
	97
	98	public object Resolve(ValueParameterElement valueParameter) {
	99	var type = ResolveParameterType(valueParameter);
	100
	101	return TypeDescriptor.GetConverter(type).ConvertFromString(valueParameter.Value);
	102	}
	103
	104	public object Resolve(SerializedParameterElement serializedParameter) {
	105	var type = ResolveParameterType(serializedParameter);
	106	if (serializedParameter.Content == null \|\| serializedParameter.Content.Length == 0)
	107	return Safe.CreateDefaultValue(type);
	108
	109	var serializer = new XmlSerializer(type);
	110	using (var reader = serializedParameter.Content[0].CreateNavigator().ReadSubtree())
	111	return serializer.Deserialize(reader);
	112	}
	113
	114	public InjectionParameterValue Resolve(DependencyParameterElement dependencyParameter) {
	115	var type = ResolveParameterType(dependencyParameter);
	116	return new ResolvedParameter(type, dependencyParameter.DependencyName);
	117	}
	118	}
	119	} No newline at end of file

Implab.Playground/Program.cs +30 -2

             using System;
             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 Container<T> {
+                public interface IContainer<T> {
+                    T Instance { get; set; }
+                }
+                public class Container<T> : IContainer<T> {
                     public Container() {
                     }
                         ctx.Visit(conf);
-                        Console.WriteLine($"Registrations: {conf.Items.Count}");
+                        DisplayContainerRegistrations(container);
+                        var instace1 = container.Resolve<IContainer<string>>();
+                        var instace2 = container.Resolve<IContainer<Foo>>();
+                    }
+                    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 +8 -6

             <?xml version="1.0" encoding="UTF-8"?>
             <container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
+                <namespace name="System"/>
                 <namespace name="Implab.Playground"/>
                 <!-- foo1 -->
                 <register name="foo1" type="Foo">
                     <property name="Name">
                 <register type="Foo">
                 </register>
-                <register type="Container{}">
+                <register provides="IContainer{}" type="Container{}">
                     <constructor/>
                     <method name="SetInstance">
                         <dependency type="T"/>
                     </method>
                 </register>
-                <register type="Container{String}">
+                <register provides="IContainer{String}" type="Container{String}">
-                    <property name="Instance">
+                    <constructor/>
-                        <value>Hello!</value>
+                    <method name="SetInstance">
-                    </property>
+                        <value type="String">Hello!</value>
+                    </method>
                 </register>
             </container>

Implab.ServiceHost/Unity/AbstractInjectionElement.cs +4 -3

+            using System;
             namespace Implab.ServiceHost.Unity
             {
-                public abstract class AbstractInjectionElement
+                public abstract class AbstractInjectionElement {
+                    internal abstract void Visit(RegistrationContext context);
                 }
             }

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

                     [XmlAttribute("provides")]
                     public string ProvidesType { get; set; }
-                    public void Visit(ConfigurationContext context) {
+                    public abstract void Visit(ConfigurationContext context);
-                        context.Visit(this);
                 }
             }

Implab.ServiceHost/Unity/ConfigurationContext.cs +19 -5

                 using System.Reflection;
                 using System.Text;
                 using global::Unity;
+                using global::Unity.Registration;
                 using Implab.Xml;
                 using static Trace<ConfigurationContext>;
                     readonly TypeResolver m_resolver;
+                    readonly UnityContainer m_container;
-                    readonly UnityContainer m_container;
                     public ConfigurationContext(UnityContainer container) {
                         m_container = container ?? new UnityContainer();
                         m_resolver = new TypeResolver();
                         return m_resolver.Resolve(TypeReference.Parse(typeReference));
                     }
-                    internal void Visit(AbstractRegistration descriptor) {
+                    internal void Visit(RegisterElement descriptor) {
+                        var registrationContext = new RegistrationContext(m_resolver, descriptor.ProvidesType, descriptor.ImplementationType);
+                        if (descriptor.Injectors != null) {
+                            foreach (var injector in descriptor.Injectors) {
+                                injector.Visit(registrationContext);
+                            }
+                        }
+                        m_container.RegisterType(
+                            registrationContext.RegistrationType,
+                            registrationContext.ImplementationType,
+                            descriptor.Name,
+                            descriptor.Lifetime?.GetLifetimeManager(this),
+                            registrationContext.Injections
+                        );
                     }
                     internal void Visit(NamespaceElement namespaceElement) {

Implab.ServiceHost/Unity/ConstructorInjectionElement.cs +4 0

                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
+                    internal override void Visit(RegistrationContext context) {
+                        context.Visit(this);
+                    }
                 }
             }

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

             namespace Implab.ServiceHost.Unity
             {
-                public class DefaultParameterElement : InjectionParameterElement
+                public class DefaultParameterElement : InjectionParameterElement {
+                    internal override object Resolve(RegistrationContext context) {
+                        return context.Resolve(this);
+                    }
                 }
             }

Implab.ServiceHost/Unity/DependencyParameterElement.cs +14 -5

@@ -1,7 +1,16
1	namespace Implab.ServiceHost.Unity	1	using System.Xml.Serialization;
2	{	2
3	public class DependencyParameterElement : InjectionParameterElement	3	namespace Implab.ServiceHost.Unity {
4	{	4	public class DependencyParameterElement : InjectionParameterElement {
5		5
		6	[XmlAttribute("name")]
		7	public string DependencyName { get; set; }
		8
		9	[XmlAttribute("optional")]
		10	public bool Optional { get; set; }
		11
		12	internal override object Resolve(RegistrationContext context) {
		13	return context.Resolve(this);
		14	}
6	}	15	}
7	} No newline at end of file	16	}

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

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

Implab.ServiceHost/Unity/MethodInjectionElement.cs +3 0

                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
+                    internal override void Visit(RegistrationContext context) {
+                        context.Visit(this);
+                    }
                 }
             }

Implab.ServiceHost/Unity/PropertyInjectionElement.cs +7 0

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

Implab.ServiceHost/Unity/RegisterElement.cs +5 -1

                     /// An optional type which is registered as a service in the container, must be assignable to <see cref="ProvidesType">.
                     /// </summary>
                     [XmlAttribute("type")]
-                    public string ImplementedType { get; set; }
+                    public string ImplementationType { get; set; }
                     [XmlElement("constructor", typeof(ConstructorInjectionElement))]
                     [XmlElement("property", typeof(PropertyInjectionElement))]
                     [XmlElement("method", typeof(MethodInjectionElement))]
                     public AbstractInjectionElement[] Injectors { get; set; }
+                    public override void Visit(ConfigurationContext context) {
+                        context.Visit(this);
+                    }
                 }
             }

Implab.ServiceHost/Unity/SerializedParameterElement.cs +4 0

                     [XmlAnyElement]
                     public XmlElement[] Content { get; set; }
+                    internal override object Resolve(RegistrationContext context) {
+                        return context.Resolve(this);
+                    }
                 }
             }

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

                     }
                     public TypeResolver(TypeResolver parent) {
+                        m_parent = parent;
                         m_insertAt = new LinkedListNode<string>(string.Empty);
                         m_namespases.AddFirst(m_insertAt);
                     }
                         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)) ),

Implab.ServiceHost/Unity/ValueParameterElement.cs +8 -1

+            using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
                 public class ValueParameterElement : InjectionParameterElement
                 {
+                    [XmlText]
+                    public string Value { get; set; }
+                    internal override object Resolve(RegistrationContext context) {
+                        return context.Resolve(this);
+                    }
                 }
             }

Implab/Safe.cs +7 0

                             throw new ArgumentOutOfRangeException(paramName);
                     }
+                    public static object CreateDefaultValue(Type type) {
+                        if (type.IsValueType)
+                            return Activator.CreateInstance(type);
+                        return null;
+                    }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentInRange(bool condition, string paramName) {
                         if (!condition)

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