private void buildAsyncDaemonAggregation()
{
var daemonBuilderIsAsync = _applyMethods.IsAsync || _createMethods.IsAsync || _shouldDeleteMethods.IsAsync;
var baseType = (daemonBuilderIsAsync ? typeof(AsyncDaemonAggregationBase <,>) : typeof(SyncDaemonAggregationBase <,>))
.MakeGenericType(typeof(T), _aggregateMapping.IdType);
_asyncDaemonType =
_assembly.AddType(GetType().Name.Sanitize() + "AsyncDaemonAggregation", baseType);
_asyncDaemonType.AllInjectedFields.Add(new InjectedField(_storageType));
var injectedField = new InjectedField(GetType());
_asyncDaemonType.AllInjectedFields.Add(injectedField);
// Build the create method
_createMethods.BuildCreateMethod(_asyncDaemonType, _aggregateMapping);
buildDetermineOperationMethodForDaemonRunner(daemonBuilderIsAsync);
buildAsyncDaemonSplitMethod();
_asyncDaemonType.Setters.AddRange(_applyMethods.Setters());
_asyncDaemonType.Setters.AddRange(_createMethods.Setters());
_asyncDaemonType.Setters.AddRange(_shouldDeleteMethods.Setters());
}
public GetInstanceFrame <T> TryGetVariableFromContainer <T>(GeneratedType generatedType, Type toLoad)
{
// If the requested type is enumerable we will always return a transient frame as, even with nothing registered, we
// want to fulfil this request as it's expected that a 0-filled enumerable is acceptable
if (toLoad.IsEnumerable())
{
return(new TransientInstanceFrame <T>(toLoad));
}
// NB: We rely on the service collection being registered when configuring Blueprint
var registrationsForType = this.GetRegistrations(toLoad).ToList();
if (registrationsForType.Any() == false)
{
return(null);
}
if (registrationsForType.Count == 1)
{
// When there is only one possible type that could be created from the IoC container
// we can do a little more optimisation.
var instanceRef = registrationsForType.Single();
if (instanceRef.IsSingleton)
{
// We have a singleton object, which means we can have this injected at build time of the
// pipeline executor which will only be constructed once.
var injected = new InjectedField(toLoad);
foreach (var alreadyInjected in generatedType.AllInjectedFields)
{
// Bail early, we have found an injected field already that can be reused
if (injected.ArgumentName == alreadyInjected.ArgumentName && injected.VariableType == alreadyInjected.VariableType)
{
return(new InjectedFrame <T>(alreadyInjected));
}
// We already have injected an instance of this interface as a concrete class, leading to a duplicate
if (injected.ArgumentName == alreadyInjected.ArgumentName && injected.VariableType != alreadyInjected.VariableType)
{
throw new InvalidOperationException(
$"An attempt has been made to request a service ({toLoad.FullName}) from the DI container that will lead " +
$"to a duplicate constructor argument (existing type is {alreadyInjected.VariableType.FullName}) . This can happen when a " +
"service is requested by an interface AND it's concrete type when they differ only be the I prefix. " +
"To fix this ensure that this service is only referenced by it's interface type");
}
}
generatedType.AllInjectedFields.Add(injected);
return(new InjectedFrame <T>(injected));
}
}
return(new TransientInstanceFrame <T>(toLoad));
}
private void useServiceProvider()
{
var factory = new InjectedField(typeof(IServiceScopeFactory));
var createScope = new ServiceScopeFactoryCreation(factory);
var provider = createScope.Provider;
foreach (var standin in _standins)
{
var variable = new GetServiceFrame(provider, standin.VariableType).Variable;
standin.UseInner(variable);
}
}
private GeneratedType buildSourceType(GeneratedAssembly assembly, CompiledSourceType handlerType,
GeneratedType compiledHandlerType)
{
var sourceBaseType = typeof(CompiledQuerySource <,>).MakeGenericType(_plan.OutputType, _plan.QueryType);
var sourceName = _plan.QueryType.Name + "CompiledQuerySource";
var sourceType = assembly.AddType(sourceName, sourceBaseType);
var hardcoded = new InjectedField(typeof(HardCodedParameters), "hardcoded");
sourceType.AllInjectedFields.Add(hardcoded);
var buildHandler = sourceType.MethodFor("BuildHandler");
switch (handlerType)
{
case CompiledSourceType.Cloneable:
var innerField = new InjectedField(typeof(IMaybeStatefulHandler));
sourceType.AllInjectedFields.Add(innerField);
var statistics = _plan.StatisticsMember == null ? "null" : $"query.{_plan.StatisticsMember.Name}";
buildHandler.Frames.Code(
$"return new Marten.Generated.{compiledHandlerType.TypeName}({innerField.Usage}, query, {statistics}, _hardcoded);");
break;
case CompiledSourceType.Stateless:
var inner = new InjectedField(typeof(IQueryHandler <>).MakeGenericType(_plan.OutputType));
sourceType.AllInjectedFields.Add(inner);
buildHandler.Frames.Code(
$"return new Marten.Generated.{compiledHandlerType.TypeName}({inner.Usage}, query, _hardcoded);");
break;
case CompiledSourceType.Complex:
var innerField2 = new InjectedField(typeof(IMaybeStatefulHandler));
sourceType.AllInjectedFields.Add(innerField2);
buildHandler.Frames.Code(
$"return new Marten.Generated.{compiledHandlerType.TypeName}({innerField2.Usage}, query, _hardcoded);");
break;
}
return(sourceType);
}
public void generate_a_class()
{
#region sample_using-injected-field
var assembly = GeneratedAssembly.Empty();
var type = assembly.AddType("WhatTimeIsIt", typeof(ISaySomething));
var method = type.MethodFor(nameof(ISaySomething.Speak));
var @call = new MethodCall(typeof(NowSpeaker), nameof(NowSpeaker.Speak));
// Create an InjectedField as the argument to
// the Speak method
var now = new InjectedField(typeof(DateTime), "now");
@call.Arguments[0] = now;
method.Frames.Add(@call);
assembly.CompileAll();
#endregion
_output.WriteLine(type.SourceCode);
}
public InjectedFrame(InjectedField field)
{
this.InstanceVariable = field;
}
