implab/ImplabNet Commit - r278:6691aff01de1

Implab: added XmlDefaultSeializer (SerializersPool is now obsolete)...

cin -

r278:6691aff01de1 v3

parent child

Context file:

r278:6691aff01de1

Expand all files

Implab.ServiceHost/Unity/ArrayTypeReference.cs created 644 +57 0

@@ -0,0 +1,57
	1	using System;
	2	using System.Text;
	3
	4	namespace Implab.ServiceHost.Unity {
	5	public class ArrayTypeReference : TypeReference {
	6	public int Rank { get; private set; }
	7
	8	public TypeReference ItemsType { get; private set; }
	9
	10	public override string Name {
	11	get {
	12	return ItemsType.Name;
	13	}
	14	}
	15
	16	public override string ClrName {
	17	get {
	18	return new StringBuilder()
	19	.Append(ItemsType.ClrName)
	20	.Append("[")
	21	.Append(',', Rank - 1)
	22	.Append("]")
	23	.ToString();
	24	}
	25	}
	26
	27	public override string Namespace {
	28	get {
	29	return ItemsType.Namespace;
	30	}
	31	}
	32
	33	public override int GenericParametersCount {
	34	get {
	35	return 0;
	36	}
	37	}
	38
	39	internal ArrayTypeReference(TypeReference itemsType, int rank) {
	40	ItemsType = itemsType;
	41	Rank = rank;
	42	}
	43
	44	internal override void Visit(TypeResolutionContext visitor) {
	45	visitor.Visit(this);
	46	}
	47
	48	override public string ToString() {
	49	return new StringBuilder()
	50	.Append(ItemsType.ToString())
	51	.Append('[')
	52	.Append(',', Rank - 1)
	53	.Append(']')
	54	.ToString();
	55	}
	56	}
	57	} No newline at end of file

Implab.ServiceHost/Unity/FactoryActivator.cs created 644 +29 0

@@ -0,0 +1,29
	1	using System;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public class FactoryActivator : FactoryAbstractRegistratrion {
	5
	6	public Type FactoryType { get; set; }
	7
	8	public string FactoryName { get; set; }
	9
	10	public new Type RegistrationType { get; set; }
	11
	12	public override void Visit(FactoryRegistrationBuilder builder) {
	13	base.Visit(builder);
	14
	15	builder.GetType()
	16	.GetMethod(
	17	nameof(FactoryRegistrationBuilder.SetFactoryDependency)
	18	, new[] { typeof(string) }
	19	)
	20	.MakeGenericMethod(FactoryType, RegistrationType)
	21	.Invoke(builder, new[] { FactoryName });
	22	}
	23
	24	public override Type GetRegistrationType(Func<string, Type> resolver) {
	25	return RegistrationType;
	26	}
	27
	28	}
	29	} No newline at end of file

Implab.ServiceHost/Unity/FactoryElement.cs created 644 +72 0

@@ -0,0 +1,72
	1	using System;
	2	using System.Xml.Serialization;
	3	using Implab.Components;
	4
	5	namespace Implab.ServiceHost.Unity {
	6	/// <summary>
	7	/// Расширяет стандартную регистрацию типа до фабрики, вместе с регистрацией
	8	/// самой фабрики создаются регистрации сервисов, которые она предоставляет.
	9	/// </summary>
	10	public class FactoryElement : RegisterElement {
	11
	12	/// <summary>
	13	/// Записи о сервисах, которые создаются данной фабрикой.
	14	/// </summary>
	15	/// <remarks>
	16	/// Сервисы, которые указаны в регистарциях они должны соответсвовать тому,
	17	/// что фабрика возвращает, но это остается на откуп контейнера
	18	/// </remarks>
	19	[XmlElement("provides")]
	20	public ProvidesElement[] Provides { get; set; }
	21
	22	/// <summary>
	23	/// Переопределяет стандарное поведение регистрации типа в контейнере,
	24	/// дополняя его регистрацией фабричных методов для получения типов.
	25	/// </summary>
	26	/// <param name="builder">Объект для конфигурирования контейнера.</param>
	27	public override void Visit(ContainerBuilder builder) {
	28	var factoryType = GetRegistrationType(builder.ResolveType);
	29
	30	base.Visit(builder);
	31
	32	if (Provides != null && Provides.Length > 0) {
	33	// если регистрации явно заданы, используеися информация из них
	34	foreach(var item in Provides) {
	35	var activator = new FactoryActivator {
	36	Name = item.RegistrationName,
	37	RegistrationType = builder.ResolveType(item.RegistrationType),
	38	FactoryName = Name,
	39	FactoryType = factoryType
	40	};
	41	activator.Visit(builder);
	42	}
	43	} else {
	44	// если регистрация явно не задана, в качестве сервиса для регистрации
	45	// используется тип создаваемый фабрикой, который будет добавлен в контейнер
	46	// с темже именем, что и сама фабрика (разные типы могут иметь одно имя для регистрации)
	47	var providedType = (
	48	factoryType.IsGenericType && factoryType.GetGenericTypeDefinition() == typeof(IFactory<>) ?
	49	factoryType :
	50	factoryType.GetInterface(typeof(IFactory<>).FullName)
	51	)?
	52	.GetGenericArguments()[0];
	53
	54	// не удалось определеить тип
	55	if (providedType == null)
	56	throw new ArgumentException("Failed to determine a type provided by the factory");
	57
	58	if (providedType.IsGenericParameter)
	59	throw new ArgumentException("Can't register a generic type paramter as a service");
	60
	61	var activator = new FactoryActivator {
	62	Name = Name,
	63	RegistrationType = providedType,
	64	FactoryName = Name,
	65	FactoryType = factoryType
	66	};
	67
	68	activator.Visit(builder);
	69	}
	70	}
	71	}
	72	} No newline at end of file

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

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

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

@@ -0,0 +1,7
	1	using System.Collections.Generic;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public interface IFactoryRegistration : IRegistration {
	5	IEnumerable<IFactoryMemberInjection> MemberInjections { get; }
	6	}
	7	} No newline at end of file

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

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

Implab.ServiceHost/Unity/IInstanceRegistration.cs created 644 +8 0

@@ -0,0 +1,8
	1	using System.Collections.Generic;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public interface IInstanceRegistration : IRegistration {
	5
	6	IEnumerable<IInjectionParameter> MemberInjections { get; }
	7	}
	8	} No newline at end of file

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

@@ -0,0 +1,12
	1	using System;
	2	using Unity.Lifetime;
	3
	4	namespace Implab.ServiceHost.Unity {
	5	public interface IRegistration {
	6	string Name { get; }
	7
	8	Type GetRegistrationType(ContainerBuilder builder);
	9
	10	LifetimeManager GetLifetime(ContainerBuilder builder);
	11	}
	12	} No newline at end of file

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

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

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

