internal ModelMetadataProviders(IResolver<ModelMetadataProvider> resolver = null)
{
_resolver = resolver ?? new SingleServiceResolver<ModelMetadataProvider>(
() => _currentProvider,
new CachedDataAnnotationsModelMetadataProvider(),
"ModelMetadataProviders.Current");
}
internal DefaultControllerFactory(IControllerActivator controllerActivator, IResolver<IControllerActivator> activatorResolver, IDependencyResolver dependencyResolver)
{
if (controllerActivator != null)
this._controllerActivator = controllerActivator;
else
this._activatorResolver = activatorResolver ?? (IResolver<IControllerActivator>) new SingleServiceResolver<IControllerActivator>((Func<IControllerActivator>) (() => (IControllerActivator) null), (IControllerActivator) new DefaultControllerFactory.DefaultControllerActivator(dependencyResolver), "DefaultControllerFactory constructor");
}
public CSSAssetsFileHasher(string hashQueryStringKeyName, IResolver fileResolver, IHasher hasher, IPathTranslator pathTranslator)
{
HashQueryStringKeyName = hashQueryStringKeyName;
FileSystemResolver = fileResolver;
Hasher = hasher;
this.pathTranslator = pathTranslator;
}
///<summary>
/// Initializes a new instance of <see cref="SelectDatabaseStep"/>.
///</summary>
///<param name="serviceProvider">The service provider to use for service location.</param>
///<param name="sourceModel">The <see cref="ConfigurationSourceModel"/> to update on <see cref="WizardStep.Execute"/></param>
///<param name="validatorFactory">The factory creating new <see cref="Validator"/> instances.</param>
///<param name="elementLookup">The service for locating registered elements.</param>
public SelectDatabaseStep(IServiceProvider serviceProvider,
ConfigurationSourceModel sourceModel,
IResolver<Validator> validatorFactory,
ElementLookup elementLookup
)
: base(serviceProvider, validatorFactory, elementLookup)
{
this.sourceModel = sourceModel;
var name = AddReflectedProperty(wizardData, propertyName);
PropertyList.Add(new AssociatedWizardProperty(serviceProvider,
wizardData,
TypeDescriptor.GetProperties(wizardData)[propertyConnectionString],
validatorFactory,
elementLookup,
name));
PropertyList.Add(new AssociatedWizardProperty(serviceProvider,
wizardData,
TypeDescriptor.GetProperties(wizardData)[propertyProviderName],
validatorFactory,
elementLookup,
name));
SetDefaultDatabase(elementLookup);
}
internal BuildManagerViewEngine(IViewPageActivator viewPageActivator, IResolver<IViewPageActivator> activatorResolver,
IDependencyResolver dependencyResolver, VirtualPathProvider pathProvider)
{
if (viewPageActivator != null)
{
_viewPageActivator = viewPageActivator;
}
else
{
_activatorResolver = activatorResolver ?? new SingleServiceResolver<IViewPageActivator>(
() => null,
new DefaultViewPageActivator(dependencyResolver),
"BuildManagerViewEngine constructor");
}
if (pathProvider != null)
{
Func<VirtualPathProvider> providerFunc = () => pathProvider;
_fileExistsCache = new FileExistenceCache(providerFunc);
VirtualPathProviderFunc = providerFunc;
}
else
{
if (_sharedFileExistsCache == null)
{
// Startup initialization race is OK providing service remains read-only
_sharedFileExistsCache = new FileExistenceCache(() => HostingEnvironment.VirtualPathProvider);
}
_fileExistsCache = _sharedFileExistsCache;
}
}
public XmlLocalizationReader(string path) {
this.path = path;
Recursive = true;
ThrowWhenNotFound = true;
Prefix = String.Empty;
Resolver = new FileSystemResolver();
}
internal ControllerBuilder(IResolver<IControllerFactory> serviceResolver) {
_serviceResolver = serviceResolver ?? new SingleServiceResolver<IControllerFactory>(
() => _factoryThunk(),
new DefaultControllerFactory { ControllerBuilder = this },
"ControllerBuilder.GetControllerFactory"
);
}
public override object GetInstance(IInstanceFactory factory, IResolver resolver)
{
if (!_threadLocalInstance.IsValueCreated)
_threadLocalInstance.Value = factory.CreateInstance(resolver);
return _threadLocalInstance.Value;
}
public async Task ExecuteAsync(IResolver resolver, CancellationToken cancellationToken)
{
var queryProcessor = resolver.Resolve<IQueryProcessor>();
var updateItineraryService = resolver.Resolve<IUpdateItineraryService>();
var commandBus = resolver.Resolve<ICommandBus>();
var routingService = resolver.Resolve<IRoutingService>();
var cargo = (await queryProcessor.ProcessAsync(new GetCargosQuery(CargoId), cancellationToken).ConfigureAwait(false)).Single();
var updatedItinerary = await updateItineraryService.UpdateItineraryAsync(cargo.Itinerary, cancellationToken).ConfigureAwait(false);
if (cargo.Route.Specification().IsSatisfiedBy(updatedItinerary))
{
await commandBus.PublishAsync(new CargoSetItineraryCommand(cargo.Id, updatedItinerary), cancellationToken).ConfigureAwait(false);
return;
}
var newItineraries = await routingService.CalculateItinerariesAsync(cargo.Route, cancellationToken).ConfigureAwait(false);
var newItinerary = newItineraries.FirstOrDefault();
if (newItinerary == null)
{
// TODO: Tell domain that a new itinerary could not be found
throw DomainError.With("Could not find itinerary");
}
await commandBus.PublishAsync(new CargoSetItineraryCommand(cargo.Id, newItinerary), cancellationToken).ConfigureAwait(false);
}
public ServiceProviderAdapter(IResolver resolver)
{
if (resolver == null)
throw new ArgumentNullException("resolver");
_resolver = resolver;
}
public SizesModel(IResolver resolver, IReadOnlyCollection<ImageInfo> images, string id)
{
this.ServiceName = resolver.ServiceName;
this.Images = images;
this.ServiceId = resolver.ServiceId;
this.Id = id;
}
public object GetInstance(Func<IResolver, object> factory, IResolver resolver)
{
if (!_threadLocalInstance.IsValueCreated)
_threadLocalInstance.Value = factory(resolver);
return _threadLocalInstance.Value;
}
/// <summary>
/// generates project.lock.json that tells compiler where to take dlls and source from
/// and builds executable and copies all required dll's
/// </summary>
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
if (!DotNetCliCommandExecutor.ExecuteCommand(
RestoreCommand,
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath,
logger,
DefaultTimeout))
{
return BuildResult.Failure(generateResult, new Exception("dotnet restore has failed"));
}
if (!DotNetCliCommandExecutor.ExecuteCommand(
GetBuildCommand(TargetFrameworkMoniker),
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath,
logger,
DefaultTimeout))
{
// dotnet cli could have succesfully builded the program, but returned 1 as exit code because it had some warnings
// so we need to check whether the exe exists or not, if it does then it is OK
if (File.Exists(generateResult.ArtifactsPaths.ExecutablePath))
{
return BuildResult.Success(generateResult);
}
return BuildResult.Failure(generateResult);
}
return BuildResult.Success(generateResult);
}
public bool TryGetConstructor(Type type, IResolver resolver, out ConstructorInfo constructor)
{
if (type.IsAbstract)
{
constructor = null;
return false;
}
var rankedConstructors =
type.GetConstructors()
.SelectMany(GetVirtualContructors)
.Where(v => v.CanResolve(resolver))
.GroupBy(v => v.GetScore())
.OrderByDescending(g => g.Key);
var enumerator = rankedConstructors.GetEnumerator();
if (!enumerator.MoveNext())
{
constructor = null;
return false;
}
if (enumerator.Current.Count() > 1)
{
constructor = null;
return false;
}
constructor = enumerator.Current.Single().Constructor;
return true;
}
public IndicatorUpdateCoordinator(ILog log, Repository<IIndicatorConfiguration> indicatorConfigurationRepository, Repository<IIndicatorState> indicatorStateRepository, IResolver resolver)
{
_log = log;
_indicatorConfigurationRepository = indicatorConfigurationRepository;
_indicatorStateRepository = indicatorStateRepository;
_resolver = resolver;
}
private ProcessStartInfo CreateStartInfo(Benchmark benchmark, string exeName, string args, string workingDirectory, IResolver resolver)
{
var start = new ProcessStartInfo
{
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
WorkingDirectory = workingDirectory
};
var runtime = benchmark.Job.Env.HasValue(EnvMode.RuntimeCharacteristic)
? benchmark.Job.Env.Runtime
: RuntimeInformation.GetCurrentRuntime();
// TODO: use resolver
switch (runtime)
{
case Runtime.Clr:
case Runtime.Core:
start.FileName = exeName;
start.Arguments = args;
break;
case Runtime.Mono:
start.FileName = "mono";
start.Arguments = GetMonoArguments(benchmark.Job, exeName, args, resolver);
break;
default:
throw new NotSupportedException("Runtime = " + runtime);
}
return start;
}
public LcdpServer(ILcdpPacketSerializer lcdpPacketSerializer, IListener listener, IForwarder forwarder, IResolver resolver)
{
this.lcdpPacketSerializer = lcdpPacketSerializer;
this.listener = listener;
this.forwarder = forwarder;
this.messages = new ConcurrentDictionary<string, LcdpMessage>();
this.ChunkExpirationTimeMilliseconds = 5000;
this.compressors = new Dictionary<byte, ICompressor>();
this.serializers = new Dictionary<byte, ISerializer>();
for(byte b = 0; b < byte.MaxValue; ++b)
{
ICompressor compressor = resolver.Resolve<ICompressor>(b.ToString());
if (compressor != null)
{
compressors[b] = compressor;
}
ISerializer serializer = resolver.Resolve<ISerializer>(b.ToString());
if (serializer != null)
{
serializers[b] = serializer;
}
}
}
public DispatchToEventSubscribers(
ILog log,
IResolver resolver)
{
_log = log;
_resolver = resolver;
}
public DocumentPicturesCreator(
IResolver<IDocumentPictureContext> resDocumentPictureContext,
IResolver<IWebApiDocument> resWebApiDocument
)
{
m_resWebApiDocument = resWebApiDocument;
m_resDocumentPictureContext = resDocumentPictureContext;
}
public static PublishCommandJob Create(
ICommand command,
IResolver resolver)
{
var commandDefinitionService = resolver.Resolve<ICommandDefinitionService>();
var jsonSerializer = resolver.Resolve<IJsonSerializer>();
return Create(command, commandDefinitionService, jsonSerializer);
}
public EmdFileParser(
IResolver<IEmdFileStructure> resEmdFileStrcture,
IResolver<IEmdFileMember> resEmdFileMember,
IResolver<IEmdFileSection> resEmdFileSection)
{
m_resEmdFileStrcture = resEmdFileStrcture;
m_resEmdFileMember = resEmdFileMember;
m_resEmdFileSection = resEmdFileSection;
}
public JobRunner(
IResolver resolver,
IJobDefinitionService jobDefinitionService,
IJsonSerializer jsonSerializer)
{
_resolver = resolver;
_jobDefinitionService = jobDefinitionService;
_jsonSerializer = jsonSerializer;
}
/*----------------------------------------------------------------------------------------*/
#region Constructors
/// <summary>
/// Creates a new Argument.
/// </summary>
/// <param name="target">The argument's injection point.</param>
/// <param name="resolver">The argument's dependency marker.</param>
/// <param name="optional">A value indicating whether the argument is optional.</param>
public Argument(ITarget target, IResolver resolver, bool optional)
{
Ensure.ArgumentNotNull(target, "target");
Ensure.ArgumentNotNull(resolver, "dependency");
Target = target;
Resolver = resolver;
Optional = optional;
}
public static ConstructorInfo GetConstructor(this IResolverConstructorSelector constructorSelector, Type type, IResolver resolver)
{
ConstructorInfo ctor;
if (constructorSelector.TryGetConstructor(type, resolver, out ctor))
{
return ctor;
}
throw new ResolveException("Unable to resolve type: " + type);
}
private static void GenerateGCSettings(XmlDocument xmlDocument, XmlNode runtimeElement, GcMode gcMode, IResolver resolver)
{
if (!gcMode.HasChanges)
return;
CreateNodeWithAttribute(xmlDocument, runtimeElement, "gcConcurrent", "enabled", gcMode.ResolveValue(GcMode.ConcurrentCharacteristic, resolver).ToLowerCase());
CreateNodeWithAttribute(xmlDocument, runtimeElement, "gcServer", "enabled", gcMode.ResolveValue(GcMode.ServerCharacteristic, resolver).ToLowerCase());
CreateNodeWithAttribute(xmlDocument, runtimeElement, "GCCpuGroup", "enabled", gcMode.ResolveValue(GcMode.CpuGroupsCharacteristic, resolver).ToLowerCase());
CreateNodeWithAttribute(xmlDocument, runtimeElement, "gcAllowVeryLargeObjects", "enabled", gcMode.ResolveValue(GcMode.AllowVeryLargeObjectsCharacteristic, resolver).ToLowerCase());
}
protected internal override void Resolve(IResolver resolver, bool canEnterContext)
{
base.Resolve(resolver, canEnterContext);
if (expression != null)
{
expression.Parent = this;
expression.Resolve(resolver);
}
}
/// <summary>
/// Initializes an instance of <see cref="PickExceptionStep"/>.
/// </summary>
/// <param name="serviceProvider"></param>
/// <param name="sourceModel"></param>
/// <param name="validatorFactory"></param>
/// <param name="elementLookup"></param>
public PickExceptionStep(IServiceProvider serviceProvider,
ConfigurationSourceModel sourceModel,
IResolver<Validator> validatorFactory,
ElementLookup elementLookup
) : base(serviceProvider, validatorFactory, elementLookup)
{
this.sourceModel = sourceModel;
AddReflectedProperty(wizardData, propertyExceptionType);
AddReflectedProperty(wizardData, propertyPolicy);
}
public JavaReverser(JavaReversingContext context, DexFile input)
{
if (null == context) { throw new ArgumentNullException(); }
if (null == input) { throw new REException(); }
_context = context;
_input = input;
_objectResolver = (IResolver)input;
_treeHandler = new SourceCodeTreeHandler(context.BaseSourceCodeDirectory);
EnsureStorage();
return;
}
public Task ExecuteAsync(IResolver resolver, CancellationToken cancellationToken)
{
var commandDefinitionService = resolver.Resolve<ICommandDefinitionService>();
var jsonSerializer = resolver.Resolve<IJsonSerializer>();
var commandBus = resolver.Resolve<ICommandBus>();
var commandDefinition = commandDefinitionService.GetDefinition(Name, Version);
var command = (ICommand) jsonSerializer.Deserialize(Data, commandDefinition.Type);
return command.PublishAsync(commandBus, cancellationToken);
}
public EmdFilesController(
IDbEmdFileRepository repo,
IDbEmdFileRangeRepository repoRanges,
IResolver<IEmdFileContext> resEmdFileContext,
IEmdFileParser emdFileParser)
{
m_repoFiles = repo;
m_emdFileParser = emdFileParser;
m_repoRanges = repoRanges;
m_resEmdFileContext = resEmdFileContext;
}
public ModelValidatorProviderCollection()
{
_serviceResolver = new MultiServiceResolver <ModelValidatorProvider>(() => Items);
}
public BusStateManager(IStateManager stateManagerImplementation, ILogger logger, IResolver resolver)
{
_stateManagerImplementation = stateManagerImplementation;
this._logger = logger;
_resolver = resolver;
//this._bus = _resolver.Resolve<Bus>();
}
public ValueProviderFactoryCollection(IList <ValueProviderFactory> list)
: base(list)
{
_serviceResolver = new MultiServiceResolver <ValueProviderFactory>(() => Items);
}
public DeleteMeterMeasurementTypeCommandHandler(
IResolver resolver
) : base(resolver)
{
Repository = GetRepository <MeterMeasurementType>();
}
public JwtServiceResolver(IResolver <IDictionary <string, string> > AppSettingsDictionary)
{
this.AppSettingsDictionary = AppSettingsDictionary;
}
public void RegisterLastChanceResolver(IResolver resolver) =>
Swap.SwapValue(ref this.lastChanceResolverRepository, (t1, t2, t3, t4, repo) =>
repo.Add(t1), resolver, Constants.DelegatePlaceholder, Constants.DelegatePlaceholder, Constants.DelegatePlaceholder);
public void ThenWrapWithType_throws_exception_if_impl_type_does_not_derive_from_service(IResolver resolver,
ServiceImpl1 initialImpl)
{
var wrapped = new AutofacDecoratorCustomizer(resolver, typeof(IServiceInterface), initialImpl);
var sut = new AutofacGenericDecoratorCustomizer <IServiceInterface>(wrapped, initialImpl);
Assert.That(() => sut.ThenWrapWithType(typeof(DifferentImpl)), Throws.ArgumentException);
}
/// <summary>
/// Initializes a new instance of the <see cref="Cli"/> class.
/// </summary>
private Cli()
{
resolver = new Resolver(Activator.CreateInstance);
outputs = new Dictionary <Type, Type>();
services = new List <CliService>();
}
public SingletonLifetimeResolverWrapper(IResolver innerResolver)
{
_innerResolver = innerResolver;
}
protected override void GenerateProject(Benchmark benchmark, ArtifactsPaths artifactsPaths, IResolver resolver, ILogger logger)
{
string template = ResourceHelper.LoadTemplate("BenchmarkProject.json");
string content = SetPlatform(template, PlatformProvider(benchmark.Job.ResolveValue(EnvMode.PlatformCharacteristic, resolver)));
content = SetCodeFileName(content, Path.GetFileName(artifactsPaths.ProgramCodePath));
content = SetDependencyToExecutingAssembly(content, benchmark.Target.Type);
content = SetTargetFrameworkMoniker(content, TargetFrameworkMoniker);
content = SetExtraDependencies(content, ExtraDependencies);
content = SetImports(content, Imports);
content = SetRuntime(content, Runtime);
content = SetGcMode(content, benchmark.Job.Env.Gc, resolver);
File.WriteAllText(artifactsPaths.ProjectFilePath, content);
}
/// <summary>
/// Sets the <see cref="Cli"/> <see cref="IResolver"/>, used to instantiate service instances to invoke.
/// </summary>
/// <param name="resolver">The CLI <see cref="IResolver"/>.</param>
/// <returns>
/// This <see cref="Cli"/> instance.
/// </returns>
public Cli SetResolver(IResolver resolver)
{
this.resolver = resolver ?? throw new ArgumentNullException(nameof(resolver));
return(this);
}
public virtual Service SetResolver(IResolver resolver)
{
this.resolver = resolver;
return(this);
}
public EventPublisher(IResolver resolver, IBusMessageDispatcher busMessageDispatcher)
{
_resolver = resolver;
_busMessageDispatcher = busMessageDispatcher;
}
/// <summary>
/// Creates a new instance of <see cref="SqlServerConvertFieldResolver"/> class.
/// </summary>
public SqlServerConvertFieldResolver(IResolver <Type, DbType?> dbTypeResolver,
IResolver <DbType, string> stringNameResolver)
: base(dbTypeResolver,
stringNameResolver)
{
}
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
logger.WriteLineInfo($"BuildScript: {generateResult.ArtifactsPaths.BuildScriptFilePath}");
var syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(generateResult.ArtifactsPaths.ProgramCodePath));
var compilationOptions = new CSharpCompilationOptions(
outputKind: OutputKind.ConsoleApplication,
optimizationLevel: OptimizationLevel.Release,
allowUnsafe: true,
platform: GetPlatform(benchmark.Job.ResolveValue(EnvMode.PlatformCharacteristic, resolver)),
deterministic: true);
var references = Generator
.GetAllReferences(benchmark)
.Select(assembly => AssemblyMetadata.CreateFromFile(assembly.Location))
.Concat(FrameworkAssembliesMetadata.Value)
.Distinct()
.Select(uniqueMetadata => uniqueMetadata.GetReference());
var compilation = CSharpCompilation
.Create(assemblyName: Path.GetFileName(generateResult.ArtifactsPaths.ExecutablePath))
.AddSyntaxTrees(syntaxTree)
.WithOptions(compilationOptions)
.AddReferences(references);
using (var executable = File.Create(generateResult.ArtifactsPaths.ExecutablePath))
{
var emitResult = compilation.Emit(executable);
if (emitResult.Success)
{
return(BuildResult.Success(generateResult));
}
foreach (var diagnostic in emitResult.Diagnostics
.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error))
{
logger.WriteError($"{diagnostic.Id}: {diagnostic.GetMessage()}");
}
return(BuildResult.Failure(generateResult));
}
}
public QueryDispatcher(IResolver resolver)
{
_resolver = resolver;
}
public ModelValidatorProviderCollection(IList <ModelValidatorProvider> list)
: base(list)
{
_serviceResolver = new MultiServiceResolver <ModelValidatorProvider>(() => Items);
}
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
var restoreResult = DotNetCliCommandExecutor.ExecuteCommand(
RestoreCommand,
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath);
logger.WriteLineInfo($"// dotnet restore took {restoreResult.ExecutionTime.TotalSeconds:0.##}s");
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(generateResult, new Exception(restoreResult.ProblemDescription)));
}
var buildResult = Build(generateResult);
logger.WriteLineInfo($"// dotnet build took {buildResult.ExecutionTime.TotalSeconds:0.##}s");
if (!buildResult.IsSuccess)
{
// dotnet cli could have succesfully builded the program, but returned 1 as exit code because it had some warnings
// so we need to check whether the exe exists or not, if it does then it is OK
if (File.Exists(generateResult.ArtifactsPaths.ExecutablePath))
{
return(BuildResult.Success(generateResult));
}
return(BuildResult.Failure(generateResult, new Exception(buildResult.ProblemDescription)));
}
return(BuildResult.Success(generateResult));
}
/// <summary>Generates the project for benchmark.</summary>
/// <param name="benchmark">The benchmark.</param>
/// <param name="logger">The logger.</param>
/// <param name="rootArtifactsFolderPath">The root artifacts folder path.</param>
/// <param name="config">The config for benchmark.</param>
/// <param name="resolver">The resolver.</param>
/// <returns>Generation result.</returns>
public GenerateResult GenerateProject(
Benchmark benchmark, ILogger logger,
string rootArtifactsFolderPath, IConfig config,
IResolver resolver) =>
GenerateResult.Success(null);
public ValueProviderFactoryCollection()
{
_serviceResolver = new MultiServiceResolver <ValueProviderFactory>(() => Items);
}
public AggregateFactory(
IResolver resolver)
{
_resolver = resolver;
}
public GenerateResult GenerateProject(Benchmark benchmark, ILogger logger, string rootArtifactsFolderPath, IConfig config, IResolver resolver)
{
if (!(benchmark is ExternalProcessBenchmark))
{
return(GenerateResult.Failure(null, Array.Empty <string>()));
}
return(GenerateResult.Success(_artifactsPaths, Array.Empty <string>()));
}
/// <summary>
/// Sets the <see cref="Cli"/> resolver function, used to instantiate service instances to invoke.
/// </summary>
/// <param name="resolver">The CLI resolver function.</param>
/// <returns>
/// This <see cref="Cli"/> instance.
/// </returns>
public Cli SetResolver(Func <Type, object> resolver)
{
this.resolver = new Resolver(resolver) ?? throw new ArgumentNullException(nameof(resolver));
return(this);
}
public override bool IsSupported(BenchmarkCase benchmarkCase, ILogger logger, IResolver resolver)
{
if (!base.IsSupported(benchmarkCase, logger, resolver))
{
return(false);
}
if (!RuntimeInformation.IsWindows())
{
logger.WriteLineError($"Classic .NET toolchain is supported only for Windows, benchmark '{benchmarkCase.DisplayInfo}' will not be executed");
return(false);
}
if (InvalidCliPath(customDotNetCliPath: null, benchmarkCase, logger))
{
return(false);
}
return(true);
}
public ISmartBehavior GetBehavior(IResolver resolver)
{
return(new FluentValidationBehavior <IValidator>((IValidator)resolver.Resolve(_type)));
}
public StructureMapJobFactory(IResolver resolver)
{
_resolver = resolver;
}
internal ValueProviderFactoryCollection(IResolver <IEnumerable <ValueProviderFactory> > serviceResolver, params ValueProviderFactory[] valueProviderFactories)
: base(valueProviderFactories)
{
_serviceResolver = serviceResolver ?? new MultiServiceResolver <ValueProviderFactory>(() => Items);
}
public Function(IResolver resolver, IUserService userService)
{
_resolver = resolver;
_userService = userService;
}
public GetUserSettingsQueryHandler(
IResolver resolver
) : base(resolver)
{
Repository = GetRepository <UserSettings>();
}
/// <summary>
/// Sets the current resolver.
/// </summary>
/// <param name="resolver">The new resolver to use.</param>
public static void SetResolver(IResolver resolver)
{
currentResolver = resolver;
}
