implab/ImplabNet Commit - r272:9d1cca834b05

preview version of Unity xml configuration

cin -

r272:9d1cca834b05 v3

parent child

Context file:

r272:9d1cca834b05

Collapse all files

Implab.ServiceHost/Unity/RegistrationContext.cs created 644 +119 0

@@ -0,0 +1,119
	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	class RegistrationContext {
	12	readonly TypeResolver m_resolver;
	13
	14	List<InjectionMember> m_injections = new List<InjectionMember>();
	15
	16	Type m_defaultType;
	17
	18	public Type RegistrationType {
	19	get;
	20	private set;
	21	}
	22
	23	public Type ImplementationType {
	24	get;
	25	private set;
	26	}
	27
	28	public RegistrationContext(TypeResolver resolver, string typeSpec, string implSpec) {
	29	RegistrationType = resolver.Resolve(string.IsNullOrEmpty(typeSpec) ? implSpec : typeSpec);
	30
	31
	32	ImplementationType = string.IsNullOrEmpty(implSpec) ? RegistrationType : resolver.Resolve(implSpec);
	33
	34	if (RegistrationType.IsGenericTypeDefinition) {
	35	m_resolver = new TypeResolver(resolver);
	36
	37	foreach (var p in ImplementationType.GetGenericArguments())
	38	m_resolver.AddMapping(p.Name, p);
	39	} else {
	40	m_resolver = resolver;
	41	}
	42
	43
	44	}
	45
	46	public InjectionMember[] Injections {
	47	get {
	48	return m_injections.ToArray();
	49	}
	50	}
	51
	52	public void Visit(ConstructorInjectionElement constructorInjection) {
	53	var parameters = constructorInjection.Parameters?.Select(x => x.Resolve(this)).ToArray();
	54
	55	var injection = parameters != null ? new InjectionConstructor(parameters) : new InjectionConstructor();
	56	m_injections.Add(injection);
	57	}
	58
	59	public void Visit(MethodInjectionElement methodInjection) {
	60	var parameters = methodInjection.Parameters?.Select(x => x.Resolve(this)).ToArray();
	61
	62	var injection = parameters != null ? new InjectionMethod(methodInjection.Name, parameters) : new InjectionMethod(methodInjection.Name);
	63	m_injections.Add(injection);
	64	}
	65
	66	public void Visit(PropertyInjectionElement propertyInjection) {
	67	if (propertyInjection.Value == null)
	68	throw new Exception($"A value value must be specified for the property '{propertyInjection.Name}'");
	69
	70	try {
	71	m_defaultType = RegistrationType.GetProperty(propertyInjection.Name)?.PropertyType;
	72
	73	var parameter = propertyInjection.Value.Resolve(this);
	74	var injection = new InjectionProperty(propertyInjection.Name, parameter);
	75	m_injections.Add(injection);
	76
	77	} finally {
	78	m_defaultType = null;
	79	}
	80
	81	}
	82
	83	Type ResolveParameterType(InjectionParameterElement injectionParameter) {
	84	if (string.IsNullOrEmpty(injectionParameter.TypeName)) {
	85	if (m_defaultType == null)
	86	throw new Exception($"A type must be specified for the parameter {injectionParameter}");
	87	return m_defaultType;
	88	}
	89	return m_resolver.Resolve(injectionParameter.TypeName);
	90	}
	91
	92	public object Resolve(DefaultParameterElement defaultParameter) {
	93	var type = ResolveParameterType(defaultParameter);
	94
	95	return Safe.CreateDefaultValue(type);
	96	}
	97
	98	public object Resolve(ValueParameterElement valueParameter) {
	99	var type = ResolveParameterType(valueParameter);
	100
	101	return TypeDescriptor.GetConverter(type).ConvertFromString(valueParameter.Value);
	102	}
	103
	104	public object Resolve(SerializedParameterElement serializedParameter) {
	105	var type = ResolveParameterType(serializedParameter);
	106	if (serializedParameter.Content == null \|\| serializedParameter.Content.Length == 0)
	107	return Safe.CreateDefaultValue(type);
	108
	109	var serializer = new XmlSerializer(type);
	110	using (var reader = serializedParameter.Content[0].CreateNavigator().ReadSubtree())
	111	return serializer.Deserialize(reader);
	112	}
	113
	114	public InjectionParameterValue Resolve(DependencyParameterElement dependencyParameter) {
	115	var type = ResolveParameterType(dependencyParameter);
	116	return new ResolvedParameter(type, dependencyParameter.DependencyName);
	117	}
	118	}
	119	} No newline at end of file