@@ -0,0 +1,10
	1	using System;
	2	using System.Collections.Generic;
	3
	4	namespace Implab.ServiceHost.Unity {
	5	public interface ITypeRegistration : IRegistration {
	6	Type GetImplementationType(ContainerBuilder builder);
	7
	8	IEnumerable<ITypeMemberInjection> MemberInjections { get; }
	9	}
	10	} No newline at end of file

Implab.ServiceHost/Unity/NestedTypeReference.cs created 644 +48 0

@@ -0,0 +1,48
	1	using System;
	2	using System.Text;
	3
	4	namespace Implab.ServiceHost.Unity {
	5	public class NestedTypeReference : TypeReference {
	6
	7	readonly string m_name;
	8
	9	readonly int m_genericParametersCount;
	10
	11	public TypeReference DeclaringType { get; private set; }
	12
	13	public override string Name {
	14	get {
	15	return m_name;
	16	}
	17	}
	18
	19	public override string Namespace {
	20	get {
	21	return DeclaringType.Namespace;
	22	}
	23	}
	24
	25	public override int GenericParametersCount {
	26	get {
	27	return m_genericParametersCount;
	28	}
	29	}
	30
	31	internal NestedTypeReference(TypeReference declaringType, string name, int parametersCount) {
	32	DeclaringType = declaringType;
	33	m_name = name;
	34	m_genericParametersCount = parametersCount;
	35	}
	36
	37	internal override void Visit(TypeResolutionContext visitor) {
	38	visitor.Visit(this);
	39	}
	40
	41	internal override void WriteTypeName(StringBuilder builder) {
	42	builder
	43	.Append(DeclaringType)
	44	.Append('+')
	45	.Append(Name);
	46	}
	47	}
	48	} No newline at end of file

Implab.ServiceHost/Unity/ProvidesElement.cs created 644 +11 0

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

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

@@ -0,0 +1,36
	1	using System;
	2
	3	namespace Implab.ServiceHost.Unity
	4	{
	5	public class RootTypeReference : TypeReference {
	6	readonly string m_name;
	7
	8	readonly string m_namespace;
	9
	10	readonly int m_genericParametersCount;
	11
	12	public override string Name {
	13	get { return m_name; }
	14	}
	15
	16	public override string Namespace {
	17	get { return m_namespace; }
	18	}
	19
	20	public override int GenericParametersCount {
	21	get { return m_genericParametersCount; }
	22	}
	23
	24	internal RootTypeReference(string ns, string name, int genericParameters) {
	25	m_name = name;
	26	m_genericParametersCount = genericParameters;
	27	m_namespace = ns;
	28	}
	29
	30	internal override void Visit(TypeResolutionContext visitor) {
	31	visitor.Visit(this);
	32	}
	33
	34
	35	}
	36	} No newline at end of file

Implab.ServiceHost/Unity/SpecializedTypeReference.cs created 644 +52 0

@@ -0,0 +1,52
	1	using System;
	2	using System.Linq;
	3	using System.Text;
	4
	5	namespace Implab.ServiceHost.Unity {
	6	public class SpecializedTypeReference : TypeReference {
	7	public override string Name {
	8	get {
	9	return GenericType.Name;
	10	}
	11	}
	12
	13	public override string Namespace {
	14	get {
	15	return GenericType.Namespace;
	16	}
	17	}
	18
	19	public override int GenericParametersCount {
	20	get {
	21	return GenericParameters.Length;
	22	}
	23	}
	24
	25	public TypeReference GenericType { get; private set; }
	26
	27	public TypeReference[] GenericParameters { get; private set; }
	28
	29	internal SpecializedTypeReference(TypeReference genericType, TypeReference[] genericParameters) {
	30	GenericType = genericType;
	31	GenericParameters = genericParameters;
	32	}
	33
	34	internal override void Visit(TypeResolutionContext visitor) {
	35	visitor.Visit(this);
	36	}
	37
	38	internal override void WriteTypeName(StringBuilder builder) {
	39	GenericType.WriteTypeName(builder);
	40	}
	41
	42	internal override void WriteTypeParams(StringBuilder builder) {
	43	builder.Append('{');
	44	for (var i = 0; i < GenericParameters.Length; i++) {
	45	if (i > 0)
	46	builder.Append(',');
	47	builder.Append(GenericParameters[i]);
	48	}
	49	builder.Append('}');
	50	}
	51	}
	52	} No newline at end of file

Implab.ServiceHost/Unity/TypeResolutionContext.cs created 644 +75 0

@@ -0,0 +1,75
	1	using System;
	2	using System.Collections.Generic;
	3	using Implab.Diagnostics;
	4
	5	namespace Implab.ServiceHost.Unity {
	6	using static Trace<TypeResolver>;
	7
	8	/// <summary>
	9	/// Позволяет обойти вложенные типы и собрать цеочку из типов и параметров генериков, которые они предлагают
	10	/// </summary>
	11	internal class TypeResolutionContext {
	12	readonly TypeResolver m_resolver;
	13
	14
	15	readonly List<Type> m_genericParameters = new List<Type>();
	16
	17	public IEnumerable<Type> GenericParameters { get { return m_genericParameters; } }
	18
	19	public Type ResolvedType { get; private set; }
	20
	21
	22	public int ArrayRank { get; private set; }
	23
	24
	25	public bool ThrowOnFail { get; private set; }
	26
	27	public TypeResolutionContext(TypeResolver resolver, bool throwOnFail) {
	28	m_resolver = resolver;
	29	ThrowOnFail = throwOnFail;
	30	}
	31
	32	public Type MakeType() {
	33	return m_genericParameters.Count > 0 ?
	34	ResolvedType?.MakeGenericType(m_genericParameters.ToArray()) :
	35	ResolvedType;
	36	}
	37
	38	public void Visit(SpecializedTypeReference typeReference) {
	39	typeReference.GenericType.Visit(this);
	40
	41	if (ResolvedType != null) {
	42	foreach (var genericParamRef in typeReference.GenericParameters) {
	43	var context = new TypeResolutionContext(m_resolver, ThrowOnFail);
	44	genericParamRef.Visit(context);
	45	m_genericParameters.Add(context.MakeType());
	46	}
	47	}
	48	}
	49
	50	public void Visit(NestedTypeReference typeReference) {
	51	typeReference.DeclaringType.Visit(this);
	52	if (ResolvedType != null)
	53	ResolvedType = ResolvedType?.GetNestedType(typeReference.ClrName) ?? Failed(typeReference);
	54	}
	55
	56	public void Visit(RootTypeReference typeReference) {
	57	ResolvedType = m_resolver.Resolve(typeReference.Namespace, typeReference.ClrName) ?? Failed(typeReference);
	58	}
	59
	60	public void Visit(ArrayTypeReference typeReference) {
	61	var context = new TypeResolutionContext(m_resolver, ThrowOnFail);
	62	typeReference.ItemsType.Visit(context);
	63	ResolvedType = typeReference.Rank == 1 ?
	64	context.MakeType()?.MakeArrayType() :
	65	context.MakeType()?.MakeArrayType(typeReference.Rank);
	66	}
	67
	68	Type Failed(TypeReference reference) {
	69	Log($"Falied to resolve {reference}");
	70	if (ThrowOnFail)
	71	throw new Exception($"Failed to resolve {reference}");
	72	return null;
	73	}
	74	}
	75	} No newline at end of file

