implab/ImplabNet Commit - r270:ade80d94dfb5

Working on Unity container xml configuration

cin -

r270:ade80d94dfb5 v3

parent child

Context file:

r270:ade80d94dfb5

Expand all files

Implab.ServiceHost/Unity/AbstractInjectionElement.cs created 644 +7 0

@@ -0,0 +1,7
	1	namespace Implab.ServiceHost.Unity
	2	{
	3	public abstract class AbstractInjectionElement
	4	{
	5
	6	}
	7	} No newline at end of file

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

@@ -0,0 +1,12
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public class ConstructorInjectionElement : AbstractInjectionElement {
	5
	6	[XmlElement("dependency", typeof(DependencyParameterElement))]
	7	[XmlElement("value", typeof(ValueParameterElement))]
	8	[XmlElement("serialized", typeof(SerializedParameterElement))]
	9	[XmlElement("default", typeof(DefaultParameterElement))]
	10	public InjectionParameterElement[] Parameters { get; set; }
	11	}
	12	} No newline at end of file

Implab.ServiceHost/Unity/DefaultParameterElement.cs created 644 +7 0

@@ -0,0 +1,7
	1	namespace Implab.ServiceHost.Unity
	2	{
	3	public class DefaultParameterElement : InjectionParameterElement
	4	{
	5
	6	}
	7	} No newline at end of file

Implab.ServiceHost/Unity/DependencyParameterElement.cs created 644 +7 0

@@ -0,0 +1,7
	1	namespace Implab.ServiceHost.Unity
	2	{
	3	public class DependencyParameterElement : InjectionParameterElement
	4	{
	5
	6	}
	7	} No newline at end of file

Implab.ServiceHost/Unity/InjectionParameterElement.cs created 644 +9 0

@@ -0,0 +1,9
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public class InjectionParameterElement {
	5
	6	[XmlAttribute("type")]
	7	public string TypeName { get; set; }
	8	}
	9	} No newline at end of file

Implab.ServiceHost/Unity/MethodInjectionElement.cs created 644 +16 0

@@ -0,0 +1,16
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public class MethodInjectionElement : AbstractInjectionElement {
	5
	6	[XmlAttribute("name")]
	7	public string Name { get; set; }
	8
	9	[XmlElement("dependency", typeof(DependencyParameterElement))]
	10	[XmlElement("value", typeof(ValueParameterElement))]
	11	[XmlElement("serialized", typeof(SerializedParameterElement))]
	12	[XmlElement("default", typeof(DefaultParameterElement))]
	13	public InjectionParameterElement[] Parameters { get; set; }
	14
	15	}
	16	} No newline at end of file

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

@@ -0,0 +1,12
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public class PropertyInjectionElement : AbstractInjectionElement {
	5
	6	[XmlElement("dependency", typeof(DependencyParameterElement))]
	7	[XmlElement("value", typeof(ValueParameterElement))]
	8	[XmlElement("serialized", typeof(SerializedParameterElement))]
	9	[XmlElement("default", typeof(DefaultParameterElement))]
	10	public InjectionParameterElement Value { get; set; }
	11	}
	12	} No newline at end of file

Implab.ServiceHost/Unity/SerializedParameterElement.cs created 644 +7 0

@@ -0,0 +1,7
	1	namespace Implab.ServiceHost.Unity
	2	{
	3	public class SerializedParameterElement : InjectionParameterElement
	4	{
	5
	6	}
	7	} No newline at end of file

Implab.ServiceHost/Unity/TypeResolver.cs created 644 +124 0

