/// <summary>
/// Returns method that will call the function object.
/// </summary>
/// <param name="c"></param>
/// <param name="Arguments"></param>
/// <param name="FunctionName"></param>
/// <returns></returns>
public Func <object> FindFunction(IScopeContext c, IEnumerable <IExpression> Arguments, string fname)
{
// Get a list of all all functions that match the name we are using
var allFuncs = ListOfFuncsWithName(fname);
// Next, sort them by number of IExpression arguments. The more there are, the more we want to
// try first. This isn't perfect, but it does establish a very definite precedence order.
var byExpressionArgsUS = from m in allFuncs
group m by m.GetParameters().Where(p => p.ParameterType.Name == "IExpression").Count();
var byExpressionArgs = from g in byExpressionArgsUS
orderby g.Key descending
select g;
// Now, run down them and see which ones match.
var args = Arguments.Select(a => new FunctionUtils.ArgEvalHolder(c, a)).ToArray();
var method = (from mgroup in byExpressionArgs
from m in mgroup
where MatchArgList(m, args)
select m).FirstOrDefault();
if (method == null)
{
return(null);
}
return(() => method.Invoke(null, ArgList(c, args, method.GetParameters()).ToArray()));
}
/// <summary>
/// Make sure that everything fits
/// </summary>
/// <param name="c"></param>
public static void NormalizePlots(IScopeContext c)
{
c.ExecutionContext.AddPostCallHook("plot", "normalize", (obj, result) =>
{
var pc = result as DrawingContext;
if (pc == null)
return result;
pc.AddPreplotHook(plotContex =>
{
var histToDraw = plotContex.ObjectsToDraw
.Select(o => o.NTObject)
.Where(o => o is ROOTNET.Interface.NTH1)
.Cast<ROOTNET.Interface.NTH1>();
if (histToDraw.Count() > 1)
{
var max = histToDraw.Select(p => FindPlotMaximum(p)).Max();
max = max * 1.10;
foreach (var p in histToDraw)
{
p.Maximum = max;
}
}
});
return result;
});
}
/// <summary>
/// Turn off stat boxes if there is more than a single plot being shown.
/// </summary>
public static void TurnOffStatBoxesForMultiPlots(IScopeContext c)
{
c.ExecutionContext.AddPostCallHook("plot", "statsboxes", (obj, result) =>
{
var pc = result as DrawingContext;
if (pc == null)
return result;
pc.AddPreplotHook(plotContex =>
{
if (plotContex.ObjectsToDraw.Count() > 1)
{
foreach (var p in plotContex.ObjectsToDraw)
{
if (p.NTObject is ROOTNET.Interface.NTH1)
{
(p.NTObject as ROOTNET.Interface.NTH1).Stats = false;
}
}
}
});
return result;
});
}
/// <summary>
/// Is this a property name we know about, and can it do what we need it to do?
/// </summary>
/// <param name="c"></param>
/// <param name="obj"></param>
/// <param name="methodName"></param>
/// <param name="args"></param>
/// <returns></returns>
public Tuple <bool, object> Evaluate(IScopeContext c, object obj, string methodName, object[] args)
{
// If we have multiple arguments, then we aren't doing anything
if (args.Length > 1)
{
return(new Tuple <bool, object>(false, null));
}
// Get the type of the object
var t = obj.GetType();
// Now, see if we can't get the property name from there.
var property = t.GetProperty(methodName);
if (property == null)
{
return(new Tuple <bool, object>(false, null));
}
// Next, this is a get or set.
if (args.Length == 0 && property.CanRead)
{
return(new Tuple <bool, object>(true, property.GetValue(obj)));
}
if (args.Length == 1 && property.CanWrite)
{
property.SetValue(obj, args[0]);
return(new Tuple <bool, object>(true, obj));
}
// Failed if we got here!
return(new Tuple <bool, object>(false, null));
}
public CacheController(
IConfiguration _config,
IScopeContext _scopeContext,
IFarmRegionBusiness _busFarmRegion,
IFishPondBusiness _busFishPond,
IProductGroupBusiness _busProductGroup,
IProductSubgroupBusiness _busProductSubgroup,
IProductUnitBusiness _busProductUnit,
IExpenditureDocketTypeBusiness _busExpenditureDocketType,
IStockIssueDocketTypeBusiness _busStockIssueDocketType,
IStockReceiveDocketTypeBusiness _busStockReceiveDocketType,
ITaxPercentBusiness _busTaxPercent,
IWarehouseBusiness _busWarehouse,
IWarehouseTypeBusiness _busWarehouseType
)
{
config = _config;
context = _scopeContext;
busFarmRegion = _busFarmRegion;
busFishPond = _busFishPond;
busProductGroup = _busProductGroup;
busProductSubgroup = _busProductSubgroup;
busProductUnit = _busProductUnit;
busExpenditureDocketType = _busExpenditureDocketType;
busStockIssueDocketType = _busStockIssueDocketType;
busStockReceiveDocketType = _busStockReceiveDocketType;
busTaxPercent = _busTaxPercent;
busWarehouse = _busWarehouse;
busWarehouseType = _busWarehouseType;
}
/// <summary>
/// Returna plot that has as its content its value divided by its error, and zero errors.
/// </summary>
/// <param name="ctx"></param>
/// <param name="source"></param>
/// <returns></returns>
public static NTH1 asSigma(IScopeContext ctx, NTH1 plot)
{
var result = plot.Clone() as NTH1;
Tags.CopyTags(ctx, plot, result);
result.Reset();
// Besure to do the overflow bins as well.
for (int i_bin_x = 0; i_bin_x < result.NbinsX + 2; i_bin_x++)
{
for (int i_bin_y = 0; i_bin_y < result.NbinsY + 2; i_bin_y++)
{
for (int i_bin_z = 0; i_bin_z < result.NbinsZ + 2; i_bin_z++)
{
var v = plot.GetBinContent(i_bin_x, i_bin_y, i_bin_z);
var e = plot.GetBinError(i_bin_x, i_bin_y, i_bin_z);
var sig = e == 0 ? 0.0 : v / e;
result.SetBinContent(i_bin_x, i_bin_y, i_bin_z, sig);
}
}
}
return(result);
}
/// <summary>
/// Add two dictionaries together. We just try to loop over everything one at a time.
/// </summary>
/// <param name="ctx"></param>
/// <param name="o1"></param>
/// <param name="o2"></param>
/// <returns></returns>
public static Dictionary <object, object> OperatorPlus(IScopeContext ctx, IDictionary <object, object> o1, IDictionary <object, object> o2)
{
var r = new Dictionary <object, object>();
foreach (var k in o1.Keys.Concat(o2.Keys).Distinct())
{
object v1 = null;
object v2 = null;
o1.TryGetValue(k, out v1);
o2.TryGetValue(k, out v2);
object opresult = null;
if (v1 == null)
{
opresult = v2;
}
else if (v2 == null)
{
opresult = v1;
}
else
{
var calc = new FunctionExpression("+", new ObjectValue(v1), new ObjectValue(v2));
opresult = calc.Evaluate(ctx);
}
if (opresult != null)
{
r[k] = opresult;
}
}
return(r);
}
/// <summary>
/// Open a local file. Only a local file.
/// </summary>
/// <param name="fname"></param>
/// <returns></returns>
public static object file(IScopeContext c, string fname)
{
// See if we can locate the file. If a relative path look relative to the
// script directory.
FileInfo fi = null;
if (Path.IsPathRooted(fname))
{
fi = new FileInfo(fname);
}
else
{
// Located near the script?
fi = new FileInfo(Path.Combine(c.ExecutionContext.CurrentScriptFile.DirectoryName, fname));
if (!fi.Exists)
{
fi = new FileInfo(fname);
}
}
if (!fi.Exists)
{
throw new ArgumentException(string.Format("Unable to locate file {0}.", fi.FullName));
}
var f = ROOTNET.NTFile.Open(fi.FullName);
if (f == null || !f.IsOpen())
{
throw new ArgumentException(string.Format("ROOT is unable to open file {0}.", fi.FullName));
}
return(f);
}
/// <summary>
/// Internal function to hide looking at all function objects.
/// </summary>
/// <param name="c"></param>
/// <param name="arguments"></param>
/// <param name="functionName"></param>
/// <returns></returns>
private Func <object> FindFunction(IScopeContext c, IEnumerable <IExpression> arguments, string functionName)
{
return(ExtensibilityControl.Get().FunctionFinders
.Select(ff => ff.FindFunction(c, arguments, functionName))
.Where(f => f != null)
.FirstOrDefault());
}
/// <summary>Inserts scoped container into pipeline and stores scoped container in context.
///
/// Optionally registers instances in scope with provided action.</summary>
/// <param name="app">App builder</param> <param name="container">Container</param>
/// <param name="registerInScope">(optional) Action for registering something in scope before setting scope into context.</param>
/// <param name="scopeContext">(optional) Specific scope context to use.
/// If not specified using current container context. <see cref="AsyncExecutionFlowScopeContext"/> is default in .NET 4.5.</param>
public static void UseDryIocOwinMiddleware(
this IAppBuilder app, IContainer container,
Action <IContainer> registerInScope = null,
IScopeContext scopeContext = null)
{
if (container.ScopeContext == null)
{
container = container.With(scopeContext: scopeContext ?? new AsyncExecutionFlowScopeContext());
}
app.Use(async(context, next) =>
{
using (var scope = container.OpenScope(Reuse.WebRequestScopeName))
{
scope.UseInstance(context);
if (registerInScope != null)
{
registerInScope(scope);
}
context.Set(ScopedContainerKeyInContext, scope);
await next();
}
});
app.UseRegisteredMiddlewares(container);
}
/// <summary>
/// Evaluate a string value.
/// </summary>
/// <param name="c"></param>
/// <returns></returns>
public object Evaluate(IScopeContext c)
{
// Find all variable subsitutions that have to be done in the string.
var myl = _content;
var m = _findVarSub.Match(myl);
while (m != null && m.Success)
{
var vname = m.Groups[1].Value;
object result = null;
try
{
var exprTree = Grammar.ExpressionParser.End().Parse(vname);
result = exprTree.Evaluate(c);
}
catch { }
int position = m.Groups[1].Index;
if (result != null)
{
var s = result.ToString();
myl = myl.Replace("{" + vname + "}", s);
position += s.Length - 1;
}
else
{
position += m.Groups[1].Length;
}
m = position > myl.Length ? null : _findVarSub.Match(myl, position);
}
return(myl);
}
/// <summary>
/// Include antoher source file. It is loaded and executed immediately, in the same global
/// context.
/// </summary>
/// <param name="filename">Filename to include, if relative, w.r.t. the initially invoked script.</param>
/// <returns>Returns whatever the last statement of the script returns.</returns>
public static object include(IScopeContext c, string filename)
{
var content = FileOperations.readfile(c, filename);
// Parse for comments, etc.
var sb = new StringBuilder();
using (var rdr = (new StringReader(content)))
{
foreach (var l in rdr.ReadFromReader())
{
sb.AppendLine(l);
}
}
// Now, push the script context, and off we go.
c.ExecutionContext.ScriptFileContextPush(new FileInfo(filename));
try
{
return(eval(c, sb.ToString()));
}
finally
{
c.ExecutionContext.ScriptFileContextPop();
}
}
public void ScopeContextEnlist(bool complete)
{
ScopeProvider scopeProvider = ScopeProvider;
bool? completed = null;
IScope ambientScope = null;
IScopeContext ambientContext = null;
Assert.IsNull(scopeProvider.AmbientScope);
using (IScope scope = scopeProvider.CreateScope())
{
scopeProvider.Context.Enlist("name", c =>
{
completed = c;
ambientScope = scopeProvider.AmbientScope;
ambientContext = scopeProvider.AmbientContext;
});
if (complete)
{
scope.Complete();
}
}
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(scopeProvider.AmbientContext);
Assert.IsNotNull(completed);
Assert.AreEqual(complete, completed.Value);
Assert.IsNull(ambientScope); // the scope is gone
Assert.IsNotNull(ambientContext); // the context is still there
}
/// <inheritdoc />
public IScope DetachScope()
{
Scope ambientScope = AmbientScope;
if (ambientScope == null)
{
throw new InvalidOperationException("There is no ambient scope.");
}
if (ambientScope.Detachable == false)
{
throw new InvalidOperationException("Ambient scope is not detachable.");
}
PopAmbientScope(ambientScope);
PopAmbientScopeContext();
Scope originalScope = AmbientScope;
if (originalScope != ambientScope.OrigScope)
{
throw new InvalidOperationException($"The detatched scope ({ambientScope.GetDebugInfo()}) does not match the original ({originalScope.GetDebugInfo()})");
}
IScopeContext originalScopeContext = AmbientContext;
if (originalScopeContext != ambientScope.OrigContext)
{
throw new InvalidOperationException($"The detatched scope context does not match the original");
}
ambientScope.OrigScope = null;
ambientScope.OrigContext = null;
ambientScope.Attached = false;
return(ambientScope);
}
/// <inheritdoc />
public IScope CreateScope(
IsolationLevel isolationLevel = IsolationLevel.Unspecified,
RepositoryCacheMode repositoryCacheMode = RepositoryCacheMode.Unspecified,
IScopedNotificationPublisher notificationPublisher = null,
bool?scopeFileSystems = null,
bool callContext = false,
bool autoComplete = false)
{
Scope ambientScope = AmbientScope;
if (ambientScope == null)
{
IScopeContext ambientContext = AmbientContext;
ScopeContext newContext = ambientContext == null ? new ScopeContext() : null;
var scope = new Scope(this, _coreDebugSettings, _eventAggregator, _loggerFactory.CreateLogger <Scope>(), _fileSystems, false, newContext, isolationLevel, repositoryCacheMode, notificationPublisher, scopeFileSystems, callContext, autoComplete);
// assign only if scope creation did not throw!
PushAmbientScope(scope);
if (newContext != null)
{
PushAmbientScopeContext(newContext);
}
return(scope);
}
var nested = new Scope(this, _coreDebugSettings, _eventAggregator, _loggerFactory.CreateLogger <Scope>(), _fileSystems, ambientScope, isolationLevel, repositoryCacheMode, notificationPublisher, scopeFileSystems, callContext, autoComplete);
PushAmbientScope(nested);
return(nested);
}
// protected TelemetryClient clienteTelemetria { get; }
protected BaseController(IMediator mediator, IStringLocalizer <I18n> dicionario, IScopeContext scopeContext)
{
Mediator = mediator;
Dicionario = dicionario;
ScopeContext = scopeContext;
// this.clienteTelemetria = clienteTelemetria;
}
public void ScopeContextEnlistAgain(bool complete)
{
ScopeProvider scopeProvider = ScopeProvider;
bool?completed = null;
bool?completed2 = null;
Assert.IsNull(scopeProvider.AmbientScope);
using (IScope scope = scopeProvider.CreateScope())
{
scopeProvider.Context.Enlist("name", c =>
{
completed = c;
// at that point the scope is gone, but the context is still there
IScopeContext ambientContext = scopeProvider.AmbientContext;
ambientContext.Enlist("another", c2 => completed2 = c2);
});
if (complete)
{
scope.Complete();
}
}
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(scopeProvider.AmbientContext);
Assert.IsNotNull(completed);
Assert.AreEqual(complete, completed.Value);
Assert.AreEqual(complete, completed2.Value);
}
/// <summary>
/// Given a 2D plot, map to a 1D plot assuming radial distances.
/// </summary>
/// <param name="ctx"></param>
/// <param name="plot"></param>
/// <returns>1D plot of the 2D plot</returns>
/// <remarks>
/// - Radial conversion assumes that both coordinates are the same units. For example, if they are x and y distances.
/// - Overflow & underflow bins are not handled.
/// - Errors are not properly handled.
/// </remarks>
public static ROOTNET.Interface.NTH1 asRadial(IScopeContext ctx, ROOTNET.Interface.NTH2 plot)
{
// First, determine the distances
var xmin = plot.Xaxis.GetBinLowEdge(1);
var ymin = plot.Yaxis.GetBinLowEdge(1);
var xmax = plot.Xaxis.GetBinUpEdge(plot.Xaxis.Nbins);
var ymax = plot.Yaxis.GetBinUpEdge(plot.Yaxis.Nbins);
var rmin = Math.Sqrt(xmin * xmin + ymin * ymin);
var rmax = Math.Sqrt(xmax * xmax + ymax * ymax);
var nbin = Math.Max(plot.Xaxis.Nbins, plot.Yaxis.Nbins);
var result = new ROOTNET.NTH1F(plot.Name, plot.Title, nbin, rmin, rmax);
// Loop over, adding everything in.
for (int i_x = 1; i_x <= plot.Xaxis.Nbins; i_x++)
{
for (int i_y = 1; i_y <= plot.Yaxis.Nbins; i_y++)
{
var x = plot.Xaxis.GetBinCenter(i_x);
var y = plot.Yaxis.GetBinCenter(i_y);
var r = Math.Sqrt(x * x + y * y);
result.Fill(r, plot.GetBinContent(i_x, i_y));
}
}
return(result);
}
public ProductService(
FLSDbContext _context,
IScopeContext _scopeContext
) : base(_context, _scopeContext)
{
context = _context;
scopeContext = _scopeContext;
}
/// <summary>
/// Scale the contents of a histogram up or down.
/// </summary>
/// <param name="h"></param>
/// <param name="scaleFactor"></param>
/// <returns></returns>
public static ROOTNET.Interface.NTH1 OperatorMultiply(IScopeContext ctx, ROOTNET.Interface.NTH1 h, double scaleFactor)
{
var clone = h.Clone() as ROOTNET.Interface.NTH1;
clone.Scale(scaleFactor);
Tags.CopyTags(ctx, h, clone);
return(clone);
}
/// <summary>
/// Rebin by a factor
/// </summary>
/// <param name="ctx"></param>
/// <param name="plot"></param>
/// <returns></returns>
public static ROOTNET.Interface.NTH1 rebin(IScopeContext ctx, ROOTNET.Interface.NTH1 plot, int rebinFactor)
{
var np = plot.Clone() as ROOTNET.Interface.NTH1;
Tags.CopyTags(ctx, plot, np);
np.Rebin(rebinFactor);
return(np);
}
/// <summary>
/// Set the minimum value for a plot
/// </summary>
/// <param name="ctx"></param>
/// <param name="plot"></param>
/// <param name="value"></param>
/// <returns></returns>
public static ROOTNET.Interface.NTH1 minimum(IScopeContext ctx, ROOTNET.Interface.NTH1 plot, double value)
{
var np = plot.Clone() as ROOTNET.Interface.NTH1;
Tags.CopyTags(ctx, plot, np);
np.Minimum = value;
return(np);
}
public async Task Invoke(
HttpContext httpContext,
IScopeContext context
)
{
context.AddHttpContext(httpContext);
await _next(httpContext);
}
static public int GetMeContext(IScopeContext c)
{
if (c == null)
{
return(0);
}
return(12);
}
public void DetachableScope()
{
ScopeProvider scopeProvider = ScopeProvider;
Assert.IsNull(scopeProvider.AmbientScope);
using (IScope scope = scopeProvider.CreateScope())
{
Assert.IsInstanceOf <Scope>(scope);
Assert.IsNotNull(scopeProvider.AmbientScope);
Assert.AreSame(scope, scopeProvider.AmbientScope);
Assert.IsNotNull(scopeProvider.AmbientContext); // the ambient context
Assert.IsNotNull(scopeProvider.Context); // the ambient context too (getter only)
IScopeContext context = scopeProvider.Context;
IScope detached = scopeProvider.CreateDetachedScope();
scopeProvider.AttachScope(detached);
Assert.AreEqual(detached, scopeProvider.AmbientScope);
Assert.AreNotSame(context, scopeProvider.Context);
// nesting under detached!
using (IScope nested = scopeProvider.CreateScope())
{
Assert.Throws <InvalidOperationException>(() =>
// cannot detach a non-detachable scope
scopeProvider.DetachScope());
nested.Complete();
}
Assert.AreEqual(detached, scopeProvider.AmbientScope);
Assert.AreNotSame(context, scopeProvider.Context);
// can detach
Assert.AreSame(detached, scopeProvider.DetachScope());
Assert.AreSame(scope, scopeProvider.AmbientScope);
Assert.AreSame(context, scopeProvider.AmbientContext);
Assert.Throws <InvalidOperationException>(() =>
// cannot disposed a non-attached scope
// in fact, only the ambient scope can be disposed
detached.Dispose());
scopeProvider.AttachScope(detached);
detached.Complete();
detached.Dispose();
// has self-detached, and is gone!
Assert.AreSame(scope, scopeProvider.AmbientScope);
Assert.AreSame(context, scopeProvider.AmbientContext);
}
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(scopeProvider.AmbientContext);
}
public void EventsDispatching_Scope(bool complete)
{
var counter = 0;
IScope ambientScope = null;
IScopeContext ambientContext = null;
Guid value = Guid.Empty;
var scopeProvider = GetScopeProvider(NullLoggerFactory.Instance) as ScopeProvider;
DoThing1 += (sender, args) => { counter++; };
DoThing2 += (sender, args) => { counter++; };
DoThing3 += (sender, args) =>
{
ambientScope = scopeProvider.AmbientScope;
ambientContext = scopeProvider.AmbientContext;
value = scopeProvider.Context.Enlist("value", Guid.NewGuid, (c, o) => { });
counter++;
};
Guid guid;
using (var scope = scopeProvider.CreateScope())
{
Assert.IsNotNull(scopeProvider.AmbientContext);
guid = scopeProvider.Context.Enlist("value", Guid.NewGuid, (c, o) => { });
scope.Events.Dispatch(DoThing1, this, new SaveEventArgs <string>("test"));
scope.Events.Dispatch(DoThing2, this, new SaveEventArgs <int>(0));
scope.Events.Dispatch(DoThing3, this, new SaveEventArgs <decimal>(0));
// events have been queued
Assert.AreEqual(3, scope.Events.GetEvents(EventDefinitionFilter.All).Count());
Assert.AreEqual(0, counter);
if (complete)
{
scope.Complete();
}
}
if (complete)
{
// events have been raised
Assert.AreEqual(3, counter);
Assert.IsNull(ambientScope); // scope was gone
Assert.IsNotNull(ambientContext); // but not context
Assert.AreEqual(guid, value); // so we got the same value!
}
else
{
// else, no event has been raised
Assert.AreEqual(0, counter);
}
// everything's gone
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(scopeProvider.AmbientContext);
}
/// <summary>First, inserts request scope into pipeline via <see cref="InsertOpenScope"/>.
/// Then adds to application builder the registered OWIN middlewares
/// wrapped in <see cref="DryIocWrapperMiddleware{TServiceMiddleware}"/> via <see cref="UseRegisteredMiddlewares"/>.</summary>
/// <param name="app">App builder</param>
/// <param name="container">Container</param>
/// <param name="registerInScope">(optional) Action for using/registering instances in scope before setting scope into context.</param>
/// <param name="scopeContext">(optional) Scope context to use. By default sets the <see cref="AsyncExecutionFlowScopeContext"/>.</param>
/// <returns>App builder to enable method chaining.</returns>
/// <remarks>IMPORTANT: if passed <paramref name="container"/> did not have a scope context set,
/// then the new container with context will be created and used. If you want to hold on this new container,
/// you may first call <see cref="InsertOpenScope"/>, store the result container,
/// then call <see cref="UseRegisteredMiddlewares"/>.</remarks>
public static IAppBuilder UseDryIocOwinMiddleware(
this IAppBuilder app, IContainer container,
Action <IResolverContext> registerInScope = null,
IScopeContext scopeContext = null)
{
var containerWithAmbientContext = container.InsertOpenScope(app, registerInScope, scopeContext);
return(app.UseRegisteredMiddlewares(containerWithAmbientContext));
}
public ReportService(
FLSDbContext _context,
IScopeContext _scopeContext,
IMapper _iMapper) : base(_context, _scopeContext)
{
context = _context;
scopeContext = _scopeContext;
iMapper = _iMapper;
}
public FishPondService(
FLSDbContext _context,
IScopeContext _scopeContext,
IMapper _iMapper)
{
context = _context;
scopeContext = _scopeContext;
iMapper = _iMapper;
}
public StockIssueDocketDetailService(
FLSDbContext _context,
IScopeContext _scopeContext,
IMapper _iMapper) : base(_context, _scopeContext)
{
context = _context;
scopeContext = _scopeContext;
iMapper = _iMapper;
}
/// <summary>Configures container to work with ASP.NET WepAPI by:
/// setting container scope context to <see cref="AsyncExecutionFlowScopeContext"/> (if scope context is not set already),
/// registering HTTP controllers, setting filter provider and dependency resolver.</summary>
/// <param name="container">Original container.</param> <param name="config">Http configuration.</param>
/// <param name="controllerAssemblies">(optional) Assemblies to look for controllers, default is ExecutingAssembly.</param>
/// <param name="scopeContext">(optional) Specific scope context to use, by default method sets
/// <see cref="AsyncExecutionFlowScopeContext"/>, only if container does not have context specified already.</param>
/// <param name="throwIfUnresolved">(optional) Instructs DryIoc to throw exception
/// for unresolved type instead of fallback to default Resolver.</param>
/// <returns>New container.</returns>
public static IContainer WithWebApi(this IContainer container, HttpConfiguration config,
IEnumerable<Assembly> controllerAssemblies = null, IScopeContext scopeContext = null,
Func<Type, bool> throwIfUnresolved = null)
{
container.ThrowIfNull();
if (container.ScopeContext == null)
container = container.With(scopeContext: scopeContext ?? new AsyncExecutionFlowScopeContext());
container.RegisterWebApiControllers(config, controllerAssemblies);
container.SetFilterProvider(config.Services);
InsertRegisterRequestMessageHandler(config);
config.DependencyResolver = new DryIocDependencyResolver(container, throwIfUnresolved);
return container;
}
public void Bind(Type concreteType, IScopeContext existingBinding, string identifier)
{
Optimizer.SetImplementationType(concreteType, existingBinding, identifier);
}
public void Unbind(Type type, IScopeContext scopeContext, string identifier)
{
Optimizer.RemoveImplementationType(type, scopeContext, identifier);
}
private IScopeContext LocateInLoadedAssembliesAndCache(Type type, string named, IScopeContext item)
{
if (!logSupressor.ContainsKey(type))
{
logSupressor.TryAdd(type, true);
Logging.DebugMessage($"Type scanning initiated. Looking for implementations of {type.FullName} {GetNameString(named)}");
}
var items = AssemblyScanner.LocateInLoadedAssemblies(type);
foreach (var scopeContext in items)
{
Optimizer.SetImplementationType(type, scopeContext, scopeContext.ImplementationKey);
if (scopeContext.ImplementationKey == named)
item = scopeContext;
}
return item;
}
public void Unbind(Type type, IScopeContext scopeContext, string identifier)
{
throw new NotImplementedException();
}
public void Bind(Type concreteType, IScopeContext existingBinding, string identifier)
{
throw new NotImplementedException();
}
/// <summary>Creates new container from original one with <see cref="HttpContextScopeContext"/>.
/// Then registers MVC controllers in container,
/// sets <see cref="DryIocFilterAttributeFilterProvider"/> as filter provider,
/// and at last sets container as <see cref="DependencyResolver"/>.</summary>
/// <param name="container">Original container.</param>
/// <param name="controllerAssemblies">(optional) By default uses <see cref="GetReferencedAssemblies"/>.</param>
/// <param name="scopeContext">Specific scope context to use, by default MVC uses <see cref="HttpContextScopeContext"/>.</param>
/// <returns>New container with applied Web context.</returns>
public static IContainer WithMvc(this IContainer container,
IEnumerable<Assembly> controllerAssemblies = null, IScopeContext scopeContext = null)
{
container.ThrowIfNull();
if (scopeContext == null && !(container.ScopeContext is HttpContextScopeContext))
scopeContext = new HttpContextScopeContext();
if (scopeContext != null)
container = container.With(scopeContext: scopeContext);
container.RegisterMvcControllers(controllerAssemblies);
container.SetFilterAttributeFilterProvider(FilterProviders.Providers);
DependencyResolver.SetResolver(new DryIocDependencyResolver(container));
return container;
}