Implab/Xml/XmlDefaultSerializer.cs created 644 +14 0

@@ -0,0 +1,14
	1	using System.Xml.Serialization;
	2	using Implab.Components;
	3
	4	namespace Implab.Xml {
	5	/// <summary>
	6	/// This class used to get default serializer for the specified type <typeparamref name="T"/>.
	7	/// </summary>
	8	/// <typeparam name="T">The type used to create <see cref="XmlSerializer"/></typeparam>
	9	public static class XmlDefaultSerializer<T> {
	10	static readonly LazyAndWeak<XmlSerializer> m_instance = new LazyAndWeak<XmlSerializer>(() => new XmlSerializer(typeof(T)));
	11
	12	public static XmlSerializer Instance { get { return m_instance.Value; } }
	13	}
	14	} No newline at end of file

Implab/Xml/XmlSerializerExtensions.cs created 644 +89 0

@@ -0,0 +1,89
	1	using System.IO;
	2	using System.Text;
	3	using System.Xml;
	4	using System.Xml.Linq;
	5	using System.Xml.Serialization;
	6
	7	namespace Implab.Xml {
	8	public static class XmlSerializerExtensions {
	9
	10	public static void Serialize(this XmlSerializer that, object obj, XmlElement element) {
	11	Safe.ArgumentNotNull(that, nameof(that));
	12	using (var writer = element.CreateNavigator().AppendChild())
	13	that.Serialize(writer, obj);
	14	}
	15
	16	public static void Serialize(this XmlSerializer that, object obj, XElement element) {
	17	Safe.ArgumentNotNull(that, nameof(that));
	18	using (var writer = element.CreateWriter())
	19	that.Serialize(writer, obj);
	20	}
	21
	22	public static XDocument SerializeAsXDocumnet(this XmlSerializer that, object obj) {
	23	Safe.ArgumentNotNull(that, nameof(that));
	24	var doc = new XDocument();
	25	using (var writer = doc.CreateWriter()) {
	26	that.Serialize(writer, obj);
	27	}
	28	return doc;
	29	}
	30
	31	public static XmlDocument SerializeAsXmlDocument(this XmlSerializer that, object obj) {
	32	Safe.ArgumentNotNull(that, nameof(that));
	33	var doc = new XmlDocument();
	34	using (var writer = doc.CreateNavigator().AppendChild()) {
	35	that.Serialize(writer, obj);
	36	}
	37	return doc;
	38	}
	39	public static string SerializeAsString(this XmlSerializer that, object obj) {
	40	Safe.ArgumentNotNull(that, nameof(that));
	41	using (var writer = new StringWriter()) {
	42	that.Serialize(writer, obj);
	43	return writer.ToString();
	44	}
	45	}
	46
	47	public static void SerializeToFile(this XmlSerializer that, object obj, string file, Encoding encoding) {
	48	Safe.ArgumentNotNull(that, nameof(that));
	49	using (var writer = new StreamWriter(File.Create(file),encoding))
	50	that.Serialize(writer, obj);
	51	}
	52
	53	public static void SerializeToFile(this XmlSerializer that, object obj, string file) {
	54	SerializeToFile(that, obj, file, Encoding.UTF8);
	55	}
	56
	57	public static object Deserialize(this XmlSerializer that, XmlElement element) {
	58	Safe.ArgumentNotNull(that, nameof(that));
	59	Safe.ArgumentNotNull(element, nameof(element));
	60
	61	using (var reader = element.CreateNavigator().ReadSubtree())
	62	return that.Deserialize(reader);
	63	}
	64
	65	public static object Deserialize(this XmlSerializer that, XElement element) {
	66	Safe.ArgumentNotNull(that, nameof(that));
	67	Safe.ArgumentNotNull(element, nameof(element));
	68
	69	using (var reader = element.CreateReader())
	70	return that.Deserialize(reader);
	71	}
	72
	73	public static object DeserializeFromString(this XmlSerializer that, string text) {
	74	Safe.ArgumentNotNull(that, nameof(that));
	75
	76	using(var reader = new StringReader(text))
	77	return that.Deserialize(reader);
	78	}
	79
	80	public static object DeserializeFromFile(this XmlSerializer that, string file) {
	81	Safe.ArgumentNotNull(that, nameof(that));
	82
	83	using(var reader = File.OpenRead(file))
	84	return that.Deserialize(reader);
	85	}
	86
	87
	88	}
	89	} No newline at end of file

Implab.Playground/Program.cs +42 -20

@@ -2,6 +2,7
2	using System.Collections.Generic;	2	using System.Collections.Generic;
3	using System.Diagnostics;	3	using System.Diagnostics;
4	using System.Linq;	4	using System.Linq;
		5	using Implab.Components;
5	using Implab.Diagnostics;	6	using Implab.Diagnostics;
6	using Implab.ServiceHost.Unity;	7	using Implab.ServiceHost.Unity;
7	using Implab.Xml;	8	using Implab.Xml;
@@ -29,11 +30,39 namespace Implab.Playground {
29		30
30	}	31	}
31		32
		33	public class FooFactory : IFactory<Foo>, IFactory<Foo.Bar> {
		34
		35	public bool UseSsl { get; set; }
		36
		37	public string Connection { get; set; }
		38
		39	public Foo Create() {
		40	return new Foo() {
		41	Name = "AutoFac"
		42	};
		43	}
		44
		45	Foo.Bar IFactory<Foo.Bar>.Create() {
		46	return new Foo.Bar();
		47	}
		48	}
		49