@@ -0,0 +1,124
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Text;
	5	using System.Text.RegularExpressions;
	6	using Implab.Diagnostics;
	7
	8	namespace Implab.ServiceHost.Unity
	9	{
	10	using static Trace<TypeResolver>;
	11	public class TypeResolver
	12	{
	13	readonly Dictionary<string, Type> m_cache = new Dictionary<string, Type>();
	14
	15	Regex _nsRx = new Regex(@"^\w+(\.\w+)*$", RegexOptions.Compiled);
	16	readonly LinkedList<string> m_namespases = new LinkedList<string>();
	17
	18	LinkedListNode<string> m_insertAt;
	19
	20	readonly TypeResolver m_parent;
	21
	22	public TypeResolver() : this(null) {
	23
	24	}
	25
	26	public TypeResolver(TypeResolver parent) {
	27	m_insertAt = new LinkedListNode<string>(string.Empty);
	28	m_namespases.AddFirst(m_insertAt);
	29	}
	30
	31	public void AddNamespace(string ns) {
	32	Safe.ArgumentMatch(ns, nameof(ns), _nsRx);
	33	if (m_insertAt != null)
	34	m_namespases.AddAfter(m_insertAt, ns);
	35	else
	36	m_namespases.AddFirst(ns);
	37	}
	38
	39	public void AddMapping(string typeName, Type type) {
	40	Safe.ArgumentNotEmpty(typeName, nameof(typeName));
	41	Safe.ArgumentNotNull(type, nameof(type));
	42
	43	m_cache[typeName] = type;
	44	}
	45
	46	public Type Resolve(TypeReference reference) {
	47	var args = reference.IsGeneric && !reference.IsOpenGeneric ? reference.GenericParameters?.Select(Resolve).ToArray() : null;
	48	var argc = reference.IsGeneric ? reference.GenericParameters.Length : 0;
	49
	50	Type resolved;
	51	if(!m_cache.TryGetValue(reference.ToString(), out resolved)) {
	52	resolved = ResolveInternal(reference, args, argc);
	53	if (resolved == null)
	54	throw new Exception($"Failed to resolve {reference}");
	55	m_cache[reference.ToString()] = resolved;
	56	}
	57
	58	return resolved;
	59	}
	60
	61	Type ResolveInternal(TypeReference reference, Type[] args, int argc) {
	62	var resolved = ProbeInNamespaces(
	63	String.Join(".", new [] { reference.Namespace, reference.TypeName }.Where(x => !string.IsNullOrEmpty(x)) ),
	64	args,
	65	argc,
	66	reference.IsArray,
	67	reference.ToString()
	68	);
	69
	70	if (resolved == null && m_parent != null)
	71	resolved = m_parent.Resolve(reference);
	72
	73	return resolved;
	74	}
	75
	76	public Type ProbeInNamespaces(string localName, Type[] args, int argc, bool isArray, string referenceName) {
	77	foreach (var ns in m_namespases) {
	78	var typeName = FormatName(new [] { ns, localName}, argc, args, isArray);
	79
	80	var resolved = Probe(typeName);
	81	if (resolved != null) {
	82	Log("Probe succeed {0} in '{1}': {2} -> {3}", referenceName, ns, typeName, resolved.AssemblyQualifiedName);
	83	return resolved;
	84	} else {
	85	Log("Probe failed {0} in '{1}': {2}", referenceName, ns, typeName);
	86	}
	87	}
	88
	89	return null;
	90	}
	91
	92	Type Probe(string typeName) {
	93	var assemblies = AppDomain.CurrentDomain.GetAssemblies();
	94
	95	foreach(var assembly in assemblies) {
	96	var type = assembly.GetType(typeName);
	97	if (type != null)
	98	return type;
	99	}
	100	return null;
	101	}
	102
	103	string FormatName(string[] parts, int argc, Type[] args, bool isArray) {
	104	var builder = new StringBuilder();
	105
	106	builder.Append(String.Join(".", parts.Where(x => !string.IsNullOrEmpty(x))));
	107	if (argc > 0) {
	108	builder.Append('`');
	109	builder.Append(argc);
	110	}
	111
	112	if (args!= null && args.Length > 0) {
	113	builder.Append('[');
	114	builder.Append(string.Join(",", args.Select(x => $"[{x.AssemblyQualifiedName}]")));
	115	builder.Append(']');
	116	}
	117
	118	if(isArray)
	119	builder.Append("[]");
	120
	121	return builder.ToString();
	122	}
	123	}
	124	} No newline at end of file

Implab.ServiceHost/Unity/ValueParameterElement.cs created 644 +7 0

@@ -0,0 +1,7
	1	namespace Implab.ServiceHost.Unity
	2	{
	3	public class ValueParameterElement : InjectionParameterElement
	4	{
	5
	6	}
	7	} No newline at end of file

Implab.Playground/Program.cs +7 -1

             using System;
             using System.Diagnostics;
             using Implab.Diagnostics;
             using Implab.ServiceHost.Unity;
             using Implab.Xml;
             using Unity;
             using Unity.Injection;
             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 class Container<T> {
                     public Container() {
                     }
                     public Container(T instance) {
                         Instance = instance;
                     }
                     public T Instance { get; set; }
+                    public void SetInstance(T value) {
+                        Instance = value;
+                    }
                 }
                 public class Program {
                     static void Main(string[] args) {
                         var container = new UnityContainer();
                         var conf = SerializationHelpers.DeserializeFromFile<ContainerElement>("data/sample.xml");
-                        Console.WriteLine($"Registrations: {conf.Registrations.Count}");
+                        Console.WriteLine($"Registrations: {conf.Items.Count}");
                     }
                 }
             }

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

@@ -1,10 +1,38
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">	2	<container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
		3	<namespace name="Implab.Playground"/>
		4
3	<!-- foo1 -->	5	<!-- foo1 -->
4	<register name="foo1" type="Foo">	6	<register name="foo1" type="Foo">
		7	<property name="Name">
		8	<value>FOO!</value>
		9	</property>
