implab/ImplabNet Commit - r269:ff581cff7003

Working on Unity container xml configuration

cin -

r269:ff581cff7003 v3

parent child

Context file:

r269:ff581cff7003

Expand all files

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

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

Implab.ServiceHost/Unity/AbstractRegistration.cs created 644 +22 0

@@ -0,0 +1,22
	1	using System;
	2	using System.Xml.Serialization;
	3	using Unity.Lifetime;
	4	using Unity.Registration;
	5
	6	namespace Implab.ServiceHost.Unity
	7	{
	8	public abstract class AbstractRegistration : IConfigurationElement {
	9
	10	/// <summary>
	11	/// An optional name for a registration in the container
	12	/// </summary>
	13	[XmlAttribute("name")]
	14	public string Name {
	15	get; set;
	16	}
	17
	18	public void Visit(ConfigurationContext context) {
	19	context.Visist(this);
	20	}
	21	}
	22	} No newline at end of file

Implab.ServiceHost/Unity/AssemblyElement.cs created 644 +14 0

@@ -0,0 +1,14
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	[XmlRoot("assembly", Namespace = Schema.ContainerConfigurationNamespace)]
	6	public class AssemblyElement : IConfigurationElement {
	7	[XmlAttribute("name")]
	8	public string AssemblyName { get; set; }
	9
	10	public void Visit(ConfigurationContext context) {
	11	throw new System.NotImplementedException();
	12	}
	13	}
	14	} No newline at end of file

Implab.ServiceHost/Unity/ConfigurationSchema.cs created 644 +47 0

@@ -0,0 +1,47
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Reflection;
	4	using System.Xml;
	5	using System.Xml.Serialization;
	6	using Implab.Components;
	7
	8	namespace Implab.ServiceHost.Unity {
	9	public class ConfigurationSchema {
	10
	11	public static ConfigurationSchema Default { get; private set; } = CreateDefault();
	12
	13	readonly Dictionary<Tuple<string,string>, LazyAndWeak<XmlSerializer>> m_mappings = new Dictionary<Tuple<string, string>, LazyAndWeak<XmlSerializer>>();
	14
	15	public void DefineMapping(string name, string ns, Type type) {
	16	Safe.ArgumentNotEmpty(name, nameof(name));
	17	Safe.ArgumentNotNull(type, nameof(type));
	18	ns = ns ?? string.Empty;
	19	m_mappings[Tuple.Create(name, ns)] = new LazyAndWeak<XmlSerializer>(() => new XmlSerializer(type), true);
	20	}
	21
	22	public void DefineMapping<T>() {
	23	var xmlRoot = typeof(T).GetCustomAttribute<XmlRootAttribute>();
	24	var ns = xmlRoot?.Namespace;
	25	var root = xmlRoot?.ElementName ?? typeof(T).Name;
	26	DefineMapping(root, ns, typeof(T));
	27	}
	28
	29	public T Deserialize<T>(XmlReader reader) {
	30	reader.MoveToContent();
	31	var name = reader.Name;
	32	var ns = reader.NamespaceURI;
	33
	34	return (T)m_mappings[Tuple.Create(name, ns)].Value.Deserialize(reader);
	35	}
	36
	37	static ConfigurationSchema CreateDefault() {
	38	var schema = new ConfigurationSchema();
	39
	40	schema.DefineMapping<RegisterElement>();
	41
	42	return schema;
	43	}
	44
	45
	46	}
	47	} No newline at end of file

Implab.ServiceHost/Unity/ConstructorInjectorElement.cs created 644 +5 0

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

Implab.ServiceHost/Unity/ContainerLifetimeElement.cs created 644 +10 0

@@ -0,0 +1,10
	1	using Unity.Lifetime;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	public class ContainerLifetimeElement : LifetimeElement {
	6	public override LifetimeManager GetLifetimeManager(ConfigurationContext ctx) {
	7	return new ContainerControlledLifetimeManager();
	8	}
	9	}
	10	} No newline at end of file

Implab.ServiceHost/Unity/ContextLifetimeElement.cs created 644 +10 0

@@ -0,0 +1,10
	1	using Unity.Lifetime;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	public class ContextLifetimeElement : LifetimeElement {
	6	public override LifetimeManager GetLifetimeManager(ConfigurationContext ctx) {
	7	return new PerResolveLifetimeManager();
	8	}
	9	}
	10	} No newline at end of file

Implab.ServiceHost/Unity/HierarchicalLifetimeElement.cs created 644 +10 0