32	public interface IContainer<T> {	50	public interface IContainer<T> {
33	T Instance { get; set; }	51	T Instance { get; set; }
34	}	52	}
35		53
36	public class Container<T> : IContainer<T> {	54	public class Container<T> : IContainer<T> {
		55	public class Bar {
		56
		57	}
		58
		59	public class Bar<T2> {
		60	public class Baz {
		61
		62	}
		63
		64	}
		65
37	public Container() {	66	public Container() {
38		67
39	}	68	}
@@ -65,29 +94,22 namespace Implab.Playground {
65	source.Switch.Level = SourceLevels.All;	94	source.Switch.Level = SourceLevels.All;
66	source.Listeners.Add(listener);	95	source.Listeners.Add(listener);
67		96
68	var ~~stopwatch~~ = new ~~Stopwatch~~();	97	var resolver = new TypeResolver();
69	stopwatch.Start();	98	resolver.AddNamespace("System");
70		99	resolver.AddNamespace("System.Collections.Generic");
71	var ctx = new ContainerBuilder();	100	resolver.AddNamespace("Implab.Playground");
72		101	resolver.AddMapping("string", typeof(string));
73	Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");	102	resolver.AddMapping("listOf`1", typeof(List<>));
74	stopwatch.Restart();
75
76	ctx.LoadConfig("data/sample.xml");
77
78	Console.WriteLine($"Loaded: {stopwatch.ElapsedMilliseconds}");
79		103
80	var container = ctx.Container;	104	var spec = TypeReference.Parse("Container{listOf{string}}+Bar{List{string}}");
81		105
82	stopwatch.Restart();	106	var t = resolver.Resolve(spec, true);
83	var instace1 = container.Resolve<IContainer<string>>();
84	Console.WriteLine($"Resolved1: {stopwatch.ElapsedMilliseconds}");
85		107
86	stopwatch.Restart();	108	Console.WriteLine("{0}", t);
87	var instace2 = container.Resolve<IContainer<Foo>>();	109	Console.WriteLine("Spec: {0}", spec);
88	Console.WriteLine($"Resolved2: {stopwatch.ElapsedMilliseconds}");	110	Console.WriteLine("IsGenericType: {0}", t.IsGenericType);
89		111	Console.WriteLine("IsGenericTypeDefinition: {0}", t.IsGenericTypeDefinition);
90	DisplayContainerRegistrations(container);	112	Console.WriteLine("ContainsGenericParameters: {0}", t.ContainsGenericParameters);
91	}	113	}
92		114
93	static void DisplayContainerRegistrations(IUnityContainer theContainer) {	115	static void DisplayContainerRegistrations(IUnityContainer theContainer) {

Implab.Playground/data/sample.xml +9 -3

             <container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
                 <namespace name="System"/>
                 <namespace name="System.Collections.Generic"/>
+                <namespace name="Implab.Components"/>
                 <namespace name="Implab.Playground"/>
                 <!-- foo1 -->
                     </method>
                     <method name="AddRange">
                         <array itemsType="T">
-                            <dependency name="foo2"/>
+                            <dependency name="foo2-bar"/>
                         </array>
                     </method>
                 </register>
                 <value name="connection1" type="String"><![CDATA[Connect me <here>!]]></value>
                 <value name="name1" type="String" value="Hello!"/>
-                <factory name="foo3" type="FooFactory">
+                <factory name="foo3" type="IFactory{Foo}" mapTo="FooFactory">
-                    <parameter name="FooName"><![CDATA[Wired "" objecty <> name @#$%^&]]></parameter>
+                    <property name="Connection">
+                        <value><![CDATA[Wired "" objecty <> name @#$%^&]]></value>
+                    </property>
+                    <property name="UseSsl">
+                        <value>false</value>
+                    </property>
                 </factory>
             </container>

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

                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement[] Items { get; set; }
-                    public override void Visit(InjectionValueBuilder builder) {
+                    public override void Visit(InjectionParameterBuilder builder) {
                         builder.Visit(this);
                     }
                 }

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

                     public string AssemblyName { get; set; }
                     public override void Visit(ContainerBuilder builder) {
-                        builder.Visit(this);
+                        builder.AddAssembly(AssemblyName);
                     }
                 }
             }

Implab.ServiceHost/Unity/ContainerBuilder.cs +79 -20

@@ -1,17 +1,8
1	using System;	1	using System;
2	using System.~~Col~~lection~~s.Generic~~;	2	using System.Reflection;
3	using System.Text.RegularExpressions;	3	using Unity;
4	using Implab.Diagnostics;
5		4
6	namespace Implab.ServiceHost.Unity {	5	namespace Implab.ServiceHost.Unity {
7	using System.Linq;
8	using System.Reflection;
9	using System.Text;
10	using global::Unity;
11	using global::Unity.Registration;
12	using Implab.Xml;
13	using static Trace<ContainerBuilder>;
14
15	public class ContainerBuilder {	6	public class ContainerBuilder {
16		7
17	readonly TypeResolver m_resolver;	8	readonly TypeResolver m_resolver;
@@ -36,7 +27,7 namespace Implab.ServiceHost.Unity {
36	}	27	}
37		28
38	public Type ResolveType(string typeReference) {	29	public Type ResolveType(string typeReference) {
39	return m_resolver.Resolve(typeReference);	30	return m_resolver.Resolve(typeReference, true);
40	}	31	}
41		32
42		33
@@ -91,16 +82,85 namespace Implab.ServiceHost.Unity {
91	);	82	);
92	}	83	}
93		84
94	internal void Visit(NamespaceElement namespaceElement) {	85	public void Visit(ITypeRegistration registration) {
95	m_resolver.AddNamespace(namespaceElement.Name);	86	Safe.ArgumentNotNull(registration, nameof(registration));
		87
		88	var registrationType = registration.GetRegistrationType(this);
		89	var implementationType = registration.GetImplementationType(this) ?? registrationType;
		90
		91	if (registrationType == null)
		92	throw new Exception($"A type must be specified for the registration {registration.Name}");
		93
		94	var builder = new TypeRegistrationBuilder(
		95	m_resolver,
		96	registrationType,
		97	implementationType
		98	);
		99
		100	builder.Lifetime = registration.GetLifetime(this);
		101
		102	if (registration.MemberInjections != null) {
		103	foreach(var member in registration.MemberInjections)
		104	member.Visit(builder);
		105	}
		106
		107	m_container.RegisterType(
		108	builder.RegistrationType,
		109	builder.ImplementationType,
		110	registration.Name,
		111	builder.Lifetime,
		112	builder.Injections
		113	);
96	}	114	}
97		115
98	internal void Visit(AssemblyElement assemblyElement) {	116	public void Visit(IInstanceRegistration registration) {
99	Assembly.Load(assemblyElement.AssemblyName);	117	Safe.ArgumentNotNull(registration, nameof(registration));
		118
		119	var registrationType = registration.GetRegistrationType(this);
		120
		121	var builder = new InstanceRegistrationBuilder (
		122	m_resolver,
		123	registrationType
		124	);
		125
		126	builder.Lifetime = registration.GetLifetime(this);
		127
		128	if (registration.MemberInjections != null) {
		129	foreach(var member in registration.MemberInjections)
		130	member.Visit(builder.ValueBuilder);
		131	}
		132
		133	if (builder.RegistrationType == null && builder.ValueBuilder.ValueType == null)
		134	throw new Exception($"A type must be specified for the registration {registration.Name}");
		135
		136	m_container.RegisterInstance(
		137	builder.RegistrationType ?? builder.ValueBuilder.ValueType,
		138	registration.Name,
		139	builder.ValueBuilder.Injection,
		140	builder.Lifetime
		141	);
100	}	142	}
101		143
102	internal void Visit(IncludeElement includeElement) {	144	public void Visit(IFactoryRegistration registration) {
103	Include(includeElement.Href);	145	Safe.ArgumentNotNull(registration, nameof(registration));
		146
		147	var registrationType = registration.GetRegistrationType(this);
		148
		149	var builder = new FactoryRegistrationBuilder(registrationType);
		150
		151	if (registration.MemberInjections != null) {
		152	foreach(var member in registration.MemberInjections)
		153	member?.Visit(builder);
		154	}
		155
		156	}
		157
		158	public void AddNamespace(string ns) {
		159	m_resolver.AddNamespace(ns);
		160	}
		161
		162	public void AddAssembly(string assembly) {
		163
104	}	164	}
105		165
106	public void Include(string file) {	166	public void Include(string file) {
@@ -110,9 +170,8 namespace Implab.ServiceHost.Unity {
110		170
111	public void LoadConfig(string file) {	171	public void LoadConfig(string file) {
112	var config = m_schema.LoadFile(file);	172	var config = m_schema.LoadFile(file);
113
114	config.Visit(this);	173	config.Visit(this);
115	}	174	}
116		175
117	}	176	}
118	} No newline at end of file	177	}

Implab.ServiceHost/Unity/ContainerConfigurationSchema.cs +1 0

                         var schema = new ContainerConfigurationSchema();
                         schema.RegisterContainerElement<RegisterElement>("register");
+                        schema.RegisterContainerElement<FactoryElement>("factory");
                         schema.RegisterContainerElement<SerializedElement>("serialized");
                         schema.RegisterContainerElement<ValueElement>("value");
                         schema.RegisterContainerElement<IncludeElement>("include");

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

                         get { return null; }
                     }
-                    public override void Visit(InjectionValueBuilder builder) {
+                    public override void Visit(InjectionParameterBuilder builder) {
                         var type = builder.ResolveInjectedValueType(TypeName);
                         builder.SetValue(type, Safe.CreateDefaultValue(type));
                     }

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

                     [XmlAttribute("optional")]
                     public bool Optional { get; set; }
-                    public override  void Visit(InjectionValueBuilder builder) {
+                    public override  void Visit(InjectionParameterBuilder builder) {
                         var type = builder.ResolveInjectedValueType(TypeName);
                         builder.SetDependencyReference(type, DependencyName, Optional);
                     }

Implab.ServiceHost/Unity/FactoryRegistrationBuilder.cs +18 0

                     internal FactoryRegistrationBuilder(Type registrationType) : base(registrationType) {
                     }
+                    /// <summary>
+                    /// Задает делегат, который будет использоваться в качестве фабрики
+                    /// для создания экземпляров, параметры делагата будет заполнены
+                    /// соответствующими зависимостями.
+                    /// </summary>
+                    /// <param name="factory">Фабрика для создания экземпляров.</param>
                     public void SetFactoryDelegate(Delegate factory) {
                         Safe.ArgumentNotNull(factory, nameof(factory));
                         Factory = new DelegateInjectionFactory(factory);
                     }
+                    /// <summary>
+                    /// Указывает зависимость типа <typeparamref name="T"/> с именем
+                    /// <paramref name="dependencyName"/>, которая будет передана в качетве
+                    /// параметра делегату <paramref name="factory"/>
+                    /// </summary>
+                    /// <param name="dependencyName">Имя зависимости</param>
+                    /// <param name="factory">Фабрика для создания экземпляра</param>
                     public void SetFactoryDependency<T>(string dependencyName, Func<T, object> factory) {
                         Safe.ArgumentNotNull(factory, nameof(factory));
                         });
                     }
+                    /// <summary>
+                    /// Указывает зависимость, реализующую интерфейс <see cref="IFactory{TObj}"/>,
+                    /// которая будет использоваться в качестве фабрики для создания объектов
+                    /// </summary>
+                    /// <param name="dependencyName"></param>
                     public void SetFactoryDependency<TFac, TObj>(string dependencyName) where TFac : IFactory<TObj> {
                         Factory = new InjectionFactory(c => c.Resolve<TFac>(dependencyName).Create());

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

                     [XmlAttribute("href")]
                     public string Href { get; set; }
-                    public override void Visit(ContainerBuilder context) {
+                    public override void Visit(ContainerBuilder builder) {
-                        context.Visit(this);
+                        builder.Include(Href);
                     }
                 }
             }

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

                     [XmlAttribute("type")]
                     public string TypeName { get; set; }
-                    public abstract void Visit(InjectionValueBuilder builder);
+                    public abstract void Visit(InjectionParameterBuilder builder);
                 }
             }

Implab.ServiceHost/Unity/InjectionValueBuilder.cs +9 -6

             namespace Implab.ServiceHost.Unity {
-                public class InjectionValueBuilder {
+                public class InjectionParameterBuilder {
                     readonly TypeResolver m_resolver;
                         }
                     }
-                    internal InjectionValueBuilder(TypeResolver resolver, Type defaultType) {
+                    internal InjectionParameterBuilder(TypeResolver resolver, Type defaultType) {
                         m_resolver = resolver;
                         DefaultType = defaultType;
                     }
                                 throw new Exception("The type must be specified");
                             return DefaultType;
                         }
-                        return m_resolver.Resolve(typeSpec);
+                        return m_resolver.Resolve(typeSpec, true);
                     }
                     public Type ResolveType(string typeSpec) {
-                        return m_resolver.Resolve(typeSpec);
+                        return m_resolver.Resolve(typeSpec, true);
                     }
                     public void SetValue(Type type, object value) {
                         InjectionParameterValue[] injections = (arrayParameter.Items ?? new InjectionParameterElement[0])
                             .Select(x => {
-                                var builder = new InjectionValueBuilder(m_resolver, itemsType);
+                                var builder = new InjectionParameterBuilder(m_resolver, itemsType);
                                 x.Visit(builder);
                                 return builder.Injection;
                             })
                             .ToArray();
-                        var array = itemsType.IsGenericParameter ? (object)new GenericResolvedArrayParameter(itemsType.Name, injections) : new ResolvedArrayParameter(itemsType, injections);
+                        var array = itemsType.IsGenericParameter ?
+                            (object)new GenericResolvedArrayParameter(itemsType.Name, injections) :
+                            new ResolvedArrayParameter(itemsType, injections);
                         ValueType = arrayType;
                         Value = array;
                     }

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

             {
                 public class InstanceRegistrationBuilder : RegistrationBuilder {
-                    public InjectionValueBuilder ValueBuilder { get; private set; }
+                    public InjectionParameterBuilder ValueBuilder { get; private set; }
                     internal InstanceRegistrationBuilder(TypeResolver typeResolver, Type registrationType) : base(registrationType) {
-                        ValueBuilder = new InjectionValueBuilder(typeResolver, registrationType);
+                        ValueBuilder = new InjectionParameterBuilder(typeResolver, registrationType);
                     }
                 }
             }

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

                     [XmlAttribute("name")]
                     public string Name { get; set; }
-                    public override void Visit(ContainerBuilder context) {
+                    public override void Visit(ContainerBuilder builder) {
-                        context.Visit(this);
+                        builder.AddNamespace(Name);
                     }
                 }
             }

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

                         throw new Exception("No content found, expected XML document");
                     }
-                    public override void Visit(InjectionValueBuilder builder) {
+                    public override void Visit(InjectionParameterBuilder builder) {
                         var type = builder.ResolveInjectedValueType(TypeName);
                         var serializer = new XmlSerializer(type);

Implab.ServiceHost/Unity/TypeReference.cs +164 -40

@@ -3,56 +3,180 using System.Linq;
3	using System.Text;	3	using System.Text;
4		4
5	namespace Implab.ServiceHost.Unity {	5	namespace Implab.ServiceHost.Unity {
6	public class TypeReference {	6	/// <summary>
7	public string TypeName { get; set; }	7	/// Ссылка на тип, является абстрактной записью имени CLR типа.
8		8	/// </summary>
9	public string Namespace { get; set; }	9	/// <remarks>
10		10	/// Ссылка на тип содержит сокращенную информацию о типе и для ее интерпретации
11	public TypeReference[] GenericParameters { get; set; }	11	/// требуется некоторый контекст, который позволит превратить ее в полноценный
12		12	/// <see cref="Type"/>. Ссылки на тип позволяют записать:
13	public bool IsArray { get; set; }	13	/// <list>
		14	/// <item><description>общие типы, их специализации</description></item>
		15	/// <item><description>вложенные типы</description></item>
		16	/// <item><description>массивы</description></item>
		17	/// </list>
		18	/// <para>
		19	/// Для получения из ссылки на тип конкретного CLR типа используется <see cref="TypeResolver.Resolve(TypeReference, bool)"/>.
		20	/// </para>
		21	/// <para>
		22	/// Ссылку на тип можно создать либо програмно при помощи методов <see cref="Create(string, string, int)"/>,
		23	/// <see cref="Create(string, int)"/>, <see cref="MakeArrayType(int)"/>, <see cref="MakeGenericType(TypeReference[])"/>,
		24	/// либо разобрав строку со спецификацией при помощи метода <see cref="Parse(string)"/>.
		25	/// </para>
		26	/// <para>
		27	/// Спецификация ссыдки на тип имеет следующий вид <c>Name.Space.MyType+Nested{String}[][]</c>, где:
		28	/// <list type="table">
		29	/// <item>
		30	/// <term><c>.</c></term>
		31	/// <description>Разделяет элементы пространства имен</description>
		32	/// <item>
		33	/// <item>
		34	/// <term><c>+</c></term>
		35	/// <description>Разделяет вложенные типы</description>
		36	/// <item>
		37	/// <item>
		38	/// <term><c>[]</c>, <c>[,,,]</c></term>
		39	/// <description>Указывает на то, что тип является массивом, также указывается его размерность</description>
		40	/// <item>
		41	/// <item>
		42	/// <term><c>{}</c>, <c>{,,}</c>, <c>{Int32,String}</c></term>
		43	/// <description>Указывает на то, что тип является общим, также
		44	/// указывается количество параметров, либо конкретные типы для
		45	/// специализации</description>
		46	/// <item>
		47	/// </list>
		48	/// </para>
		49	/// </remarks>
		50	public abstract class TypeReference {
14		51
15	public bool IsOpenGeneric {	52	/// <summary>
		53	/// Имя типа без дополнительных элементов, указывающих на то, что он общий или массив.
		54	/// </summary>
		55	/// <remarks>
		56	/// Для массивов это имя его элементов.
		57	/// </remarks>
		58	public abstract string Name { get; }
		59
		60	/// <summary>
		61	/// Пространство имен в котором нахожится тип.
		62	/// </summary>
		63	/// <remarks>
		64	/// Для вложенных типов это пространтство имен типа самого верхнего уровня,
		65	/// для массивов - пространство имен его элементов.
		66	/// </remarks>
		67	public abstract string Namespace { get; }
		68
		69	/// <summary>
		70	/// Количество параметров общего типа.
		71	/// </summary>
		72	/// <remarks>
		73	/// <para>
		74	/// Вложенные типы неявно получают параметры от типов в которых они объявлены,
		75	/// данное свойство это не учитывает, возвращается только количество собственных
		76	/// параметров.
		77	/// </para>
		78	/// <para>
		79	/// Данное свойство используется для получения CRL имени типа.
		80	/// </para>
		81	/// </remarks>
		82	public abstract int GenericParametersCount { get; }
		83
		84	public virtual string ClrName {
16	get {	85	get {
17	return GenericParameters!=~~null~~ && GenericParameters.~~Contains~~(~~null~~);	86	return GenericParametersCount != 0 ? $"{Name}`{GenericParametersCount}" : Name;
18	}
19	}
20
21	public bool IsGeneric {
22	get {
23	return GenericParameters != null && GenericParameters.Length > 0;
24	}	87	}
25	}	88	}
26		89
		90	/// <summary>
		91	/// Создает ссылку на специализацию текущего типа.
		92	/// </summary>
		93	/// <param name="genericParameters">Ссылки на типы, которые будут использоваться для специализации текущего типа.</param>
		94	/// <returns>Специализация данного типа.</returns>
		95	public virtual SpecializedTypeReference MakeGenericType(TypeReference[] genericParameters) {
		96	if (GenericParametersCount == 0)
		97	throw new InvalidOperationException("Can't specialize a non-geneic type");
		98
		99	if (genericParameters == null \|\| GenericParametersCount != genericParameters.Length)
		100	throw new InvalidOperationException("Generic parameters count mismatch");
		101
		102	return new SpecializedTypeReference(this, genericParameters);
		103	}
		104
		105	/// <summary>
		106	/// Создает ссылку на тип массива указанной размерности, элементами которого являются экземпаляры даннго типа.
		107	/// </summary>
		108	/// <param name="rank">Размерность, если размерность <c>1</c> создается вектор (<see cref="Type.MakeArrayType()"/>).</param>
		109	/// <returns>Ссылка на тип массива</returns>
		110	public ArrayTypeReference MakeArrayType(int rank) {
		111	Safe.ArgumentInRange(rank > 0, nameof(rank));
		112
		113	return new ArrayTypeReference(this, rank);
		114	}
		115
		116	/// <summary>
		117	/// Создает ссылку на вложенный тип.
		118	/// </summary>
		119	/// <param name="name">Имя типа</param>
		120	/// <param name="genericParameters">Количество параметров, если это общий тип, иначе 0.</param>
		121	/// <returns>Ссылка на вложенный тип.</returns>
		122	public TypeReference Create(string name, int genericParameters) {
		123	Safe.ArgumentNotEmpty(name, nameof(name));
		124	Safe.ArgumentInRange(genericParameters >= 0, nameof(genericParameters));
		125
		126	return new NestedTypeReference(this, name, genericParameters);
		127	}
		128
		129	/// <summary>
		130	/// Возвращает строковое представление ссылки на тип.
		131	/// </summary>
		132	/// <returns></returns>