Implab.Playground/Program.cs +30 -2

             using System;
             using System.Diagnostics;
+            using System.Linq;
             using Implab.Diagnostics;
             using Implab.ServiceHost.Unity;
             using Implab.Xml;
             using Unity;
             using Unity.Injection;
+            using Unity.Registration;
             namespace Implab.Playground {
                 public class Foo {
                     public class Bar {
                     }
                     public string Name { get; set; }
                     public int IntValue { get; set; }
                     public string StringValue { get; set; }
                 }
-                public class Container<T> {
+                public interface IContainer<T> {
+                    T Instance { get; set; }
+                }
+                public class Container<T> : IContainer<T> {
                     public Container() {
                     }
                     public Container(T instance) {
                         Instance = instance;
                     }
                     public T Instance { get; set; }
                     public void SetInstance(T value) {
                         Instance = value;
                     }
                 }
                 public class Program {
                     static void Main(string[] args) {
                         var container = new UnityContainer();
                         var ctx = new ConfigurationContext(container);
                         var conf = SerializationHelpers.DeserializeFromFile<ContainerElement>("data/sample.xml");
                         ctx.Visit(conf);
-                        Console.WriteLine($"Registrations: {conf.Items.Count}");
+                        DisplayContainerRegistrations(container);
+                        var instace1 = container.Resolve<IContainer<string>>();
+                        var instace2 = container.Resolve<IContainer<Foo>>();
+                    }
+                    static void DisplayContainerRegistrations(IUnityContainer theContainer) {
+                        string regName, regType, mapTo, lifetime;
+                        Console.WriteLine("Container has {0} Registrations:",
+                                theContainer.Registrations.Count());
+                        foreach (ContainerRegistration item in theContainer.Registrations) {
+                            regType = item.RegisteredType.FullName;
+                            mapTo = item.MappedToType.FullName;
+                            regName = item.Name ?? "[default]";
+                            lifetime = item.LifetimeManager.LifetimeType.Name;
+                            if (mapTo != regType) {
+                                mapTo = " -> " + mapTo;
+                            } else {
+                                mapTo = string.Empty;
+                            }
+                            lifetime = lifetime.Substring(0, lifetime.Length - "LifetimeManager".Length);
+                            Console.WriteLine("+ {0}{1}  '{2}'  {3}", regType, mapTo, regName, lifetime);
+                        }
                     }
                 }
             }

Implab.Playground/data/sample.xml +8 -6

             <?xml version="1.0" encoding="UTF-8"?>
             <container xmlns="http://implab.org/schemas/servicehost/unity.v1.xsd">
+                <namespace name="System"/>
                 <namespace name="Implab.Playground"/>
                 <!-- foo1 -->
                 <register name="foo1" type="Foo">
                     <property name="Name">
                         <value>FOO!</value>
                     </property>
                 </register>
                 <!-- foo2 -->
                 <register name="foo2" type="Foo">
                     <property name="Name">
                         <value>GOOD</value>
                     </property>
                     <property name="IntValue">
                         <value>2</value>
                     </property>
                 </register>
                 <register type="Foo">
                 </register>
-                <register type="Container{}">
+                <register provides="IContainer{}" type="Container{}">
                     <constructor/>
                     <method name="SetInstance">
                         <dependency type="T"/>
                     </method>
                 </register>
-                <register type="Container{String}">
+                <register provides="IContainer{String}" type="Container{String}">
-                    <property name="Instance">
+                    <constructor/>
-                        <value>Hello!</value>
+                    <method name="SetInstance">
-                    </property>
+                        <value type="String">Hello!</value>
+                    </method>
                 </register>
             </container>

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

+            using System;
             namespace Implab.ServiceHost.Unity
             {
-                public abstract class AbstractInjectionElement
+                public abstract class AbstractInjectionElement {
+                    internal abstract void Visit(RegistrationContext context);
                 }
             }

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

             using System;
             using System.Xml.Serialization;
             using Unity.Lifetime;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity
             {
                 public abstract class AbstractRegistration : IConfigurationElement {
                     /// <summary>
                     /// An optional name for a registration in the container
                     /// </summary>
                     [XmlAttribute("name")]
                     public string Name {
                         get; set;
                     }
                     [XmlElement("signleton", typeof(SimgletonLifetimeElement))]
                     [XmlElement("context", typeof(ContextLifetimeElement))]
                     [XmlElement("container", typeof(ContainerLifetimeElement))]
                     [XmlElement("hierarchy", typeof(HierarchicalLifetimeElement))]
                     public LifetimeElement Lifetime {get; set;}
                     /// <summary>
                     /// A type specification for the service registration,
                     /// </summary>
                     [XmlAttribute("provides")]
                     public string ProvidesType { get; set; }
-                    public void Visit(ConfigurationContext context) {
+                    public abstract void Visit(ConfigurationContext context);
-                        context.Visit(this);
                 }
             }

Implab.ServiceHost/Unity/ConfigurationContext.cs +19 -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 global::Unity.Registration;
                 using Implab.Xml;
                 using static Trace<ConfigurationContext>;
                 public class ConfigurationContext {
                     readonly TypeResolver m_resolver;
+                    readonly UnityContainer m_container;
-                    readonly UnityContainer m_container;
                     public ConfigurationContext(UnityContainer container) {
                         m_container = container ?? new UnityContainer();
                         m_resolver = new TypeResolver();
                     }
                     public Type Resolve(string typeReference) {
                         return m_resolver.Resolve(TypeReference.Parse(typeReference));
                     }
-                    internal void Visit(AbstractRegistration descriptor) {
+                    internal void Visit(RegisterElement descriptor) {
+                        var registrationContext = new RegistrationContext(m_resolver, descriptor.ProvidesType, descriptor.ImplementationType);
+                        if (descriptor.Injectors != null) {
+                            foreach (var injector in descriptor.Injectors) {
+                                injector.Visit(registrationContext);
+                            }
+                        }
+                        m_container.RegisterType(
+                            registrationContext.RegistrationType,
+                            registrationContext.ImplementationType,
+                            descriptor.Name,
+                            descriptor.Lifetime?.GetLifetimeManager(this),
+                            registrationContext.Injections
+                        );
                     }
                     internal void Visit(NamespaceElement namespaceElement) {
                         m_resolver.AddNamespace(namespaceElement.Name);
                     }
                     internal void Visit(AssemblyElement assemblyElement) {
                         Assembly.Load(assemblyElement.AssemblyName);
                     }
                     internal void Visit(IncludeElement includeElement) {
                         Include(includeElement.Href);
                     }
                     public void Include(string file) {
                         var includeContext = new ConfigurationContext(m_container);
                         includeContext.LoadConfig(file);
                     }
                     public void LoadConfig(string file) {
                         var config = SerializationHelpers.DeserializeFromFile<ContainerElement>(file);
                         Visit(config);
                     }
                     public void Visit(ContainerElement containerElement) {
                         foreach (var item in containerElement.Items)
                             item.Visit(this);
                     }
                 }
             }

Implab.ServiceHost/Unity/ConstructorInjectionElement.cs +4 0

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class ConstructorInjectionElement : AbstractInjectionElement {
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
+                    internal override void Visit(RegistrationContext context) {
+                        context.Visit(this);
+                    }
                 }
             }

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

             namespace Implab.ServiceHost.Unity
             {
-                public class DefaultParameterElement : InjectionParameterElement
+                public class DefaultParameterElement : InjectionParameterElement {
+                    internal override object Resolve(RegistrationContext context) {
+                        return context.Resolve(this);
+                    }
                 }
             }

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

@@ -1,7 +1,16
1	namespace Implab.ServiceHost.Unity	1	using System.Xml.Serialization;
2	{	2
3	public class DependencyParameterElement : InjectionParameterElement	3	namespace Implab.ServiceHost.Unity {
4	{	4	public class DependencyParameterElement : InjectionParameterElement {
5		5
		6	[XmlAttribute("name")]
		7	public string DependencyName { get; set; }
		8
		9	[XmlAttribute("optional")]
		10	public bool Optional { get; set; }
		11
		12	internal override object Resolve(RegistrationContext context) {
		13	return context.Resolve(this);
		14	}
6	}	15	}
7	} No newline at end of file	16	}

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

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
-                public class InjectionParameterElement {
+                public abstract class InjectionParameterElement {
                     [XmlAttribute("type")]
                     public string TypeName { get; set; }
+                    internal abstract object Resolve(RegistrationContext context);
                 }
             }

Implab.ServiceHost/Unity/MethodInjectionElement.cs +3 0

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class MethodInjectionElement : AbstractInjectionElement {
                     [XmlAttribute("name")]
                     public string Name { get; set; }
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement[] Parameters { get; set; }
+                    internal override void Visit(RegistrationContext context) {
+                        context.Visit(this);
+                    }
                 }
             }

