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; }