implab/ImplabNet Commit - r274:22629bf26121

Unity xml configuration, alpha2

cin -

r274:22629bf26121 v3

parent child

Context file:

r274:22629bf26121

Expand all files

Implab.ServiceHost/Unity/ContainerBuilder.cs created 644 +125 0

			@@ -0,0 +1,125
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Text.RegularExpressions;
		4	using Implab.Diagnostics;
		5
		6	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 {
		16
		17	readonly TypeResolver m_resolver;
		18
		19	readonly UnityContainer m_container;
		20
		21	readonly ContainerConfigurationSchema m_schema;
		22
		23	public UnityContainer Container {
		24	get {
		25	return m_container;
		26	}
		27	}
		28
		29	public ContainerBuilder() : this(null, null) {
		30	}
		31
		32	public ContainerBuilder(UnityContainer container, ContainerConfigurationSchema schema) {
		33	m_container = container ?? new UnityContainer();
		34	m_resolver = new TypeResolver();
		35	m_schema = schema ?? ContainerConfigurationSchema.Default;
		36	}
		37
		38	public Type ResolveType(string typeReference) {
		39	return m_resolver.Resolve(typeReference);
		40	}
		41
		42	internal void Visit(RegisterElement registerElement) {
		43	var registrationType = ResolveType(registerElement.RegistrationType);
		44	var implementationType = string.IsNullOrEmpty(registerElement.MapToType) ? registrationType : ResolveType(registerElement.MapToType);
		45
		46	var registrationContext = new TypeRegistrationBuilder(
		47	m_resolver,
		48	registrationType,
		49	implementationType
		50	);
		51
		52	if (registerElement.Injectors != null) {
		53	foreach (var injector in registerElement.Injectors) {
		54	injector.Visit(registrationContext);
		55	}
		56	}
		57
		58	m_container.RegisterType(
		59	registrationContext.RegistrationType,
		60	registrationContext.ImplementationType,
		61	registerElement.Name,
		62	registerElement.Lifetime?.GetLifetimeManager(this),
		63	registrationContext.Injections
		64	);
		65	}
		66
		67	internal void Visit(SerializedElement serializedElement) {
		68	var registrationType = ResolveType(serializedElement.RegistrationType);
		69	var valueBuilder = new InjectionValueBuilder(m_resolver, null);
		70
		71	valueBuilder.Visit(serializedElement);
		72
		73	m_container.RegisterInstance(
		74	registrationType,
		75	serializedElement.Name,
		76	valueBuilder.Value,
		77	serializedElement.Lifetime?.GetLifetimeManager(this)
		78	);
		79	}
		80
		81	internal void Visit(ValueElement valueElement) {
		82	var registrationType = ResolveType(valueElement.RegistrationType);
		83	var valueBuilder = new InjectionValueBuilder(m_resolver, null);
		84
		85	valueBuilder.Visit(valueElement);
		86
		87	m_container.RegisterInstance(
		88	registrationType,
		89	valueElement.Name,
		90	valueBuilder.Value,
		91	valueElement.Lifetime?.GetLifetimeManager(this)
		92	);
		93	}
		94
		95	internal void Visit(NamespaceElement namespaceElement) {
		96	m_resolver.AddNamespace(namespaceElement.Name);
		97	}
		98
		99	internal void Visit(AssemblyElement assemblyElement) {
		100	Assembly.Load(assemblyElement.AssemblyName);
		101	}
		102
		103	internal void Visit(IncludeElement includeElement) {
		104	Include(includeElement.Href);
		105	}
		106
		107	public void Include(string file) {
		108	var includeContext = new ContainerBuilder(m_container, m_schema);
		109	includeContext.LoadConfig(file);
		110	}
		111
		112	public void LoadConfig(string file) {
		113	var config = m_schema.LoadFile(file);
		114	Visit(config);
		115	}
		116
		117	internal void Visit(ContainerElement containerElement) {
		118	foreach (var item in containerElement.Items)
		119	item.Visit(this);
		120	}
		121
		122
		123
		124	}
		125	} No newline at end of file

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

			@@ -0,0 +1,7
		1	namespace Implab.ServiceHost.Unity {
		2	public class FactoryInjectionElement : AbstractInjectionElement {
		3	internal override void Visit(TypeRegistrationBuilder context) {
		4
		5	}
		6	}
		7	} No newline at end of file