Implab.ServiceHost/Unity/PropertyInjectionElement.cs +7 0

             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity {
                 public class PropertyInjectionElement : AbstractInjectionElement {
+                    [XmlAttribute("name")]
+                    public string Name { get; set; }
                     [XmlElement("dependency", typeof(DependencyParameterElement))]
                     [XmlElement("value", typeof(ValueParameterElement))]
                     [XmlElement("serialized", typeof(SerializedParameterElement))]
                     [XmlElement("default", typeof(DefaultParameterElement))]
                     public InjectionParameterElement Value { get; set; }
+                    internal override void Visit(RegistrationContext context) {
+                        context.Visit(this);
+                    }
                 }
             }

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

             using System;
             using System.Xml.Serialization;
             using Unity.Lifetime;
             using Unity.Registration;
             namespace Implab.ServiceHost.Unity {
                 [XmlRoot("register", Namespace = Schema.ContainerConfigurationNamespace)]
                 public class RegisterElement : AbstractRegistration  {
                     /// <summary>
                     /// An optional type which is registered as a service in the container, must be assignable to <see cref="ProvidesType">.
                     /// </summary>
                     [XmlAttribute("type")]
-                    public string ImplementedType { get; set; }
+                    public string ImplementationType { get; set; }
                     [XmlElement("constructor", typeof(ConstructorInjectionElement))]
                     [XmlElement("property", typeof(PropertyInjectionElement))]
                     [XmlElement("method", typeof(MethodInjectionElement))]
                     public AbstractInjectionElement[] Injectors { get; set; }
+                    public override void Visit(ConfigurationContext context) {
+                        context.Visit(this);
+                    }
                 }
             }

