adding IMissingDependencyExpressionProvider for issue #169

src/Grace/DependencyInjection/IExportRegistrationBlock.cs

@@ -39,6 +39,12 @@ public interface IExportRegistrationBlock
  /// <param name="provider"></param>
  void AddMissingExportStrategyProvider(IMissingExportStrategyProvider provider);
 
+ /// <summary>
+ /// Add missing dependency expression provider
+ /// </summary>
+ /// <param name="provider"></param>
+ void AddMissingDependencyExpressionProvider(IMissingDependencyExpressionProvider provider);
+
  /// <summary>
  /// Add IInjectionValueProvider allowing the developer to override the normal behavior for creating an injection value
  /// </summary>

src/Grace/DependencyInjection/IInjectionScope.cs

@@ -51,6 +51,11 @@ public interface IInjectionScope : IExportLocatorScope
  /// </summary>
  IEnumerable<IMissingExportStrategyProvider> MissingExportStrategyProviders { get; }
 
+ /// <summary>
+ /// List of missing dependency expression providers
+ /// </summary>
+ IEnumerable<IMissingDependencyExpressionProvider> MissingDependencyExpressionProviders { get; }
+
  /// <summary>
  /// List of value providers that can be used during construction of linq expression
  /// </summary>

src/Grace/DependencyInjection/IMissingDependencyExpressionProvider.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Grace.DependencyInjection
+{
+ /// <summary>
+ /// Interface for providing linq expressions for missing dependencies
+ /// </summary>
+ public interface IMissingDependencyExpressionProvider
+ {
+ /// <summary>
+ /// Provide linq expression for the missing dependency
+ /// </summary>
+ /// <param name="scope"></param>
+ /// <param name="request"></param>
+ /// <returns>return expression or null if it's not possible</returns>
+ IActivationExpressionResult ProvideExpression(IInjectionScope scope,
+ IActivationExpressionRequest request);
+ }
+}

src/Grace/DependencyInjection/Impl/ExportRegistrationBlock.cs

@@ -17,6 +17,7 @@ public class ExportRegistrationBlock : IExportRegistrationBlockValueProvider
  private ImmutableLinkedList<IActivationStrategyInspector> _inspectors = ImmutableLinkedList<IActivationStrategyInspector>.Empty;
  private ImmutableLinkedList<IInjectionValueProvider> _valueProviders = ImmutableLinkedList<IInjectionValueProvider>.Empty;
  private ImmutableLinkedList<IMissingExportStrategyProvider> _missingExportStrategyProviders = ImmutableLinkedList<IMissingExportStrategyProvider>.Empty;
+ private ImmutableLinkedList<IMissingDependencyExpressionProvider> _missingDependencyExpressionProviders = ImmutableLinkedList<IMissingDependencyExpressionProvider>.Empty;
  private ImmutableLinkedList<IMemberInjectionSelector> _globalSelectors = ImmutableLinkedList<IMemberInjectionSelector>.Empty;
  private readonly IActivationStrategyCreator _strategyCreator;
  private IExportStrategyProvider _currentProvider;
@@ -106,6 +107,15 @@ public IEnumerable<IMissingExportStrategyProvider> GetMissingExportStrategyProvi
  return _missingExportStrategyProviders;
  }
 
+ /// <summary>
+ /// Get list of missing dependency expression provider
+ /// </summary>
+ /// <returns></returns>
+ public IEnumerable<IMissingDependencyExpressionProvider> GetMissingDependencyExpressionProviders()
+ {
+ return _missingDependencyExpressionProviders;
+ }
+
  /// <summary>
  /// Get list of value providers
  /// </summary>
@@ -578,6 +588,15 @@ public void AddMissingExportStrategyProvider(IMissingExportStrategyProvider prov
  _missingExportStrategyProviders = _missingExportStrategyProviders.Add(provider);
  }
 
+ /// <summary>
+ /// Add missing dependency expression provider
+ /// </summary>
+ /// <param name="provider"></param>
+ public void AddMissingDependencyExpressionProvider(IMissingDependencyExpressionProvider provider)
+ {
+ _missingDependencyExpressionProviders = _missingDependencyExpressionProviders.Add(provider);
+ }
+
  /// <summary>
  /// Add your own custom activation strategy
  /// </summary>
@@ -633,5 +652,6 @@ private void ProcessCurrentProvider()
  _currentProvider = null;
  }
  }
+
  }
 }

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

@@ -154,9 +154,17 @@ public virtual IActivationExpressionResult GetActivationExpression(IInjectionSco
  }
  }
 
- var parent = scope.Parent as IInjectionScope;
+ foreach (var scopeMissingDependencyExpressionProvider in scope.MissingDependencyExpressionProviders)
+ {
+ var result = scopeMissingDependencyExpressionProvider.ProvideExpression(scope, request);
 
- if (parent != null)
+ if (result != null)
+ {
+ return result;
+ }
+ }
+
+ if (scope.Parent is IInjectionScope parent)
  {
  return GetActivationExpression(parent, request);
  }
