/// <summary>
/// A singleton object cannot depend on a scoped object because it "captures" the scoped object and may access
/// if after the scope closes and destroys the object. To prevent this we eliminate the scope for a singleton
/// evaluation and then put it back in case the singleton is part of a multiple object activation
/// </summary>
private IIocService ExchangeRequestScope(IBindingRequest request, IIocService newScope)
{
var ret = request.IocService;
request.IocService = newScope;
return(ret);
}
public object?Create(IBindingRequest bindingRequest)
{
var values = new object[desiredType.GetGenericArguments().Length];
var scope = bindingRequest.IocService.CreateScope();
values[0] = scope;
scope.Fill(values.AsSpan <object?>()[1..], RequestsForInnerItems(bindingRequest));
private async Task <T> CreateFromStaticImplementation(object[] parameters, IBindingRequest parentRequest)
{
request = parentRequest;
await EnsureInitialized(parameters, StaticConstructor);
return(datum !);
}
private static object?RunStaticOrMemberMethod(IBindingRequest request, object?target, string methodName,
Type targetType, BindingFlags searchCriteria)
{
var methods = FindCallableTargetMethod(request, methodName, searchCriteria, targetType);
return(methods.Invoke(target, ResolveParameters(request, methods)));
}
public IActivationStrategy?ApplyResolutionPolicy(IBindingRequest request)
{
var targetType = ApplyConvention(request.DesiredType);
return(targetType == null ? null :
TypeActivatorFactory.CreateTypeActivator(targetType, ConstructorSelectors.MaximumArgumentCount));
}
private IBindingRequest InnerRequestForCanCreate(IBindingRequest bindingRequest)
{
var types = functionDelegateType.GetGenericArguments().ToList();
return(bindingRequest.CreateSubRequest(types.Last(),
CreateFakeObjectsFromFunctionParameters(types).ToArray()));
}
public AsyncFunctionFactoryStub(IBindingRequest request, Type targetObjectType,
ForwardFuncToMethodCall asyncInitializerFactory)
{
this.request = request;
this.targetObjectType = targetObjectType;
this.asyncInitializerFactory = asyncInitializerFactory;
}
private void TrySetScopeValue(IBindingRequest request)
{
if (IsAChildOfThisScope(request.IocService))
{
return;
}
request.IocService = this;
}
public ClonedBindingRequest(IBindingRequest rootRequest)
{
this.rootRequest = rootRequest;
IocService = rootRequest.IocService;
// copy the array because it gets destroyed
ArgumentsFromParent = rootRequest.ArgumentsFromParent.ToArray();
ArgumentsFormChild = rootRequest.ArgumentsFormChild.ToArray();
}
private static MethodInfo FindCallableTargetMethod(IBindingRequest request, string methodName,
BindingFlags searchCriteria, Type typeToSearch) =>
typeToSearch
.GetMethods(searchCriteria)
.Where(i => i.Name.Equals(methodName, StringComparison.Ordinal))
.OrderByDescending(i => i.GetParameters().Length)
.FirstOrDefault(i => CanSupplyAllParameters(request, i))
?? throw new IocException("Could not find a method to call");
public object?Intercept(IBindingRequest request, object?source)
{
if (!(DestinationTypeFulfillsRequest(request) && source is TSource legalSource))
{
return(source);
}
return(DoInterception(request, legalSource));
}
public IActivationStrategy?ApplyResolutionPolicy(IBindingRequest request)
{
if (!IsClosedEnumerable(request.DesiredType))
{
return(null);
}
return(new MultipleValueActivator(innerPolicy, request.DesiredType.GetGenericArguments()[0]));
}
private object?ComputeSingleValue(IBindingRequest bindingRequest)
{
var oldScope = ExchangeRequestScope(bindingRequest, bindingRequest.IocService.GlobalScope());
var ret = base.Create(bindingRequest);
ExchangeRequestScope(bindingRequest, oldScope);
return(ret);
}
CreateNetworkVariableServer(IIocService ioc, IBindingRequest br)
{
return((r, w) =>
{
var dict = ioc.Get <BinaryObjectDictionary>();
return new NetworkVariableServer(ioc.Get <IVariableCache>(),
new BinaryObjectPipeReader(r, dict), new BinaryObjectPipeWriter(w, dict));
});
}
public object?Intercept(IBindingRequest request, object?source)
{
if (IsDisposableItem(source))
{
RegisterDisposal(source, request);
}
return(source);
}
public override object?Create(IBindingRequest bindingRequest)
{
// here we needed to copy the array anyway so that multiple invocations get their own set of
// variables anyway. We append our vars to the end of the array so any values provided by a
// factory will get precedence;
bindingRequest.ArgumentsFormChild =
bindingRequest.ArgumentsFormChild.Concat(parameters).ToArray();
return(base.Create(bindingRequest));
}
private T FetchDatumIfNeeded(IBindingRequest localRequest)
{
if (state != FactoryState.NotCreatedYet)
{
return(datum !);
}
state = FactoryState.StaticCreationDone;
return((T)(localRequest.IocService.Get(localRequest) ??
new InvalidOperationException("Failed to fetch datum")));
}
public override object?Create(IBindingRequest bindingRequest)
{
if ((!bindingRequest.IocService.ScopeList().OfType <IRegisterDispose>().Any()) ||
forbidDisposeEvenIfInScope)
{
SetDisposalContextToAContextThatWillNeverGetDisposed(bindingRequest);
}
return(InnerActivationStrategy.Create(bindingRequest));
}
BasisCall(Func <IBindingRequest, object?> action, IBindingRequest request)
{
try
{
return(action(request));
}
catch (IocException e)
{
throw e.CreateElaboratedException();
}
}
public IActivationStrategy?GetStrategy(IBindingRequest request, CachedResolutionPolicy cache)
{
var finalTargetType = genericTemplate.MakeGenericType(request.DesiredType.GetGenericArguments());
var activator = cache.Bind(request.DesiredType, true).DoBinding(
TypeActivatorFactory.CreateTypeActivator(
finalTargetType, constructorSelector)
);
options?.Invoke(activator);
return(activator.GetFinalFactory());
}
public static object InterceptFromTypes(IBindingRequest bindingRequest, object item,
IEnumerable <Type> interceptorTypes)
{
var interceptors = bindingRequest.IocService.Get(interceptorTypes
.Select(bindingRequest.CreateSubRequest).ToList())
.OfType <IInterceptor>()
.ToArray();
return(ProxyGeneratorSource.CreateInterceptor(bindingRequest.IocService, bindingRequest.DesiredType,
item, interceptors));
}
public static void AddBindingRequest(VisualElement ve, IBindingRequest req)
{
List <IBindingRequest> l = ve.GetProperty(s_BindingRequestObjectVEPropertyName) as List <IBindingRequest>;
if (l == null)
{
l = RequestObjectListPool.Get();
ve.SetProperty(s_BindingRequestObjectVEPropertyName, l);
}
l.Add(req);
ve.IncrementVersion(VersionChangeType.Bindings);
}
public static object?RecursiveCall(Func <IBindingRequest,
object?> action, IBindingRequest request)
{
try
{
return(action(request));
}
catch (IocException e)
{
e.TypeStack.Add($"{RequestedTypeName(request)} -- {ScopeTag(request)}");
throw;
}
}
private object FirstElligibleContainer(IIocService service, IBindingRequest bindingRequest)
{
IIocService?currentService = service;
while (currentService != null && !bindingRequest.DesiredType.IsInstanceOfType(currentService))
{
currentService = currentService.ParentScope;
}
if (currentService == null)
{
throw new IocException("No valid service container found");
}
return(currentService);
}
public IActivationStrategy?ApplyResolutionPolicy(IBindingRequest request)
{
var objects = request.ArgumentsFromParent;
for (int i = 0; i < objects.Length; i++)
{
if (objects[i] is {} ret&& ObjectFillsRequest(ret, request))
{
RemoveArgumentSoNooneElseCanUseIt(objects, i);
return(new ConstantActivationStrategy(ret));
}
}
return(null);
}
private static IBindingInfo Resolve(IBindingRequest request)
{
ICollection <IBindingInfo> bindings = Bindings[request.Service];
if (string.IsNullOrWhiteSpace(request.Name))
{
if (DefaultBinding.ContainsKey(request.Service))
{
request.Name = DefaultBinding[request.Service];
}
}
return(bindings != null?bindings.FirstOrDefault(binding => ((IBindingMatcher)binding).Matches(request)) : null);
}
public IActivationStrategy?ApplyResolutionPolicy(IBindingRequest request)
{
if (!request.DesiredType.IsGenericType)
{
return(null);
}
var generic = request.DesiredType.GetGenericTypeDefinition();
if (registrations.TryGetValue(generic, out var activation))
{
return(activation.GetStrategy(request, cache));
}
return(null);
}
public static void RemoveBindingRequest(VisualElement ve, IBindingRequest req)
{
List <IBindingRequest> l = ve.GetProperty(s_BindingRequestObjectVEPropertyName) as List <IBindingRequest>;
if (l != null)
{
req.Release();
l.Remove(req);
if (l.Count == 0)
{
RequestObjectListPool.Release(l);
ve.SetProperty(s_BindingRequestObjectVEPropertyName, null);
}
}
}
private void CreateValueExactlyOnceForAllThreads(IBindingRequest bindingRequest)
{
//the double check and lock pattern relies on value and valueExists being volitile fields
if (!valueExists)
{
lock (this)
{
if (!valueExists)
{
value = ComputeSingleValue(bindingRequest);
valueExists = true;
}
}
}
}
public bool CanGet(IBindingRequest request)
{
try
{
var activator = TypeResolver.ApplyResolutionPolicy(request);
if (activator == null)
{
return(false);
}
return(activator.CanCreate(request));
}
catch (Exception)
{
// if we run into a constructor we cannot automatically resolve, then we cannot get the type.
return(false);
}
}