Implab.ServiceHost/Unity/SerializedParameterElement.cs +4 0

             using System.Xml;
             using System.Xml.Schema;
             using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
                 public class SerializedParameterElement : InjectionParameterElement {
                     [XmlAnyElement]
                     public XmlElement[] Content { get; set; }
+                    internal override object Resolve(RegistrationContext context) {
+                        return context.Resolve(this);
+                    }
                 }
             }

Implab.ServiceHost/Unity/TypeResolver.cs +5 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using Implab.Diagnostics;
             namespace Implab.ServiceHost.Unity
             {
                 using static Trace<TypeResolver>;
                 public class TypeResolver
                 {
                     readonly Dictionary<string, Type> m_cache = new Dictionary<string, Type>();
                     Regex _nsRx = new Regex(@"^\w+(\.\w+)*$", RegexOptions.Compiled);
                     readonly LinkedList<string> m_namespases = new LinkedList<string>();
                     LinkedListNode<string> m_insertAt;
                     readonly TypeResolver m_parent;
                     public TypeResolver() : this(null) {
                     }
                     public TypeResolver(TypeResolver parent) {
+                        m_parent = parent;
                         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 void AddMapping(string typeName, Type type) {
                         Safe.ArgumentNotEmpty(typeName, nameof(typeName));
                         Safe.ArgumentNotNull(type, nameof(type));
                         m_cache[typeName] = type;
                     }
                     public Type Resolve(TypeReference reference) {
                         var args = reference.IsGeneric && !reference.IsOpenGeneric ? reference.GenericParameters?.Select(Resolve).ToArray() : null;
                         var argc = reference.IsGeneric ? reference.GenericParameters.Length : 0;
                         Type resolved;
                         if(!m_cache.TryGetValue(reference.ToString(), out resolved)) {
                             resolved = ResolveInternal(reference, args, argc);
                             if (resolved == null)
                                 throw new Exception($"Failed to resolve {reference}");
                             m_cache[reference.ToString()] = resolved;
                         }
                         return resolved;
                     }
+                    public Type Resolve(string typeSpec) {
+                        return Resolve(TypeReference.Parse(typeSpec));
+                    }
                     Type ResolveInternal(TypeReference reference, Type[] args, int argc) {
                         var resolved = ProbeInNamespaces(
                             String.Join(".", new [] { reference.Namespace, reference.TypeName }.Where(x => !string.IsNullOrEmpty(x)) ),
                             args,
                             argc,
                             reference.IsArray,
                             reference.ToString()
                         );
                         if (resolved == null && m_parent != null)
                             resolved = m_parent.Resolve(reference);
                         return resolved;
                     }
                     public Type ProbeInNamespaces(string localName, Type[] args, int argc, bool isArray, string referenceName) {
                         foreach (var ns in m_namespases) {
                             var typeName = FormatName(new [] { ns, localName}, argc, args, isArray);
                             var resolved = Probe(typeName);
                             if (resolved != null) {
                                 Log("Probe succeed {0} in '{1}': {2} -> {3}", referenceName, ns, typeName, resolved.AssemblyQualifiedName);
                                 return resolved;
                             } else {
                                 Log("Probe failed {0} in '{1}': {2}", referenceName, ns, typeName);
                             }
                         }
                         return null;
                     }
                     Type Probe(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.AssemblyQualifiedName}]")));
                             builder.Append(']');
                         }
                         if(isArray)
                             builder.Append("[]");
                             return builder.ToString();
                     }
                 }
             }

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