@@ -321,9 +329,9 @@ protected virtual IActivationExpressionResult GetValueFromRequest(IInjectionScop
 
  if (key is string keyString)
  {
- knownValue = 
- knownValues.FirstOrDefault(v => 
- string.Compare(keyString, v.Key as string,StringComparison.CurrentCultureIgnoreCase) == 0);
+ knownValue =
+ knownValues.FirstOrDefault(v =>
+ string.Compare(keyString, v.Key as string, StringComparison.CurrentCultureIgnoreCase) == 0);
  }
  else
  {
@@ -363,15 +371,15 @@ protected virtual IActivationExpressionResult GetValueFromRequest(IInjectionScop
  return knownValue.ValueExpression(request);
  }
  }
- 
+
  return knownValues[0].ValueExpression(request);
  }
 
  if (request.WrapperPathNode != null)
  {
  var configuration = request.WrapperPathNode.Strategy.GetActivationConfiguration(activationType);
 
- if (configuration.ActivationType != null && 
+ if (configuration.ActivationType != null &&
  activationType.GetTypeInfo().IsAssignableFrom(configuration.ActivationType.GetTypeInfo()))
  {
  var wrapper = request.PopWrapperPathNode();
@@ -412,7 +420,7 @@ protected virtual IActivationExpressionResult GetValueFromRequest(IInjectionScop
  return request.Services.Compiler.CreateNewResult(request, request.ScopeParameter);
  }
 
- if (request.ActivationType == typeof(IDisposalScope) || 
+ if (request.ActivationType == typeof(IDisposalScope) ||
  (request.ActivationType == typeof(IDisposable) &&
  request.RequestingScope.ScopeConfiguration.InjectIDisposable))
  {
@@ -576,7 +584,7 @@ protected virtual IActivationExpressionResult GetExpressionFromStrategyCollectio
  {
  var strategy = request.Filter == null ? collection.GetPrimary() : null;
 
- if (strategy != null && 
+ if (strategy != null &&
  strategy != request.RequestingStrategy)
  {
  var result = ActivationExpressionForStrategy(scope, request, strategy);

src/Grace/DependencyInjection/Impl/IExportRegistrationBlockValueProvider.cs

@@ -37,6 +37,12 @@ public interface IExportRegistrationBlockValueProvider : IExportRegistrationBloc
  /// <returns></returns>
  IEnumerable<IMissingExportStrategyProvider> GetMissingExportStrategyProviders();
 
+ /// <summary>
+ /// Get list of missing dependency expression providers
+ /// </summary>
+ /// <returns></returns>
+ IEnumerable<IMissingDependencyExpressionProvider> GetMissingDependencyExpressionProviders();
+
  /// <summary>
  /// Get list of value providers
  /// </summary>

src/Grace/DependencyInjection/Impl/InjectionScope.cs

@@ -400,6 +400,12 @@ public void Configure(Action<IExportRegistrationBlock> registrationBlock)
  InternalFieldStorage.MissingExportStrategyProviders = InternalFieldStorage.MissingExportStrategyProviders.Add(missingExportStrategyProvider);
  }
 
+ foreach (var expressionProvider in provider.GetMissingDependencyExpressionProviders())
+ {
+ InternalFieldStorage.MissingDependencyExpressionProviders =
+ InternalFieldStorage.MissingDependencyExpressionProviders.Add(expressionProvider);
+ }
+
  foreach (var injectionValueProvider in provider.GetValueProviders())
  {
  InternalFieldStorage.ValueProviders = InternalFieldStorage.ValueProviders.Add(injectionValueProvider);
@@ -471,6 +477,12 @@ public IActivationStrategyCollectionContainer<ICompiledDecoratorStrategy> Decora
  /// </summary>
  public IEnumerable<IMissingExportStrategyProvider> MissingExportStrategyProviders => InternalFieldStorage.MissingExportStrategyProviders;
 
+ /// <summary>
+ /// List of missing dependency expression providers
+ /// </summary>
+ public IEnumerable<IMissingDependencyExpressionProvider> MissingDependencyExpressionProviders =>
+ InternalFieldStorage.MissingDependencyExpressionProviders;
+
  /// <summary>
  /// List of value providers that can be used during construction of linq expression
  /// </summary>
@@ -854,6 +866,11 @@ protected class InternalFieldStorageClass
  /// </summary>
  public ImmutableLinkedList<IMemberInjectionSelector> MemberInjectionSelectors = ImmutableLinkedList<IMemberInjectionSelector>.Empty;
 
+ /// <summary>
+ /// List of missing dependency expression providers
+ /// </summary>
+ public ImmutableLinkedList<IMissingDependencyExpressionProvider> MissingDependencyExpressionProviders = ImmutableLinkedList<IMissingDependencyExpressionProvider>.Empty;
+
  /// <summary>
  /// Dynamic array locator
  /// </summary>