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

                      }
+                     public string Name { get; set; }
                      public int IntValue { get; set; }
                      public string StringValue { get; set; }
                      }
                      public T Instance { get; set; }
+                     public void SetInstance(T value) {
+                         Instance = value;
+                     }
                  }
                  public class Program {
                          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

              <?xml version="1.0" encoding="UTF-8"?>
              <container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
+                 <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">
+                 </register>
+                 <register type="Container{}">
+                     <constructor/>
+                     <method name="SetInstance">
+                         <dependency type="T"/>
+                     </method>
+                 </register>
+                 <register type="Container{String}">
+                     <property name="Instance">
+                         <value>Hello!</value>
+                     </property>
+                 </register>
              </container>
  No newline at end of file

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

                      }
                      public void Visit(ConfigurationContext context) {
-                         context.Visist(this);
+                         context.Visit(this);
                      }
                  }
              }
  No newline at end of file

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

                      public string AssemblyName { get; set; }
                      public void Visit(ConfigurationContext context) {
-                         throw new System.NotImplementedException();
+                         context.Visit(this);
                      }
                  }
              }
  No newline at end of file

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

		@@ -8,93 +8,56 namespace Implab.ServiceHost.Unity {
8	8	using System.Reflection;
9	9	using System.Text;
10	10	using global::Unity;
	11	using Implab.Xml;
11	12	using static Trace<ConfigurationContext>;
12	13
13	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	20	readonly UnityContainer m_container;
20	21
21	22	public ConfigurationContext(UnityContainer container) {
22	23	m_container = container ?? new UnityContainer();
23		m_insertAt = new LinkedListNode<string>(string.Empty);
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}");
	24	m_resolver = new TypeResolver();
54	25	}
55	26
56		Type ProbeType(string typeName) {
57		var assemblies = AppDomain.CurrentDomain.GetAssemblies();
58	27
59		foreach(var assembly in assemblies) {
60		var type = assembly.GetType(typeName);
61		if (type != null)
62		return type;
63		}
64		return null;
	28	public Type Resolve(string typeReference) {
	29	return m_resolver.Resolve(TypeReference.Parse(typeReference));
65	30	}
66	31
67		string FormatName(string[] parts, int argc, Type[] args, bool isArray) {
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) {
	32	internal void Visit(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	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	}

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

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

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

                      public string Href { get; set; }
                      public void Visit(ConfigurationContext context) {
-                         context.Include(Href);
+                         context.Visit(this);
                      }
                  }
              }
  No newline at end of file

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

                      public string Name { get; set; }
                      public void Visit(ConfigurationContext context) {
-                         throw new System.NotImplementedException();
+                         context.Visit(this);
                      }
                  }
              }
  No newline at end of file

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

                      [XmlElement("hierarchy", typeof(HierarchicalLifetimeElement))]
                      public LifetimeElement Lifetime {get; set;}
-                     [XmlElement("constructor", typeof(ConstructorInjectorElement))]
-                     [XmlElement("property", typeof(PropertyInjectorElement))]
-                     [XmlElement("method", typeof(MethodInjectorElement))]
-                     public AbstractInjectorElement[] Injectors { get; set; }
+                     [XmlElement("constructor", typeof(ConstructorInjectionElement))]
+                     [XmlElement("property", typeof(PropertyInjectionElement))]
+                     [XmlElement("method", typeof(MethodInjectionElement))]
+                     public AbstractInjectionElement[] Injectors { get; set; }
                  }
              }
  No newline at end of file

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