@@ -0,0 +1,10
	1	using Unity.Lifetime;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	public class HierarchicalLifetimeElement : LifetimeElement {
	6	public override LifetimeManager GetLifetimeManager(ConfigurationContext ctx) {
	7	return new HierarchicalLifetimeManager();
	8	}
	9	}
	10	} No newline at end of file

Implab.ServiceHost/Unity/IConfigurationElement.cs created 644 +5 0

@@ -0,0 +1,5
	1	namespace Implab.ServiceHost.Unity {
	2	public interface IConfigurationElement {
	3	void Visit(ConfigurationContext context);
	4	}
	5	} No newline at end of file

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

@@ -0,0 +1,13
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	[XmlRoot("include", Namespace = Schema.ContainerConfigurationNamespace)]
	5	public class IncludeElement : IConfigurationElement {
	6	[XmlAttribute("href")]
	7	public string Href { get; set; }
	8
	9	public void Visit(ConfigurationContext context) {
	10	context.Include(Href);
	11	}
	12	}
	13	} No newline at end of file

Implab.ServiceHost/Unity/LifetimeElement.cs created 644 +10 0

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

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

@@ -0,0 +1,13
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public class MethodInjectorElement : AbstractInjectorElement {
	5
	6	[XmlAttribute("name")]
	7	public string Name { get; set; }
	8
	9	[XmlElement("params")]
	10	public MethodInjectorParameter[] Parameters { get; set; }
	11
	12	}
	13	} No newline at end of file

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

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

Implab.ServiceHost/Unity/NamespaceElement.cs created 644 +15 0

@@ -0,0 +1,15
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	[XmlRoot("namespace", Namespace = Schema.ContainerConfigurationNamespace)]
	6	public class NamespaceElement : IConfigurationElement {
	7
	8	[XmlAttribute("name")]
	9	public string Name { get; set; }
	10
	11	public void Visit(ConfigurationContext context) {
	12	throw new System.NotImplementedException();
	13	}
	14	}
	15	} No newline at end of file

Implab.ServiceHost/Unity/PropertyInjectorElement.cs created 644 +6 0

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

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

@@ -0,0 +1,36
	1	using System;
	2	using System.Xml.Serialization;
	3	using Unity.Lifetime;
	4	using Unity.Registration;
	5
	6	namespace Implab.ServiceHost.Unity {
	7
	8	[XmlRoot("register", Namespace = Schema.ContainerConfigurationNamespace)]
	9	public class RegisterElement : AbstractRegistration {
	10
	11	/// <summary>
	12	/// An optional type specification for the service registration,
	13	/// must be assignable from the type specified by <see cref="ImplementedType"/>
	14	/// </summary>
	15	[XmlAttribute("provides")]
	16	public string ProvidesType { get; set; }
	17
	18	/// <summary>
	19	/// The type which is registered as a service in the container.
	20	/// </summary>
	21	[XmlAttribute("type")]
	22	public string ImplementedType { get; set; }
	23
	24	[XmlElement("signleton", typeof(SimgletonLifetimeElement))]
	25	[XmlElement("context", typeof(ContextLifetimeElement))]
	26	[XmlElement("container", typeof(ContainerLifetimeElement))]
	27	[XmlElement("hierarchy", typeof(HierarchicalLifetimeElement))]
	28	public LifetimeElement Lifetime {get; set;}
	29
	30	[XmlElement("constructor", typeof(ConstructorInjectorElement))]
	31	[XmlElement("property", typeof(PropertyInjectorElement))]
	32	[XmlElement("method", typeof(MethodInjectorElement))]
	33	public AbstractInjectorElement[] Injectors { get; set; }
	34	}
	35
	36	} No newline at end of file

Implab.ServiceHost/Unity/SimgletonLifetimeElement.cs created 644 +10 0

@@ -0,0 +1,10
	1	using Unity.Lifetime;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	public class SimgletonLifetimeElement : LifetimeElement {
	6	public override LifetimeManager GetLifetimeManager(ConfigurationContext ctx) {
	7	return new SingletonLifetimeManager();
	8	}
	9	}
	10	} No newline at end of file

Implab.Playground/Program.cs +7 -12

             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 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 class Program {
                     static void Main(string[] args) {
                         var container = new UnityContainer();
-                        var listener = new SimpleTraceListener(Console.Out);
+                        var conf = SerializationHelpers.DeserializeFromFile<ContainerElement>("data/sample.xml");
-                        Trace<ConfigurationContext>.TraceSource.Switch.Level = SourceLevels.All;
-                        Trace<ConfigurationContext>.TraceSource.Listeners.Add(listener);
-                        var c = new Container<int>();
-                        var cts = new ConfigurationContext();
+                        Console.WriteLine($"Registrations: {conf.Registrations.Count}");
-                        cts.AddNamespace("System");
-                        cts.AddNamespace("System.Collections.Generic");
-                        cts.AddNamespace("Implab.Playground");
-                        Console.WriteLine(c.GetType().FullName);
-                        cts.Resolve("Container{Int32}");
                     }
                 }
             }