Implab.ServiceHost/Unity/InjectionValueBuilder.cs created 644 +64 0

			@@ -0,0 +1,64
		1	using System;
		2	using System.ComponentModel;
		3	using System.Xml.Serialization;
		4	using Unity.Injection;
		5
		6	namespace Implab.ServiceHost.Unity {
		7
		8	public class InjectionValueBuilder {
		9
		10	readonly TypeResolver m_resolver;
		11
		12	public Type DefaultType { get; private set; }
		13
		14	public Type ValueType { get; set; }
		15
		16	public object Value { get; set; }
		17
		18	public InjectionParameterValue Injection {
		19	get {
		20	if (Value != null)
		21	return InjectionParameterValue.ToParameter(Value);
		22
		23	return new InjectionParameter(ValueType, null);
		24	}
		25	}
		26
		27	internal InjectionValueBuilder(TypeResolver resolver, Type acceptsType) {
		28	m_resolver = resolver;
		29	DefaultType = acceptsType;
		30	}
		31
		32	public Type ResolveType(string typeSpec) {
		33	if (string.IsNullOrEmpty(typeSpec)) {
		34	if (DefaultType == null)
		35	throw new Exception("The type must be specified");
		36	return DefaultType;
		37	}
		38	return m_resolver.Resolve(typeSpec);
		39	}
		40
		41	public void Visit(ITextValue value) {
		42	ValueType = ResolveType(value.TypeName);
		43
		44	Value = string.IsNullOrEmpty(value.Value) ?
		45	Safe.CreateDefaultValue(ValueType) :
		46	TypeDescriptor.GetConverter(ValueType).ConvertFromString(value.Value);
		47	}
		48
		49	public void Visit(ISerializedValue value) {
		50	ValueType = ResolveType(value.TypeName);
		51
		52	var serializer = new XmlSerializer(ValueType);
		53
		54	using (var reader = value.GetReader())
		55	Value = new InjectionParameter(ValueType, serializer.Deserialize(reader));
		56	}
		57
		58	public void Visit(IDependencyReference value) {
		59	ValueType = ResolveType(value.TypeName);
		60	Value = new ResolvedParameter(ValueType, value.DependencyName);
		61	}
		62
		63	}
		64	} No newline at end of file

Implab.ServiceHost/Unity/RegistrationBuilder.cs created 644 +21 0

			@@ -0,0 +1,21
		1	using System;
		2	using System.Collections.Generic;
		3	using System.ComponentModel;
		4	using System.Linq;
		5	using System.Xml.Serialization;
		6	using Implab.Xml;
		7	using Unity.Injection;
		8	using Unity.Registration;
		9
		10	namespace Implab.ServiceHost.Unity {
		11	public abstract class RegistrationBuilder {
		12	public Type RegistrationType {
		13	get;
		14	private set;
		15	}
		16
		17	protected RegistrationBuilder(Type registrationType) {
		18	RegistrationType = registrationType;
		19	}
		20	}
		21	} No newline at end of file