27	public override string ToString() {	133	public override string ToString() {
28	var builder = new StringBuilder();	134	var builder = new StringBuilder();
29		135	WriteTypeName(builder);
30	if (!string.IsNullOrEmpty(Namespace)) {	136	WriteTypeParams(builder);
31	builder.Append(Namespace);
32	builder.Append('.');
33	}
34
35	if (!string.IsNullOrEmpty(TypeName)) {
36	builder.Append(TypeName);
37	} else {
38	builder.Append("__unnamed__");
39	}
40
41	if (GenericParameters != null && GenericParameters.Length > 0) {
42	builder.Append('{');
43	for(var i = 0; i < GenericParameters.Length; i++) {
44	if (i > 0)
45	builder.Append(',');
46	builder.Append(GenericParameters[i]);
47	}
48	builder.Append('}');
49	}
50
51	return builder.ToString();	137	return builder.ToString();
52	}	138	}
53	public static TypeReference Parse(string text) {	139
54	var parser = new TypeReferenceParser(text);	140	internal virtual void WriteTypeName(StringBuilder builder) {
		141	if (!string.IsNullOrEmpty(Namespace))
		142	builder
		143	.Append(Namespace)
		144	.Append('.');
		145	builder.Append(Name);
		146	}
		147
		148	internal virtual void WriteTypeParams(StringBuilder builder) {
		149	if (GenericParametersCount > 0)
		150	builder
		151	.Append('{')
		152	.Append(',', GenericParametersCount-1)
		153	.Append('}');
		154	}
		155
		156	internal abstract void Visit(TypeResolutionContext visitor);
		157
		158	/// <summary>
		159	/// Создает ссылку на тип.
		160	/// </summary>
		161	/// <param name="ns">Пространство имен, либо его фрагмент.</param>
		162	/// <param name="name">Имя типа без указания на количество параметров, либо на то, что это массив.</param>
		163	/// <param name="genericParameters">Количество параметров типа, если это общий тип, иначе 0.</param>
		164	/// <returns>Ссылка на тип.</returns>
		165	public static TypeReference Create(string ns, string name, int genericParameters) {
		166	Safe.ArgumentNotEmpty(name, nameof(name));
		167	Safe.ArgumentInRange(genericParameters >= 0, nameof(genericParameters));
		168	return new RootTypeReference(ns, name, genericParameters);
		169	}
		170
		171	/// <summary>
		172	/// Разирает строковую запись ссылки на тип.
		173	/// </summary>
		174	/// <param name="typeSpec">Строковая запись ссылки на тип, например <c>Dictionary{String,String}</c></param>
		175	/// <returns>Ссылка на тип.</returns>
		176	public static TypeReference Parse(string typeSpec) {
		177	var parser = new TypeReferenceParser(typeSpec);
55	return parser.Parse();	178	return parser.Parse();
56	}	179	}
		180
