implab/ImplabNet Commit - r292:807f0bc35f40

Fixed Safe.DisposeCollection NullReferenceException...

cin -

r292:807f0bc35f40 v3

parent child

Context file:

r292:807f0bc35f40

Collapse all files

Implab.ServiceHost/Implab.ServiceHost.csproj +1 -1

             <Project Sdk="Microsoft.NET.Sdk">
               <PropertyGroup>
                 <Authors>Sergey Smirnov</Authors>
                 <Title>Implab.ServiceHost</Title>
                 <Description>The configurable application host.
                 Provides simple and flexible Xml configuration for UnityContainer.
                 </Description>
                 <Copyright>2012-2018 Sergey Smirnov</Copyright>
-                <Version>1.0.1</Version>
+                <Version>1.0.3</Version>
                 <PackageLicenseUrl>https://bitbucket.org/wozard/implabnet/src/v3/Implab/license.txt</PackageLicenseUrl>
                 <PackageProjectUrl>https://bitbucket.org/wozard/implabnet</PackageProjectUrl>
                 <RepositoryUrl>https://bitbucket.org/wozard/implabnet</RepositoryUrl>
                 <RepositoryType>mercurial</RepositoryType>
                 <PackageTags>Implab;Xml configuration;IoC;Unity container</PackageTags>
               </PropertyGroup>
               <PropertyGroup Condition="'$(OSTYPE)'=='linux'">
                 <TargetFrameworks>netcoreapp2.0;net46</TargetFrameworks>
                 <FrameworkPathOverride Condition="'$(TargetFramework)'=='net46'">/usr/lib/mono/4.5/</FrameworkPathOverride>
               </PropertyGroup>
               <PropertyGroup Condition="'$(OSTYPE)'=='windows'">
                 <TargetFrameworks>netcoreapp2.0;net46</TargetFrameworks>
               </PropertyGroup>
               <ItemGroup>
                 <PackageReference Include="Unity" Version="5.8.6" />
               </ItemGroup>
               <ItemGroup>
                 <ProjectReference Include="..\Implab\Implab.csproj" />
               </ItemGroup>
             </Project>