Implab.ServiceHost/Unity/TypeRegistrationBuilder.cs created 644 +77 0

			@@ -0,0 +1,77
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Linq;
		4	using Unity.Injection;
		5	using Unity.Registration;
		6
		7	namespace Implab.ServiceHost.Unity {
		8	public class TypeRegistrationBuilder : RegistrationBuilder {
		9
		10	readonly TypeResolver m_resolver;
		11
		12	readonly List<InjectionMember> m_injections = new List<InjectionMember>();
		13
		14	public InjectionMember[] Injections { get { return m_injections.ToArray(); } }
		15
		16	public Type ImplementationType {
		17	get;
		18	private set;
		19	}
		20
		21	internal TypeRegistrationBuilder(TypeResolver resolver, Type registrationType, Type implementationType) : base(registrationType) {
		22	ImplementationType = implementationType;
		23
		24	// when registering a generic mapping, register all generic parameter names as local types
		25	if (ImplementationType.IsGenericTypeDefinition) {
		26	m_resolver = new TypeResolver(resolver);
		27
		28	foreach (var p in ImplementationType.GetGenericArguments())
		29	m_resolver.AddMapping(p.Name, p);
		30	} else {
		31	m_resolver = resolver;
		32	}
		33	}
		34
		35	internal void Visit(ConstructorInjectionElement constructorInjection) {
		36
		37
		38	var parameters = constructorInjection.Parameters?
		39	.Select(x => {
		40	var valueBuilder = new InjectionValueBuilder(m_resolver, null);
		41	x.Visit(valueBuilder);
		42	return valueBuilder.Injection;
		43	})
		44	.ToArray();
		45
		46	var injection = parameters != null ? new InjectionConstructor(parameters) : new InjectionConstructor();
		47	m_injections.Add(injection);
		48	}
		49
		50	internal void Visit(MethodInjectionElement methodInjection) {
		51	var valueContext = new InjectionValueBuilder(m_resolver, null);
		52
		53	var parameters = methodInjection.Parameters?
		54	.Select(x => {
		55	var valueBuilder = new InjectionValueBuilder(m_resolver, null);
		56	x.Visit(valueBuilder);
		57	return valueBuilder.Injection;
		58	})
		59	.ToArray();
		60
		61	var injection = parameters != null ? new InjectionMethod(methodInjection.Name, parameters) : new InjectionMethod(methodInjection.Name);
		62	m_injections.Add(injection);
		63	}
		64
		65	internal void Visit(PropertyInjectionElement propertyInjection) {
		66	if (propertyInjection.Value == null)
		67	throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
		68
		69	var propertyType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
		70	var valueContext = new InjectionValueBuilder(m_resolver, propertyType);
		71
		72	propertyInjection.Value.Visit(valueContext);
		73	var injection = new InjectionProperty(propertyInjection.Name, valueContext.Injection);
		74	m_injections.Add(injection);
		75	}
		76	}
		77	} No newline at end of file

Implab.Playground/Program.cs +1 -1

                          var stopwatch = new Stopwatch();
                          stopwatch.Start();
-                         var ctx = new ContainerContext();
+                         var ctx = new ContainerBuilder();
                          Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");

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

                  </register>
                  <serialized type="Foo+Bar">
-                     <Bar id="1">
+                     <Bar xmlns="" id="1">
                          <Name>Baaar</Name>
                      </Bar>
                  </serialized>

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

              using System;