57	}	181	}
58	} No newline at end of file	182	}

Implab.ServiceHost/Unity/TypeReferenceParser.cs +86 -16

@@ -1,5 +1,6
1	using System;	1	using System;
2	using System.Collections.Generic;	2	using System.Collections.Generic;
		3	using System.Linq;
3	using System.Text.RegularExpressions;	4	using System.Text.RegularExpressions;
4		5
5	namespace Implab.ServiceHost.Unity {	6	namespace Implab.ServiceHost.Unity {
@@ -21,10 +22,12 namespace Implab.ServiceHost.Unity {
21		22
22	CloseArray,	23	CloseArray,
23		24
		25	Plus,
		26
24	Eof	27	Eof
25	}	28	}
26		29
27	readonly Regex _tokens = new Regex(@"([\w\+]+)\|\s([\.{},\[\]])\s");	30	readonly Regex _tokens = new Regex(@"\G(?:([\w]+)\|\s([\+\.{},\[\]])\s)", RegexOptions.Compiled);
28		31
29	TokenType m_token;	32	TokenType m_token;
30		33
@@ -83,6 +86,9 namespace Implab.ServiceHost.Unity {
83	case "]":	86	case "]":
84	m_token = TokenType.CloseArray;	87	m_token = TokenType.CloseArray;
85	break;	88	break;
		89	case "+":
		90	m_token = TokenType.Plus;
		91	break;
86	}	92	}
87	}	93	}
88	return true;	94	return true;
@@ -97,7 +103,7 namespace Implab.ServiceHost.Unity {
97	return result;	103	return result;
98	}	104	}
99		105
100	string[] ReadTypeName() {	106	string[] ReadQTypeName() {
101	var parts = new List<string>();	107	var parts = new List<string>();
102		108
103	string current = null;	109	string current = null;
@@ -129,31 +135,95 namespace Implab.ServiceHost.Unity {
129	return parts.ToArray();	135	return parts.ToArray();
130	}	136	}
131		137
		138	string ReadNQTypeName() {
		139	ReadToken();
		140	if (Token != TokenType.Word)
		141	ThrowUnexpectedToken();
		142	return TokenValue;
		143	}
		144
132	TypeReference ReadTypeReference() {	145	TypeReference ReadTypeReference() {
133		146
134	var parts = ReadTypeName();	147	var parts = ReadQTypeName();
135	if (parts == null)	148	if (parts == null)
136	return null;	149	return null;
137		150
138	var typeReference = new TypeReference {	151	var genericParameters = ReadGenericParams();
139	Namespace = string.Join(".", parts, 0, parts.Length - 1),	152
140	TypeName = parts[parts.Length - 1]	153	var typeReference = TypeReference.Create(
141	};	154	string.Join(".", parts, 0, parts.Length - 1),
		155	parts[parts.Length - 1],
		156	genericParameters.Length
		157	);
		158
		159	if (genericParameters.Length > 0 && genericParameters.All(x => x != null))
		160	typeReference = typeReference.MakeGenericType(genericParameters);
		161
		162	typeReference = ReadArraySpec(typeReference);
		163
		164	if(Token == TokenType.Plus)
		165	return ReadNestedType(typeReference);
		166
		167	return typeReference;
		168	}
		169
		170	TypeReference ReadNestedType(TypeReference declaringType) {
		171	var name = ReadNQTypeName();
		172	if(string.IsNullOrEmpty(name))
		173	throw new FormatException("Nested type name can't be empty");
		174	ReadToken();
		175
		176	var genericParameters = ReadGenericParams();
		177
		178	var typeReference = declaringType.Create(
		179	name,
		180	genericParameters.Length
		181	);
142		182
143	switch (Token) {	183	if (genericParameters.Length > 0 && genericParameters.All(x => x != null))
144	case TokenType.OpenList:	184	typeReference = typeReference.MakeGenericType(genericParameters);
145	typeReference.GenericParameters = ReadTypeReferenceList();	185
146	if (Token != TokenType.CloseList)	186	typeReference = ReadArraySpec(typeReference);
147	ThrowUnexpectedToken();	187
148	ReadToken();	188	if(Token == TokenType.Plus)
149	break;	189	return ReadNestedType(typeReference);
		190
		191	return typeReference;
		192	}
		193
		194	TypeReference[] ReadGenericParams() {
		195	if (Token == TokenType.OpenList) {
		196	var genericParameters = ReadTypeReferenceList();
		197	if (Token != TokenType.CloseList)
		198	ThrowUnexpectedToken();
		199	ReadToken();
		200
		201	return genericParameters;
		202	}
		203
		204	return Array.Empty<TypeReference>();
		205	}
		206
		207	TypeReference ReadArraySpec(TypeReference typeReference) {
		208	while (Token == TokenType.OpenArray) {
		209	var rank = CountRank();
		210	if (Token != TokenType.CloseArray)
		211	ThrowUnexpectedToken();
		212
		213	typeReference = typeReference.MakeArrayType(rank);
		214
		215	ReadToken();
150	}	216	}
151		217
152	return typeReference;	218	return typeReference;
153	}	219	}
154		220
155	int Count~~Dimentions~~() {	221	int CountRank() {
156	~~return~~ 0;	222	int rank = 0;
		223	do {
		224	rank++;
		225	} while(ReadToken() && Token == TokenType.Comma);
		226	return rank;
157	}	227	}
158		228
159	TypeReference[] ReadTypeReferenceList() {	229	TypeReference[] ReadTypeReferenceList() {

Implab.ServiceHost/Unity/TypeRegistrationBuilder.cs +4 -6

                         var parameters = constructorInjection.Parameters?
                             .Select(x => {
-                                var valueBuilder = new InjectionValueBuilder(m_resolver, null);
+                                var valueBuilder = new InjectionParameterBuilder(m_resolver, null);
                                 x.Visit(valueBuilder);
                                 return valueBuilder.Injection;
                             })
                     }
                     internal void Visit(MethodInjectionElement methodInjection) {
-                        var valueContext = new InjectionValueBuilder(m_resolver, null);
                         var parameters = methodInjection.Parameters?
                             .Select(x => {
-                                var valueBuilder = new InjectionValueBuilder(m_resolver, null);
+                                var valueBuilder = new InjectionParameterBuilder(m_resolver, null);
                                 x.Visit(valueBuilder);
                                 return valueBuilder.Injection;
                             })
                         if (propertyInjection.Value == null)
                             throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
-                        var propertyType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
+                        var propertyType = ImplementationType.GetProperty(propertyInjection.Name)?.PropertyType;
-                        var valueContext = new InjectionValueBuilder(m_resolver, propertyType);
+                        var valueContext = new InjectionParameterBuilder(m_resolver, propertyType);
                         propertyInjection.Value.Visit(valueContext);
                         var injection = new InjectionProperty(propertyInjection.Name, valueContext.Injection);

Implab.ServiceHost/Unity/TypeResolver.cs +36 -63

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

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

                         return string.IsNullOrEmpty(Value) ? Text : Value;
                     }
-                    public override void Visit(InjectionValueBuilder builder) {
+                    public override void Visit(InjectionParameterBuilder builder) {
                         var type = builder.ResolveInjectedValueType(TypeName);
                         builder.SetValue(type, TypeDescriptor.GetConverter(type).ConvertFromString(GetTextValue()));
                     }

Implab/Xml/SerializationHelpers.cs +13 -16

             namespace Implab.Xml {
                 public static class SerializationHelpers {
                     public static string SerializeAsString<T>(T obj) {
-                        return SerializersPool<T>.Instance.SerializeAsString(obj);
+                        return XmlDefaultSerializer<T>.Instance.SerializeAsString(obj);
                     }
                     public static void Serialize<T>(XmlWriter writer, T obj) {
-                        SerializersPool<T>.Instance.Serialize(writer, obj);
+                        XmlDefaultSerializer<T>.Instance.Serialize(writer, obj);
                     }
                     public static XmlDocument SerializeAsXmlDocument<T>(T obj) {
                         var doc = new XmlDocument();
                         using (var writer = doc.CreateNavigator().AppendChild()) {
-                            SerializersPool<T>.Instance.Serialize(writer, obj);
+                            XmlDefaultSerializer<T>.Instance.Serialize(writer, obj);
                         }
                         return doc;
                     }
                     public static XDocument SerializeAsXDocument<T>(T obj) {
                         var doc = new XDocument();
                         using (var writer = doc.CreateWriter()) {
-                            SerializersPool<T>.Instance.Serialize(writer, obj);
+                            XmlDefaultSerializer<T>.Instance.Serialize(writer, obj);
                         }
                         return doc;
                     }
                     public static void SerializeToFile<T>(string file, T obj) {
-                        using (var writer = File.CreateText(file))
+                        XmlDefaultSerializer<T>.Instance.SerializeToFile(obj, file);
-                            SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
                     public static void SerializeToElementChild<T>(XmlElement element, T obj) {
-                        using(var writer = element.CreateNavigator().AppendChild())
+                        XmlDefaultSerializer<T>.Instance.Serialize(obj, element);
-                            SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
                     public static T Deserialize<T>(XmlReader reader) {
-                        return SerializersPool<T>.Instance.Deserialize(reader);
+                        return (T)XmlDefaultSerializer<T>.Instance.Deserialize(reader);
                     }
                     public static T DeserializeFromFile<T>(string file) {
-                        using(var reader = XmlReader.Create(File.OpenText(file)))
+                        return (T)XmlDefaultSerializer<T>.Instance.DeserializeFromFile(file);
-                            return Deserialize<T>(reader);
                     }
                     public static T DeserializeFromString<T>(string data) {
-                        return SerializersPool<T>.Instance.DeserializeFromString(data);
+                        return (T)XmlDefaultSerializer<T>.Instance.DeserializeFromString(data);
                     }
                     public static T DeserializeFromXmlNode<T>(XmlNode node) {
                         Safe.ArgumentNotNull(node, nameof(node));
                         using (var reader = node.CreateNavigator().ReadSubtree())
-                            return SerializersPool<T>.Instance.Deserialize(reader);
+                            return (T)XmlDefaultSerializer<T>.Instance.Deserialize(reader);
                     }
                     public static T DeserializeJson<T>(TextReader textReader) {
                             FlattenArrays = true
                         };
-                        using(var reader = JsonXmlReader.CreateJsonXmlReader(textReader, options))
+                        using (var reader = JsonXmlReader.CreateJsonXmlReader(textReader, options))
                             return Deserialize<T>(reader);
                     }
                     public static T DeserializeJsonFromString<T>(string data) {
-                        using(var reader = new StringReader(data)) {
+                        using (var reader = new StringReader(data)) {
                             return DeserializeJson<T>(reader);
                         }
                     }
                     }
                     public static string SerializeJsonAsString<T>(T obj) {
-                        using(var writer = new StringWriter()) {
+                        using (var writer = new StringWriter()) {
                             SerializeJson(writer, obj);
                             return writer.ToString();
                         }

Implab/Xml/SerializersPool.cs +1 0

             using System.Xml.Serialization;
             namespace Implab.Xml {
+                [Obsolete("this class will be removed, use XmlDefaultSerializer")]
                 public class SerializersPool<T> : ObjectPool<XmlSerializer> {
                     static readonly SerializersPool<T> _instance = new SerializersPool<T>();

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