adding ExportInitialize<T> for issue #120

src/Grace/DependencyInjection/IExportRegistrationBlockExtensions.cs

@@ -269,5 +269,26 @@ public static IExportRegistrationBlock ExcludeTypeFromAutoRegistration(this IExp
 
  return block;
  }
+
+ /// <summary>
+ /// Initialize all instance of a specific type
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="block"></param>
+ /// <param name="initializeAction"></param>
+ /// <returns></returns>
+ public static IExportRegistrationBlock ExportInitialize<T>(this IExportRegistrationBlock block,
+ Action<T> initializeAction)
+ {
+ var func = new Func<object,object>(instance =>
+ {
+ initializeAction((T) instance);
+ return instance;
+ });
+
+ block.AddInspector(new ExportInitializeInspector(func, typeof(T)));
+
+ return block;
+ }
  }
 }

src/Grace/DependencyInjection/Impl/ExportInitializeInspector.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+
+namespace Grace.DependencyInjection.Impl
+{
+ /// <summary>
+ /// Inspector that will apply an enrichment delegate to call strategies that are of a specific type
+ /// </summary>
+ public class ExportInitializeInspector : IActivationStrategyInspector
+ {
+ private readonly object _initializeDelegate;
+ private readonly Type _initializeType;
+
+ /// <summary>
+ /// Default constructor
+ /// </summary>
+ /// <param name="initializeDelegate"></param>
+ /// <param name="initializeType"></param>
+ public ExportInitializeInspector(object initializeDelegate, Type initializeType)
+ {
+ _initializeDelegate = initializeDelegate;
+ _initializeType = initializeType;
+ }
+
+ void IActivationStrategyInspector.Inspect<T>(T strategy)
+ {
+ if (strategy is ICompiledExportStrategy compiledExportStrategy)
+ {
+ if (_initializeType.GetTypeInfo().IsAssignableFrom(strategy.ActivationType.GetTypeInfo()))
+ {
+ compiledExportStrategy.EnrichmentDelegate(_initializeDelegate);
+ }
+ }
+ }
+ }
+}

src/Grace/DependencyInjection/Impl/Expressions/EnrichmentExpressionCreator.cs

@@ -47,7 +47,7 @@ public IActivationExpressionResult CreateExpression(IInjectionScope scope, IActi
 
  foreach (var parameter in invokeMethod.GetParameters())
  {
- if (parameter.ParameterType == expression.Type)
+ if (parameter.ParameterType.GetTypeInfo().IsAssignableFrom(expression.Type.GetTypeInfo()))
  {
  expressions.Add(expression);
  }
@@ -65,6 +65,11 @@ public IActivationExpressionResult CreateExpression(IInjectionScope scope, IActi
 
  expression = Expression.Call(Expression.Constant(enrichmentDelegate), invokeMethod,
  expressions);
+
+ if (activationConfiguration.ActivationType != expression.Type)
+ {
+ expression = Expression.Convert(expression, activationConfiguration.ActivationType);
+ }
  }
 
  result.Expression = expression;

tests/Grace.Tests/DependencyInjection/AddOns/ExportInitializeTests.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Grace.DependencyInjection;
+using Grace.Tests.Classes.Simple;
+using Xunit;
+
+namespace Grace.Tests.DependencyInjection.AddOns
+{
+ public class ExportInitializeTests
+ {
+ [Fact]
+ public void ExportInitialize_Type()
+ {
+ var container = new DependencyInjectionContainer();
+
+ container.Configure(c =>
+ {
+ c.ExportInitialize<BasicService>(service => service.Count = 10);
+ c.Export<BasicService>().As<IBasicService>();
+ });
+
+ var instance = container.Locate<IBasicService>();
+
+ Assert.NotNull(instance);
+ Assert.Equal(10, instance.Count);
+ }
+
+ [Fact]
+ public void ExportInitialize_Interface()
+ {
+ var container = new DependencyInjectionContainer();
+
+ container.Configure(c =>
+ {
+ c.ExportInitialize<IBasicService>(service => service.Count = 10);
+ c.Export<BasicService>();
+ });
+
+ var instance = container.Locate<BasicService>();
+
+ Assert.NotNull(instance);
+ Assert.Equal(10, instance.Count);
+ }
+
+ public interface IInjectable
+ {
+ void Injected();
+ }
+
+ public class ImplementationClass : IInjectable
+ {
+ public void Injected()
+ {
+ IntValue = 10;
+ }
+
+ public int IntValue { get; set; }
+ }
+
+ [Fact]
+ public void ExportInitialize_Dependent()
+ {
+ var container = new DependencyInjectionContainer();
+
+ container.Configure(c =>
+ {
+ c.ExportInitialize<IInjectable>(service => service.Injected());
+ });
+
+ var instance = container.Locate<DependentService<ImplementationClass>>();
+
+ Assert.NotNull(instance);
+ Assert.Equal(10, instance.Value.IntValue);
+ }
+
+
+ public class InheritBasicService : BasicService
+ {
+
+ }
+
+ [Fact]
+ public void ExportInitialize_Base()
+ {
+ var container = new DependencyInjectionContainer();
+
+ container.Configure(c =>
+ {
+ c.ExportInitialize<BasicService>(service => service.Count = 10);
+ c.Export<InheritBasicService>().As<IBasicService>();
+ });
+
+ var instance = container.Locate<IBasicService>();
+
+ Assert.NotNull(instance);
+ Assert.Equal(10, instance.Count);
+ Assert.IsType<InheritBasicService>(instance);
+ }
+ }
+}