Implab.Playground/data/sample.xml +2 -2

             <?xml version="1.0" encoding="UTF-8"?>
             <container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
                 <!-- foo1 -->
-                <register name="foo1" provides="IFoo" type="Foo">
+                <register name="foo1" type="Foo">
                 </register>
                 <!-- foo2 -->
-                <register name="foo2" provides="IFoo" type="Foo">
+                <register name="foo2" type="Foo">
                 </register>
             </container>

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

             using System;
             using System.Collections.Generic;
             using System.Text.RegularExpressions;
             using Implab.Diagnostics;
             namespace Implab.ServiceHost.Unity {
                 using System.Linq;
+                using System.Reflection;
                 using System.Text;
+                using global::Unity;
                 using static Trace<ConfigurationContext>;
                 public class ConfigurationContext {
                     Regex _nsRx = new Regex(@"^\w+(\.\w+)*$", RegexOptions.Compiled);
                     readonly LinkedList<string> m_namespases = new LinkedList<string>();
                     LinkedListNode<string> m_insertAt;
-                    public ConfigurationContext() {
+                    readonly UnityContainer m_container;
+                    public ConfigurationContext(UnityContainer container) {
+                        m_container = container ?? new UnityContainer();
                         m_insertAt = new LinkedListNode<string>(string.Empty);
                         m_namespases.AddFirst(m_insertAt);
                     }
                     public void AddNamespace(string ns) {
                         Safe.ArgumentMatch(ns, nameof(ns), _nsRx);
                         if (m_insertAt != null)
                             m_namespases.AddAfter(m_insertAt, ns);
                         else
                             m_namespases.AddFirst(ns);
                     }
                     public Type Resolve(TypeReference reference) {
                         Safe.ArgumentNotNull(reference, nameof(reference));
                         var args = reference.IsGeneric && !reference.IsOpenGeneric ? reference.GenericParameters?.Select(Resolve).ToArray() : null;
                         var argc = reference.IsGeneric ? reference.GenericParameters.Length : 0;
                         foreach (var ns in m_namespases) {
                             var typeName = FormatName(new [] { ns, reference.Namespace, reference.TypeName}, argc, args, reference.IsArray);
-                            var resolved = Type.GetType(typeName, false);
+                            var resolved = ProbeType(typeName);
                             if (resolved != null) {
-                                Log("Probe succeed {0} in '{1}': {2} -> {3}", reference, ns, typeName, resolved.FullName);
+                                Log("Probe succeed {0} in '{1}': {2} -> {3}", reference, ns, typeName, resolved.AssemblyQualifiedName);
                                 return resolved;
                             } else {
                                 Log("Probe failed {0} in '{1}': {2}", reference, ns, typeName);
                             }
                         }
                         throw new Exception($"Failed to resolve: {reference}");
                     }
+                    Type ProbeType(string typeName) {
+                        var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+                        foreach(var assembly in assemblies) {
+                            var type = assembly.GetType(typeName);
+                            if (type != null)
+                                return type;
+                        }
+                        return null;
+                    }
                     string FormatName(string[] parts, int argc, Type[] args, bool isArray) {
                         var builder = new StringBuilder();
                         builder.Append(String.Join(".", parts.Where(x => !string.IsNullOrEmpty(x))));
                         if (argc > 0) {
                             builder.Append('`');
                             builder.Append(argc);
                         }
                         if (args!= null && args.Length > 0) {
                             builder.Append('[');
-                            builder.Append(string.Join(",", args.Select(x => x.FullName)));
+                            builder.Append(string.Join(",", args.Select(x => $"[{x.AssemblyQualifiedName}]")));
                             builder.Append(']');
                         }
                         if(isArray)
                             builder.Append("[]");
                             return builder.ToString();
                     }
                     public Type Resolve(string typeReference) {
                         return Resolve(TypeReference.Parse(typeReference));
                     }
-                    public void Register(ServiceElement descriptor) {
+                    public void Visist(AbstractRegistration descriptor) {
+                    }
+                    public void Include(string file) {
                     }
                 }
             }

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

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

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

Implab.ServiceHost/Unity/ServiceElement.cs removed 0 -28

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