+            using System.Xml.Serialization;
             namespace Implab.ServiceHost.Unity
             {
                 public class ValueParameterElement : InjectionParameterElement
                 {
+                    [XmlText]
+                    public string Value { get; set; }
+                    internal override object Resolve(RegistrationContext context) {
+                        return context.Resolve(this);
+                    }
                 }
             }

Implab/Safe.cs +7 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             using System.Collections;
             using System.Runtime.CompilerServices;
             using System.Threading.Tasks;
             using System.Threading;
             #if NET_4_5
             using System.Threading.Tasks;
             #endif
             namespace Implab
             {
                 public static class Safe
                 {
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentAssert(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentException("The parameter is invalid", paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentMatch(string value, string paramName, Regex rx) {
                         if (rx == null)
                             throw new ArgumentNullException("rx");
                         if (!rx.IsMatch(value))
                             throw new ArgumentException(String.Format("The prameter value must match {0}", rx), paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentNotEmpty(string value, string paramName) {
                         if (String.IsNullOrEmpty(value))
                             throw new ArgumentException("The parameter can't be empty", paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentNotEmpty<T>(T[] value, string paramName) {
                         if (value == null || value.Length == 0)
                             throw new ArgumentException("The array must be not emty", paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentNotNull(object value, string paramName) {
                         if (value == null)
                             throw new ArgumentNullException(paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     internal static void ArgumentGreaterEqThan(int value, int min, string paramName) {
                         if (value < min)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
+                    public static object CreateDefaultValue(Type type) {
+                        if (type.IsValueType)
+                            return Activator.CreateInstance(type);
+                        return null;
+                    }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentInRange(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentOfType(object value, Type type, string paramName) {
                         if (!type.IsInstanceOfType(value))
                             throw new ArgumentException(String.Format("The parameter must be of type {0}", type), paramName);
                     }
                     public static void Dispose(params IDisposable[] objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(params object[] objects) {
                         foreach (var obj in objects) {
                             var d = obj as IDisposable;
                             if (d != null)
                                 d.Dispose();
                         }
                     }
                     public static void DisposeCollection(IEnumerable<IDisposable> objects) {
                         foreach (var d in objects)
                             Dispose(d);
                     }
                     public static void DisposeCollection(IEnumerable objects) {
                         foreach (var d in objects)
                             Dispose(d);
                     }
                     public static void Dispose(object obj) {
                         if (obj is IDisposable)
                             Dispose((IDisposable)obj);
                     }
                     [DebuggerStepThrough]
                     public static void DispatchEvent<T>(this EventHandler<T> handler, object sender, T args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     [DebuggerStepThrough]
                     public static void DispatchEvent(this EventHandler handler, object sender, EventArgs args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<T> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return Promise.Resolve(action());
                         } catch (Exception err) {
                             return Promise.Reject<T>(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Action action) {
                         ArgumentNotNull(action, "action");
                         try {
                             action();
                             return Promise.Resolve();
                         } catch (Exception err) {
                             return Promise.Reject(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Func<IPromise> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise.Reject(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise.Reject(err);
                         }
                     }
                     public static void NoWait(IPromise promise) {
                     }
                     public static void NoWait(Task promise) {
                     }
                     public static void NoWait<T>(Task<T> promise) {
                     }
                     public static void Noop() {
                     }
                     public static void Noop(CancellationToken ct) {
                         ct.ThrowIfCancellationRequested();
                     }
                     public static Task CreateTask() {
                         return new Task(Noop);
                     }
                     public static Task CreateTask(CancellationToken ct) {
                         return new Task(Noop, ct);
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise.Reject<T>(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise.Reject<T>(err);
                         }
                     }
                 }
             }

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