Implab.ServiceHost/src/Unity/ContainerBuilder.cs +6 -1

             using System;
             using System.IO;
             using System.Reflection;
             using Implab.Diagnostics;
             using Unity;
             namespace Implab.ServiceHost.Unity {
                 using Log = Trace<ContainerBuilder>;
                 public class ContainerBuilder {
                     readonly TypeResolver m_resolver;
                     readonly IUnityContainer m_container;
                     readonly ContainerConfigurationSchema m_schema;
                     Uri m_location;
                     public IUnityContainer Container {
                         get {
                             return m_container;
                         }
                     }
                     public ContainerBuilder() : this(null, null) {
                     }
                     public ContainerBuilder(IUnityContainer container, ContainerConfigurationSchema schema) {
                         m_container = container ?? new UnityContainer();
                         m_resolver = new TypeResolver();
                         m_schema = schema ?? ContainerConfigurationSchema.Default;
                     }
                     public Type ResolveType(string typeReference) {
                         var resolved = string.IsNullOrEmpty(typeReference) ? null : m_resolver.Resolve(typeReference, true);
                         Log.Debug("ResolveType('{0}'): {1}", typeReference, resolved?.FullName);
                         return resolved;
                     }
                     public void Visit(ITypeRegistration registration) {
                         Safe.ArgumentNotNull(registration, nameof(registration));
                         var registrationType = registration.GetRegistrationType(this);
                         var implementationType = registration.GetImplementationType(this) ?? registrationType;
                         if (registrationType == null)
                             throw new Exception($"A type must be specified for the registration {registration.Name}");
                         var builder = new TypeRegistrationBuilder(
                             m_resolver,
                             registrationType,
                             implementationType,
                             this
                         );
                         builder.Lifetime = registration.GetLifetime(this);
                         if (registration.MemberInjections != null) {
                             foreach(var member in registration.MemberInjections)
                                 member.Visit(builder);
                         }
                         m_container.RegisterType(
                             builder.RegistrationType,
                             builder.ImplementationType,
                             registration.Name,
                             builder.Lifetime,
                             builder.Injections
                         );
                     }
                     public void Visit(IInstanceRegistration registration) {
                         Safe.ArgumentNotNull(registration, nameof(registration));
                         var registrationType = registration.GetRegistrationType(this);
                         var builder = new InstanceRegistrationBuilder (
                             m_resolver,
                             registrationType,
                             this
                         );
                         builder.Lifetime = registration.GetLifetime(this);
                         if (registration.MemberInjections != null) {
                             foreach(var member in registration.MemberInjections)
                                 member.Visit(builder.ValueBuilder);
                         }
                         if (builder.RegistrationType == null && builder.ValueBuilder.ValueType == null)
                             throw new Exception($"A type must be specified for the registration {registration.Name}");
                         m_container.RegisterInstance(
                             builder.RegistrationType ?? builder.ValueBuilder.ValueType,
                             registration.Name,
                             builder.ValueBuilder.Value,
                             builder.Lifetime
                         );
                     }
                     public void AddNamespace(string ns) {
                         m_resolver.AddNamespace(ns);
+                        Log.Log($"AddNamespace: {ns}");
                     }
                     public void AddAssembly(string assembly) {
+                        var asm = Assembly.Load(assembly);
+                        Log.Log($"AddAssembly: {assembly} -> {asm.FullName}");
                     }
                     /// <summary>
                     /// Includes the confguration. Creates a new <see cref="ContainerBuilder"/>,
                     /// and loads the configuration to it. The created builder will share the
                     /// container and will have its own isolated type resolver.
                     /// </summary>
                     /// <param name="file">A path to configuration relative to the current configuration.</param>
                     public void Include(string file) {
                         var includeContext = new ContainerBuilder(m_container, m_schema);
                         if (m_location != null) {
                             var uri =  new Uri(m_location, file);
                             includeContext.LoadConfig(uri);
                         } else {
                             includeContext.LoadConfig(file);
                         }
                     }
                     /// <summary>
                     /// Resolves a path ralatively to the current container configuration location.
                     /// </summary>
                     /// <param name="location">A path yto resolve</param>
                     /// <returns>Resolved Uri fot the specified location</returns>
                     public Uri MakeLocationUri(string location) {
                         return m_location != null ? new Uri(m_location, location) : new Uri(location);
                     }
                     /// <summary>
                     /// Loads a configuration from the specified local file.
                     /// </summary>
                     /// <param name="file">The path to the configuration file.</param>
                     public void LoadConfig(string file) {
                         Safe.ArgumentNotEmpty(file, nameof(file));
                         LoadConfig(new Uri(Path.GetFullPath(file)));
                     }
                     public void LoadConfig(Uri location) {
                         Safe.ArgumentNotNull(location, nameof(location));
+                        Log.Log($"LoadConfig {location}");
+                        Safe.ArgumentNotNull(location, nameof(location));
                         m_location = location;
                         var config = m_schema.LoadConfig(location.ToString());
                         config.Visit(this);
                     }
                 }
             }

Implab/src/Safe.cs +4 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) {
+                        if (objects != null)
                             foreach (var d in objects)
                                 if (d != null)
                                     d.Dispose();
                     }
                     public static void Dispose(params object[] objects) {
+                        if (objects != null)
                             foreach (var obj in objects) {
                                 var d = obj as IDisposable;
                                 if (d != null)
                                     d.Dispose();
                             }
                     }
                     public static void DisposeCollection(IEnumerable<IDisposable> objects) {
+                        if (objects != null)
                             foreach (var d in objects)
                                 Dispose(d);
                     }
                     public static void DisposeCollection(IEnumerable objects) {
+                        if (objects != null)
                             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