-             namespace Implab.ServiceHost.Unity
+             {
+             namespace Implab.ServiceHost.Unity {
+                 /// <summary>
+                 /// Base class for injections, each injection is applied to the type registration context.
+                 /// </summary>
                  public abstract class AbstractInjectionElement {
-                     internal abstract void Visit(TypeRegistrationContext context);
+                     internal abstract void Visit(TypeRegistrationBuilder context);
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/AbstractRegistration.cs 0 -4

                      [XmlAttribute("type")]
                      public string RegistrationType { get; set; }
-                     public virtual Type ResolveRegistrationType(ContainerContext ctx) {
-                         return ctx.Resolve(RegistrationType);
+                     }
                  }
              }
  No newline at end of file

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

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

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

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

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

                          var schema = new ContainerConfigurationSchema();
                          schema.RegisterContainerElement<RegisterElement>("register");
+                         schema.RegisterContainerElement<SerializedElement>("serialized");
+                         schema.RegisterContainerElement<ValueElement>("value");
                          schema.RegisterContainerElement<IncludeElement>("include");
                          schema.RegisterContainerElement<AssemblyElement>("assembly");
                          schema.RegisterContainerElement<NamespaceElement>("namespace");

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

                  [XmlRoot("container", Namespace = Schema.ContainerConfigurationNamespace)]
                  public class ContainerElement : ContainerItemElement {
-                     public List<ContainerItemElement> Items {get; set; } = new List<ContainerItemElement>();
+                     public List<ContainerItemElement> Items { get; set; } = new List<ContainerItemElement>();
-                     public override void Visit(ContainerContext context) {
+                     public override void Visit(ContainerBuilder context) {
                          context.Visit(this);
                      }
                  }

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

              namespace Implab.ServiceHost.Unity {
                  public abstract class ContainerItemElement {
-                     public abstract void Visit(ContainerContext context);
+                     public abstract void Visit(ContainerBuilder context);
                  }
              }
  No newline at end of file

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

              namespace Implab.ServiceHost.Unity
              {
                  public class ContainerLifetimeElement : LifetimeElement {
-                     public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
+                     public override LifetimeManager GetLifetimeManager(ContainerBuilder ctx) {
                          return new ContainerControlledLifetimeManager();
                      }
                  }

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

              namespace Implab.ServiceHost.Unity
              {
                  public class ContextLifetimeElement : LifetimeElement {
-                     public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
+                     public override LifetimeManager GetLifetimeManager(ContainerBuilder ctx) {
                          return new PerResolveLifetimeManager();
                      }
                  }

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

              namespace Implab.ServiceHost.Unity
              {
-                 public class DefaultParameterElement : InjectionParameterElement {
-                     internal override object Resolve(InjectionValueContext context) {
-                         var type = context.ResolveType(TypeName);
-                         return Safe.CreateDefaultValue(type);
+                 public class DefaultParameterElement : InjectionParameterElement, ITextValue {
+                     public string Value {
+                         get { return null; }
+                     }
+                     internal override void Visit(InjectionValueBuilder builder) {
+                         builder.Visit(this);
                      }
                  }
              }
  No newline at end of file

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

              using System.Xml.Serialization;
              namespace Implab.ServiceHost.Unity {
-                 public class DependencyParameterElement : InjectionParameterElement {
+                 public class DependencyParameterElement : InjectionParameterElement, IDependencyReference {
                      [XmlAttribute("name")]
                      public string DependencyName { get; set; }
                      [XmlAttribute("optional")]
                      public bool Optional { get; set; }
+                     internal override void Visit(InjectionValueBuilder builder) {
+                         builder.Visit(this);
+                     }
                  }
              }
  No newline at end of file

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

              namespace Implab.ServiceHost.Unity
              {
                  public class HierarchicalLifetimeElement : LifetimeElement {
-                     public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
+                     public override LifetimeManager GetLifetimeManager(ContainerBuilder ctx) {
                          return new HierarchicalLifetimeManager();
                      }
                  }

Implab.ServiceHost/Unity/IDependencyReference.cs +4 -1

              namespace Implab.ServiceHost.Unity {
                  public interface IDependencyReference {
-                     string Name { get; set; }
+                     string TypeName { get; set; }
+                     string DependencyName { get; set; }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/ISerializedValue.cs +9 -5

		@@ -1,7 +1,11
1		namespace Implab.ServiceHost.Unity
2		{
3		public class ISerializedValue
4		{
5
	1	using System.Xml;
	2
	3	namespace Implab.ServiceHost.Unity {
	4	public interface ISerializedValue {
	5
	6	string TypeName { get; }
	7
	8	XmlReader GetReader();
	9
6	10	}
7	11	} No newline at end of file

Implab.ServiceHost/Unity/ITextValue.cs +2 0

              namespace Implab.ServiceHost.Unity {
                  public interface ITextValue {
+                     string TypeName { get; }
                      string Value { get; }
                  }

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

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

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

                      [XmlAttribute("type")]
                      public string TypeName { get; set; }
-                     internal abstract object Resolve(InjectionValueContext context);
-                     public virtual Type ResolveParameterType(InjectionValueContext context) {
-                         return context.ResolveType(TypeName);
+                     }
+                     internal abstract void Visit(InjectionValueBuilder builder);
                  }
              }
  No newline at end of file

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

              {
                  public abstract class LifetimeElement
                  {
-                     public abstract LifetimeManager GetLifetimeManager(ContainerContext ctx);
+                     public abstract LifetimeManager GetLifetimeManager(ContainerBuilder ctx);
                  }
              }
  No newline at end of file

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

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

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

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

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

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

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

                      [XmlElement("method", typeof(MethodInjectionElement))]
                      public AbstractInjectionElement[] Injectors { get; set; }
-                     public override void Visit(ContainerContext context) {
+                     public override void Visit(ContainerBuilder context) {
                          context.Visit(this);
                      }
-                     public virtual Type ResolveImplementationType(ContainerContext ctx) {
-                         return string.IsNullOrEmpty(MapToType) ?
-                             ResolveRegistrationType(ctx) :
-                             ctx.Resolve(MapToType);
+                     }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/SerializedElement.cs +15 -16

              namespace Implab.ServiceHost.Unity
              {
-                 public class SerializedElement : AbstractRegistration {
+                 public class SerializedElement : AbstractRegistration, ISerializedValue {
                      [XmlAttribute("href")]
                      public string Location { get; set; }
                      [XmlAnyElement]
                      public XmlElement[] Content { get; set; }
-                     public override void Visit(ContainerContext context) {
+                     string ISerializedValue.TypeName {
+                         get {
+                             return string.IsNullOrEmpty(SerializedType) ? RegistrationType : SerializedType;
+                         }
+                     }
+                     public override void Visit(ContainerBuilder context) {
                          context.Visit(this);
                      }
-                     public virtual Type ResolveSerializedType(ContainerContext context) {
-                         if(string.IsNullOrEmpty(SerializedType))
-                             return ResolveRegistrationType(context);
-                         return context.Resolve(SerializedType);
+                     }
+                     public XmlReader GetReader() {
+                         if (!string.IsNullOrEmpty(Location))
+                             return XmlReader.Create(Location);
+                         if (Content != null && Content.Length > 0)
+                             return Content[0].CreateNavigator().ReadSubtree();
-                     public virtual object GetValue(ContainerContext context) {
-                         var type = ResolveRegistrationType(context);
-                         if (Content == null || Content.Length == 0)
-                             return Safe.CreateDefaultValue(type);
-                         var serializer = new XmlSerializer(type);
-                         using(var reader = Content[0].CreateNavigator().ReadSubtree())
-                             return serializer.Deserialize(reader);
+                         throw new Exception("No content found, expected XML document");
                      }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/SerializedParameterElement.cs +13 -3

+             using System;
              using System.Xml;
              using System.Xml.Schema;
              using System.Xml.Serialization;
              namespace Implab.ServiceHost.Unity
              {
-                 public class SerializedParameterElement : InjectionParameterElement {
+                 public class SerializedParameterElement : InjectionParameterElement, ISerializedValue {
                      [XmlAttribute("href")]
                      public string Location { get; set; }
                      [XmlAnyElement]
                      public XmlElement[] Content { get; set; }
-                     internal override object Resolve(RegistrationContext context) {
-                         return context.Resolve(this);
+                     public XmlReader GetReader() {
+                         if (!string.IsNullOrEmpty(Location))
+                             return XmlReader.Create(Location);
+                         if (Content != null && Content.Length > 0)
+                             return Content[0].CreateNavigator().ReadSubtree();
+                         throw new Exception("No content found, expected XML document");
+                     }
+                     internal override void Visit(InjectionValueBuilder builder) {
+                         builder.Visit(this);
                      }
                  }
              }
  No newline at end of file

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

              namespace Implab.ServiceHost.Unity
              {
                  public class SimgletonLifetimeElement : LifetimeElement {
-                     public override LifetimeManager GetLifetimeManager(ContainerContext ctx) {
+                     public override LifetimeManager GetLifetimeManager(ContainerBuilder ctx) {
                          return new SingletonLifetimeManager();
                      }
                  }

Implab.ServiceHost/Unity/ValueElement.cs +16 -2

              namespace Implab.ServiceHost.Unity {
                  public class ValueElement : AbstractRegistration, ITextValue {
-                     [XmlText]
-                     [XmlAttribute("value")]
                      public string Value { get; set; }
-                     public override void Visit(ContainerContext context) {
+                     [XmlText]
+                     public string Text { get; set; }
+                     string ITextValue.Value {
+                         get {
+                             return string.IsNullOrEmpty(Value) ? Text : Value;
+                         }
+                     }
+                     public string TypeName {
+                         get {
+                             return RegistrationType;
+                         }
+                     }
+                     public override void Visit(ContainerBuilder context) {
                          context.Visit(this);
                      }
                  }

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

              using System.Xml.Serialization;
-             namespace Implab.ServiceHost.Unity
+             {
-                 public class ValueParameterElement : InjectionParameterElement
+                 {
+             namespace Implab.ServiceHost.Unity {
+                 public class ValueParameterElement : InjectionParameterElement, ITextValue {
                      [XmlText]
                      [XmlAttribute("value")]
                      public string Value { get; set; }
-                     internal override object Resolve(RegistrationContext context) {
-                         return context.Resolve(this);
+                     internal override void Visit(InjectionValueBuilder builder) {
+                         builder.Visit(this);
                      }
                  }
              }
  No newline at end of file

Implab.ServiceHost/Unity/ContainerContext.cs removed 0 -111

NO CONTENT: file was removed

Implab.ServiceHost/Unity/InjectionValueContext.cs removed 0 -41

NO CONTENT: file was removed

Implab.ServiceHost/Unity/InstanceRegistrationContext.cs removed 0 -16

NO CONTENT: file was removed

Implab.ServiceHost/Unity/RegistrationContext.cs removed 0 -21

NO CONTENT: file was removed

Implab.ServiceHost/Unity/TypeRegistrationContext.cs removed 0 -65

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