5	</register>	10	</register>
6		11
7	<!-- foo2 -->	12	<!-- foo2 -->
8	<register name="foo2" type="Foo">	13	<register name="foo2" type="Foo">
		14	<property name="Name">
		15	<value>GOOD</value>
		16	</property>
		17	<property name="IntValue">
		18	<value>2</value>
		19	</property>
9	</register>	20	</register>
		21
		22	<register type="Foo">
		23	</register>
		24
		25	<register type="Container{}">
		26	<constructor/>
		27	<method name="SetInstance">
		28	<dependency type="T"/>
		29	</method>
		30	</register>
		31
		32	<register type="Container{String}">
		33	<property name="Instance">
		34	<value>Hello!</value>
		35	</property>
		36	</register>
		37
10	</container> No newline at end of file	38	</container>

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

             using System;
             using System.Xml.Serialization;
             using Unity.Lifetime;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity
             {
                 public abstract class AbstractRegistration : IConfigurationElement {
                     /// <summary>
                     /// An optional name for a registration in the container
                     /// </summary>
                     [XmlAttribute("name")]
                     public string Name {
                         get; set;
                     }
                     public void Visit(ConfigurationContext context) {
-                        context.Visist(this);
+                        context.Visit(this);
                     }
                 }
             }

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

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

Implab.ServiceHost/Unity/ConfigurationContext.cs +31 -68

@@ -1,101 +1,64
1	using System;	1	using System;
2	using System.Collections.Generic;	2	using System.Collections.Generic;
3	using System.Text.RegularExpressions;	3	using System.Text.RegularExpressions;
4	using Implab.Diagnostics;	4	using Implab.Diagnostics;
5		5
6	namespace Implab.ServiceHost.Unity {	6	namespace Implab.ServiceHost.Unity {
7	using System.Linq;	7	using System.Linq;
8	using System.Reflection;	8	using System.Reflection;
9	using System.Text;	9	using System.Text;
10	using global::Unity;	10	using global::Unity;
		11	using Implab.Xml;
11	using static Trace<ConfigurationContext>;	12	using static Trace<ConfigurationContext>;
12		13
13	public class ConfigurationContext {	14	public class ConfigurationContext {
14	Regex _nsRx = new Regex(@"^\w+(\.\w+)*$", RegexOptions.Compiled);
15	readonly LinkedList<string> m_namespases = new LinkedList<string>();
16		15
17	LinkedListNode<string> m_insertAt;	16	readonly TypeResolver m_resolver;
		17
		18
18		19
19	readonly UnityContainer m_container;	20	readonly UnityContainer m_container;
20		21
21	public ConfigurationContext(UnityContainer container) {	22	public ConfigurationContext(UnityContainer container) {
22	m_container = container ?? new UnityContainer();	23	m_container = container ?? new UnityContainer();
23	m_insertAt = new LinkedListNode<string>(string.Empty);	24	m_resolver = new TypeResolver();
24	m_namespases.AddFirst(m_insertAt);
25	}
26
27	public void AddNamespace(string ns) {
28	Safe.ArgumentMatch(ns, nameof(ns), _nsRx);
29	if (m_insertAt != null)
30	m_namespases.AddAfter(m_insertAt, ns);
31	else
32	m_namespases.AddFirst(ns);
33	}
34
35	public Type Resolve(TypeReference reference) {
36	Safe.ArgumentNotNull(reference, nameof(reference));
37
38	var args = reference.IsGeneric && !reference.IsOpenGeneric ? reference.GenericParameters?.Select(Resolve).ToArray() : null;
39	var argc = reference.IsGeneric ? reference.GenericParameters.Length : 0;
40
41	foreach (var ns in m_namespases) {
42	var typeName = FormatName(new [] { ns, reference.Namespace, reference.TypeName}, argc, args, reference.IsArray);
43
44	var resolved = ProbeType(typeName);
45	if (resolved != null) {
46	Log("Probe succeed {0} in '{1}': {2} -> {3}", reference, ns, typeName, resolved.AssemblyQualifiedName);
47	return resolved;
48	} else {
49	Log("Probe failed {0} in '{1}': {2}", reference, ns, typeName);
50	}
51	}
52
53	throw new Exception($"Failed to resolve: {reference}");
54	}	25	}
55		26
56	Type ProbeType(string typeName) {
57	var assemblies = AppDomain.CurrentDomain.GetAssemblies();
58		27
59	foreach(var assembly in assemblies) {	28	public Type Resolve(string typeReference) {
60	var type = assembly.GetType(typeName);	29	return m_resolver.Resolve(TypeReference.Parse(typeReference));
61	if (type != null)
62	return type;
63	}
64	return null;
65	}	30	}
66		31
67	string FormatName(string[] parts, int argc, Type[] args, bool isArray) {	32	internal void Visit(AbstractRegistration descriptor) {
68	var builder = new StringBuilder();
69
70	builder.Append(String.Join(".", parts.Where(x => !string.IsNullOrEmpty(x))));
71	if (argc > 0) {
72	builder.Append('`');
73	builder.Append(argc);
74	}
75
76	if (args!= null && args.Length > 0) {
77	builder.Append('[');
78	builder.Append(string.Join(",", args.Select(x => $"[{x.AssemblyQualifiedName}]")));
79	builder.Append(']');
80	}
81
82	if(isArray)
83	builder.Append("[]");
84
85	return builder.ToString();
86	}
87
88	public Type Resolve(string typeReference) {
89	return Resolve(TypeReference.Parse(typeReference));
90	}
91
92	public void Visist(AbstractRegistration descriptor) {
93		33
94	}	34	}
95		35
		36	internal void Visit(NamespaceElement namespaceElement) {
		37	m_resolver.AddNamespace(namespaceElement.Name);
		38	}
		39
		40	internal void Visit(AssemblyElement assemblyElement) {
		41	Assembly.Load(assemblyElement.AssemblyName);
		42	}
		43
		44	internal void Visit(IncludeElement includeElement) {
		45	Include(includeElement.Href);
		46	}
		47
96	public void Include(string file) {	48	public void Include(string file) {
		49	var includeContext = new ConfigurationContext(m_container);
		50	includeContext.LoadConfig(file);
		51	}
97		52
		53	public void LoadConfig(string file) {
		54	var config = SerializationHelpers.DeserializeFromFile<ContainerElement>(file);
		55	Visit(config);
		56	}
		57
		58	public void Visit(ContainerElement containerElement) {
		59	foreach (var item in containerElement.Items)
		60	item.Visit(this);
98	}	61	}
99		62
100	}	63	}
101	} No newline at end of file	64	}

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

             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 : IXmlSerializable {
-                    public List<IConfigurationElement> Registrations {get; set; } = new List<IConfigurationElement>();
+                    public List<IConfigurationElement> Items {get; set; } = new List<IConfigurationElement>();
                     public XmlSchema GetSchema() {
                         return null;
                     }
                     public void ReadXml(XmlReader reader) {
                         while(reader.Read() && reader.NodeType != XmlNodeType.EndElement) {
                             var registration = ConfigurationSchema.Default.Deserialize<IConfigurationElement>(reader);
-                            Registrations.Add(registration);
+                            Items.Add(registration);
                         }
                     }
                     public void WriteXml(XmlWriter writer) {
                         throw new System.NotImplementedException();
                     }
                 }
             }

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("include", Namespace = Schema.ContainerConfigurationNamespace)]
                 public class IncludeElement : IConfigurationElement {
                     [XmlAttribute("href")]
                     public string Href { get; set; }
                     public void Visit(ConfigurationContext context) {
-                        context.Include(Href);
+                        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 : IConfigurationElement {
                     [XmlAttribute("name")]
                     public string Name { get; set; }
                     public void Visit(ConfigurationContext context) {
-                        throw new System.NotImplementedException();
+                        context.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/RegisterElement.cs +4 -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  {
                     /// <summary>
                     /// An optional type specification for the service registration,
                     /// must be assignable from the type specified by <see cref="ImplementedType"/>
                     /// </summary>
                     [XmlAttribute("provides")]
                     public string ProvidesType { get; set; }
                     /// <summary>
                     /// The type which is registered as a service in the container.
                     /// </summary>
                     [XmlAttribute("type")]
                     public string ImplementedType { get; set; }
                     [XmlElement("signleton", typeof(SimgletonLifetimeElement))]
                     [XmlElement("context", typeof(ContextLifetimeElement))]
                     [XmlElement("container", typeof(ContainerLifetimeElement))]
                     [XmlElement("hierarchy", typeof(HierarchicalLifetimeElement))]
                     public LifetimeElement Lifetime {get; set;}
-                    [XmlElement("constructor", typeof(ConstructorInjectorElement))]
+                    [XmlElement("constructor", typeof(ConstructorInjectionElement))]
-                    [XmlElement("property", typeof(PropertyInjectorElement))]
+                    [XmlElement("property", typeof(PropertyInjectionElement))]
-                    [XmlElement("method", typeof(MethodInjectorElement))]
+                    [XmlElement("method", typeof(MethodInjectionElement))]
-                    public AbstractInjectorElement[] Injectors { get; set; }
+                    public AbstractInjectionElement[] Injectors { get; set; }
                 }
             }

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

NO CONTENT: file was removed

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

NO CONTENT: file was removed

Implab.ServiceHost/Unity/MethodInjectorElement.cs removed 0 -13

NO CONTENT: file was removed

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

NO CONTENT: file was removed

Implab.ServiceHost/Unity/PropertyInjectorElement.cs removed 0 -6

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