public ModuleActionDescriptorProvider(
IAssemblyProvider assemblyProvider,
IServiceProvider services)
{
_assemblyProvider = assemblyProvider;
_services = services;
}
protected override AutoPersistenceModel GetAutoPersistenceModel(IAssemblyProvider assemblyProvider)
{
return AutoMap
.AssemblyOf<LogModel>()
.Where(type => type.Namespace == typeof(LogModel).Namespace)
.UseOverridesFromAssemblyOf<AutoPersistenceModelProvider>();
}
public SingleApplicationInstanceManager(IIpcCommsServer server, IIpcCommsClient client, IAssemblyProvider assemblyProvider, IApplicationWindowState windowState)
{
this.server = server;
this.client = client;
this.assemblyProvider = assemblyProvider;
this.windowState = windowState;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataQueryOptions"/> class based on the incoming request and some metadata information from
/// the <see cref="ODataQueryContext"/>.
/// </summary>
/// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information.</param>
/// <param name="request">The incoming request message.</param>
public ODataQueryOptions(ODataQueryContext context, HttpRequest request)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
if (request == null)
{
throw Error.ArgumentNull("request");
}
_assemblyProvider = request.AssemblyProvider();
Context = context;
Request = request;
RawValues = new ODataRawQueryOptions();
var queryOptionDict = request.Query.ToDictionary(p => p.Key, p => p.Value.FirstOrDefault());
_queryOptionParser = new ODataQueryOptionParser(
context.Model,
context.ElementType,
context.NavigationSource,
queryOptionDict);
BuildQueryOptions(queryOptionDict);
}
public UpdateManager(
IApplicationState applicationState,
IApplicationWindowState applicationWindowState,
IUserActivityMonitor userActivityMonitor,
IUpdateCheckerFactory updateCheckerFactory,
IProcessStartProvider processStartProvider,
IUpdatePromptProvider updatePromptProvider,
IAssemblyProvider assemblyProvider,
Func<IUpdateVariantHandler> updateVariantHandlerFactory)
{
this.applicationState = applicationState;
this.applicationWindowState = applicationWindowState;
this.userActivityMonitor = userActivityMonitor;
this.updateCheckerFactory = updateCheckerFactory;
this.processStartProvider = processStartProvider;
this.updatePromptProvider = updatePromptProvider;
this.assemblyProvider = assemblyProvider;
this.updateVariantHandlerFactory = updateVariantHandlerFactory;
this.promptTimer = new DispatcherTimer();
this.promptTimer.Tick += this.PromptTimerElapsed;
// Strategy time:
// We'll prompt the user a fixed period after the computer starts up / resumes from sleep
// (this is handled by CheckForUpdates being set to true, if appropriate, by another part of the application)
// We'll also check on a fixed interval since this point
// If 'remind me later' is active, we'll also check when the application is restored from tray
this.applicationState.ResumeFromSleep += this.ResumeFromSleep;
this.applicationWindowState.RootWindowActivated += this.RootWindowActivated;
}
public ControllerElementsProvider(IAssemblyProvider assemblyProvider, IProxyGeneratorConfiguration configuration)
{
if (assemblyProvider == null) throw new ArgumentNullException("assemblyProvider");
if (configuration == null) throw new ArgumentNullException("configuration");
_assemblyProvider = assemblyProvider;
_configuration = configuration;
}
public UnhandledExceptionViewModel(IApplicationPathsProvider applicationPathsProvider, IProcessStartProvider processStartProvider, IAssemblyProvider assemblyProvider)
{
this.applicationPathsProvider = applicationPathsProvider;
this.processStartProvider = processStartProvider;
this.assemblyProvider = assemblyProvider;
this.IssuesUrl = AppSettings.Instance.IssuesUrl;
}
/// <summary>
/// Initializes a new instance of <see cref="CompilerCache"/> populated with precompiled views
/// discovered using <paramref name="provider"/>.
/// </summary>
/// <param name="assemblyProvider">The <see cref="IAssemblyProvider"/> that provides assemblies
/// for precompiled view discovery.</param>
/// <param name="loaderContextAccessor">The <see cref="IAssemblyLoadContextAccessor"/>.</param>
/// <param name="optionsAccessor">An accessor to the <see cref="RazorViewEngineOptions"/>.</param>
public CompilerCache(IAssemblyProvider assemblyProvider,
IAssemblyLoadContextAccessor loadContextAccessor,
IOptions<RazorViewEngineOptions> optionsAccessor)
: this(GetFileInfos(assemblyProvider.CandidateAssemblies),
loadContextAccessor.GetLoadContext(RazorFileInfoCollectionType.Assembly),
optionsAccessor.Options.FileProvider)
{
}
public UnhandledExceptionViewModel(IApplicationPathsProvider applicationPathsProvider, IProcessStartProvider processStartProvider, IAssemblyProvider assemblyProvider)
{
this.processStartProvider = processStartProvider;
this.assemblyProvider = assemblyProvider;
this.IssuesUrl = Properties.Settings.Default.IssuesUrl;
this.LogFilePath = applicationPathsProvider.LogFilePath;
}
public CustomCompilerCache(IAssemblyProvider assemblyProvider,
IAssemblyLoadContextAccessor loadContextAccessor,
IOptions<RazorViewEngineOptions> optionsAccessor,
CompilerCacheInitialiedService cacheInitializedService)
: base(assemblyProvider, loadContextAccessor, optionsAccessor)
{
cacheInitializedService.Initialized = true;
}
public static IQueryable Bind(IQueryable queryable, ODataQuerySettings settings,
IAssemblyProvider assembliesProvider, SelectExpandQueryOption selectExpandQuery)
{
Contract.Assert(queryable != null);
SelectExpandBinder binder = new SelectExpandBinder(settings, assembliesProvider, selectExpandQuery);
return(binder.Bind(queryable));
}
public DefaultNHibernateSessionFactoryBuilder(IPersistenceConfigurerProvider persistenceConfigurerProvider, IAssemblyProvider assemblyProvider, IList<IAutoPersistenceModelProvider> autoPersistenceModelProviders, IHbmMappingRegisterer hbmMappingRegisterer, IConventionApplier conventionApplier, IConfigurationProcessor configurationProcessor)
{
this.persistenceConfigurerProvider = persistenceConfigurerProvider;
this.assemblyProvider = assemblyProvider;
this.autoPersistenceModelProviders = autoPersistenceModelProviders;
this.hbmMappingRegisterer = hbmMappingRegisterer;
this.conventionApplier = conventionApplier;
this.configurationProcessor = configurationProcessor;
}
/// <summary>
/// Initialises a new instance of <see cref="DefaultWidgetDescriptorProvider"/>.
/// </summary>
/// <param name="assemblyProvider">The assembly provider.</param>
public DefaultWidgetDescriptorProvider(IAssemblyProvider assemblyProvider)
{
if (assemblyProvider == null)
{
throw new ArgumentNullException(nameof(assemblyProvider));
}
_assemblyProvider = assemblyProvider;
}
public void ThrowExceptionWhenValueTypeImplementsIConfigObject()
{
IAssemblyProvider assemblyProviderMock = Substitute.For <IAssemblyProvider>();
assemblyProviderMock.GetAllTypes().Returns(new [] { typeof(ReferenceTypeConfig), typeof(ValueTypeConfig) });
ConfigObjectTypeValidator configValidator = new ConfigObjectTypeValidator(assemblyProviderMock);
Assert.Throws <ProgrammaticException>(configValidator.Validate);
}
public TypeResolver(IAssemblyProvider assemblyProvider)
{
if (assemblyProvider == null)
{
throw new ArgumentNullException(nameof(assemblyProvider));
}
LoadedTypes = assemblyProvider.GetAssemblies()
.SelectMany(a => a.GetTypes())
.ToList();
}
public ControllerActionDescriptorProvider(IAssemblyProvider assemblyProvider,
IControllerModelBuilder applicationModelBuilder,
IGlobalFilterProvider globalFilters,
IOptions <MvcOptions> optionsAccessor)
{
_assemblyProvider = assemblyProvider;
_applicationModelBuilder = applicationModelBuilder;
_globalFilters = globalFilters.Filters;
_modelConventions = optionsAccessor.Options.ApplicationModelConventions;
}
private static IEdmModel GetEdmModel(IAssemblyProvider assemblyProvider)
{
var builder = new ODataConventionModelBuilder(assemblyProvider);
builder.EntitySet <Person>("Peoples");
builder.EntityType <Person>().HasKey(x => x.ID);
builder.EntitySet <Trip>("Trips");
builder.EntityType <Trip>().HasKey(x => x.ID);
return(builder.GetEdmModel());
}
public DataContext(
ShellSettings shellSettings,
IDbContextFactoryHolder dbContextFactoryHolder,
IAssemblyProvider assemblyProvider)
{
_shellSettings = shellSettings;
_dbContextFactoryHolder = dbContextFactoryHolder;
_assemblyProvider = assemblyProvider;
_instanceId = Guid.NewGuid();
}
public ConfigurationResponseBuilder(ConfigCache configCache,
IEnvironmentVariableProvider envs,
IAssemblyProvider assemblyProvider,
UsageTracking usageTracking)
{
UsageTracking = usageTracking;
ConfigCache = configCache;
Envs = envs;
AssemblyProvider = assemblyProvider;
}
public AutostartProvider(IAssemblyProvider assemblyProvider)
{
this.assemblyProvider = assemblyProvider;
// Default
this.IsEnabled = true;
// Find a key, if we can, which points to our current location
this.keyName = this.FindKeyNameAndCheckAccess();
}
public AutoPersistenceModel GetAutoPersistenceModel(IAssemblyProvider assemblyProvider, string sessionAlias)
{
if (sessionAlias != this.sessionAlias)
{
return nullAutoMap;
}
AutoPersistenceModel autoPersistenceModel = GetAutoPersistenceModel(assemblyProvider);
return autoPersistenceModel;
}
public OrleansServiceInterfaceMapper(IAssemblyProvider assemblyProvider)
{
Mappings = assemblyProvider.GetAllTypes()
.Where(t => t.IsInterface && typeof(IGrain).IsAssignableFrom(t))
.SelectMany(t => t.GetInterfaces().Where(i => i.GetCustomAttribute <HttpServiceAttribute>() != null)
.Select(i => new { CallableInterface = t, ServiceInterface = i }))
.ToDictionary(x => x.ServiceInterface, x => x.CallableInterface);
ExtractHealthStatusServiceType(Mappings.Values);
}
public void NoValueTypesInAssemblies_TestPassed()
{
IAssemblyProvider assemblyProviderMock = Substitute.For <IAssemblyProvider>();
assemblyProviderMock.GetAllTypes().Returns(new[] { typeof(ReferenceTypeConfig) });
ConfigObjectTypeValidator configValidator = new ConfigObjectTypeValidator(assemblyProviderMock);
configValidator.Validate();
}
public PathTransformer(IAssemblyProvider assemblyProvider)
{
this.basePath = Path.GetDirectoryName(assemblyProvider.Location);
this.specials = new Dictionary <string, string>()
{
// This is legacy, in case it's managed to slip through the configuration
["EXEPATH"] = this.basePath,
};
}
public AutoPersistenceModel GetAutoPersistenceModel(IAssemblyProvider assemblyProvider, string sessionAlias)
{
if (sessionAlias != this.sessionAlias)
{
return(nullAutoMap);
}
AutoPersistenceModel autoPersistenceModel = GetAutoPersistenceModel(assemblyProvider);
return(autoPersistenceModel);
}
internal LoaderConfig()
{
BootstrapperClassName = BootstrapperDefaultClassName;
ConfigureMethods = new Dictionary <string, Func <bool> >
{
{ ConfigureDefaultMethodName, AlwaysCall }
};
InstanceCreator = new ExpressionCreator();
AssemblyProvider = new FileSystemAssemblyProvider(Directory.GetCurrentDirectory(), "*.dll");
}
public InstalledUpdateVariantHandler(
IUpdateDownloader updateDownloader,
IProcessStartProvider processStartProvider,
IAssemblyProvider assemblyProvider,
IApplicationState applicationState)
{
this.updateDownloader = updateDownloader;
this.processStartProvider = processStartProvider;
this.assemblyProvider = assemblyProvider;
this.applicationState = applicationState;
}
public InstalledUpdateVariantHandler(
IUpdateDownloader updateDownloader,
IProcessStartProvider processStartProvider,
IAssemblyProvider assemblyProvider,
IApplicationState applicationState)
{
this.updateDownloader = updateDownloader;
this.processStartProvider = processStartProvider;
this.assemblyProvider = assemblyProvider;
this.applicationState = applicationState;
}
public static Type GetClrType(IEdmType edmType, IEdmModel edmModel, IAssemblyProvider assemblyProvider)
{
IEdmSchemaType edmSchemaType = edmType as IEdmSchemaType;
Contract.Assert(edmSchemaType != null);
string typeName = edmSchemaType.FullName();
IEnumerable <Type> matchingTypes = GetMatchingTypes(typeName, assemblyProvider);
return(matchingTypes.FirstOrDefault());
}
/// <summary>
/// Withes the specified assembly provider.
/// </summary>
/// <param name="assemblyProvider">The assembly provider.</param>
/// <returns>RocketFunctionHostBuilder.</returns>
internal RocketFunctionHostBuilder With(IAssemblyProvider assemblyProvider) => new RocketFunctionHostBuilder(
Builder,
FunctionsAssembly,
_startupInstance,
_environment,
Scanner,
AssemblyCandidateFinder,
assemblyProvider,
DiagnosticSource,
ServiceProperties
);
public void ConfigureServices(IServiceCollection services, IConfiguration configuration, AppConfig appConfig)
{
_assemblyProvider = new AppAssemblyProvider();
_typeFinder = new AppTypeFinder(_assemblyProvider);
CallConfigureServicesMethodOfStartups(services, configuration, _typeFinder);
AddAutoMapper(_typeFinder);
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
IAssemblyProvider provider = app.ApplicationServices.GetRequiredService <IAssemblyProvider>();
IEdmModel model = GetEdmModel(provider);
// Single
app.UseMvc(builder => builder.MapODataRoute("odata", model));
}
internal void Initialize(IAssemblyProvider assemblyProvider, bool isQueryCompositionMode)
{
_isQueryCompositionMode = isQueryCompositionMode;
_configuredNavigationSources = new HashSet <NavigationSourceConfiguration>();
_mappedTypes = new HashSet <StructuralTypeConfiguration>();
_ignoredTypes = new HashSet <Type>();
ModelAliasingEnabled = true;
_allTypesWithDerivedTypeMapping = new Lazy <IDictionary <Type, List <Type> > >(
() => BuildDerivedTypesMapping(assemblyProvider),
isThreadSafe: false);
}
protected ApplicationHost(string applicationId, IAssemblyProvider assemblyProvider, Func <IModule, bool> modulePredicate = null)
{
if (string.IsNullOrWhiteSpace(applicationId))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(applicationId));
}
ApplicationId = applicationId;
AssemblyProvider = assemblyProvider ?? throw new ArgumentNullException(nameof(assemblyProvider));
this.modulePredicate = modulePredicate;
}
/// <summary>
/// Configure with a specific <see cref="IContainer"/>.
/// </summary>
/// <param name="container"><see cref="IContainer"/> to configure with.</param>
/// <param name="assembliesConfiguration"><see cref="AssembliesConfiguration"/> to use.</param>
/// <param name="assemblyProvider"><see cref="IAssemblyProvider"/> to use for providing assemblies.</param>
/// <param name="contractToImplementorsMap"><see cref="IContractToImplementorsMap"/> for keeping track of
/// the relationship between contracts and implementors.</param>
/// <returns>Configuration object to continue configuration on.</returns>
public static Configure With(
IContainer container,
AssembliesConfiguration assembliesConfiguration,
IAssemblyProvider assemblyProvider,
IContractToImplementorsMap contractToImplementorsMap)
{
return(With(
container,
new DefaultConventions(container),
new DefaultBindings(assembliesConfiguration, assemblyProvider, contractToImplementorsMap),
assembliesConfiguration));
}
/// <summary>
/// Creates a runtime hash based on the assembly provider
/// </summary>
/// <param name="assemblyProvider"></param>
/// <returns></returns>
public RuntimeHashPaths AddAssemblies(IAssemblyProvider assemblyProvider)
{
foreach (Assembly assembly in assemblyProvider.Assemblies)
{
// TODO: We need to test this on a published website
if (!assembly.IsDynamic && assembly.Location != null)
{
AddFile(new FileInfo(assembly.Location));
}
}
return(this);
}
public SynchronizeIt(Workspace workspace, IBrowserConnection browserConnection,
ISessionWebPovider sessionWebProvider, IAssemblyProvider assemblyProvider)
{
_workspace = workspace;
_browserConnection = browserConnection;
_sessionWebProvider = sessionWebProvider;
_assemblyProvider = assemblyProvider;
_browserConnection.SessionWebRequested += _browserConnection_SessionWebRequested;
_browserConnection.SessionWebReceived += BrowserConnectionSessionWebReceived;
_browserConnection.UrlToMatchReceived += _browserConnection_UrlToMatchReceived;
_workspace.WorkspaceChanged += _workspace_WorkspaceChanged;
}
public ControllerActionDescriptorProvider([NotNull] IAssemblyProvider assemblyProvider,
[NotNull] IControllerModelBuilder applicationModelBuilder,
[NotNull] IGlobalFilterProvider globalFilters,
[NotNull] IOptions <MvcOptions> optionsAccessor,
[NotNull] ILoggerFactory loggerFactory)
{
_assemblyProvider = assemblyProvider;
_applicationModelBuilder = applicationModelBuilder;
_globalFilters = globalFilters.Filters;
_modelConventions = optionsAccessor.Options.ApplicationModelConventions;
_logger = loggerFactory.Create <ControllerActionDescriptorProvider>();
}
/// <summary>
/// Initializes a new instance of the <see cref="RocketHostBuilder" /> class.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="scanner">The scanner.</param>
/// <param name="assemblyCandidateFinder">The assembly candidate finder.</param>
/// <param name="assemblyProvider">The assembly provider.</param>
/// <param name="diagnosticSource">The diagnostic source.</param>
/// <param name="serviceProperties">The service properties.</param>
public RocketHostBuilder(
IHostBuilder builder,
IConventionScanner scanner,
IAssemblyCandidateFinder assemblyCandidateFinder,
IAssemblyProvider assemblyProvider,
DiagnosticSource diagnosticSource,
IServiceProviderDictionary serviceProperties
) : base(scanner, assemblyCandidateFinder, assemblyProvider, diagnosticSource, serviceProperties)
{
Builder = builder;
Logger = new DiagnosticLogger(diagnosticSource);
}
private static IEdmModel GetEdmModel(IAssemblyProvider provider)
{
var builder = new ODataConventionModelBuilder(provider);
builder.ContainerName = "NorthwindContext";
builder.EntitySet <Product>("Products");
builder.EntitySet <Order>("Orders");
return(builder.GetEdmModel());
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionBinderBase"/> class.
/// </summary>
/// <param name="requestContainer">The request container.</param>
protected ExpressionBinderBase(IServiceProvider requestContainer)
{
Contract.Assert(requestContainer != null);
RequestContainer = requestContainer;
QuerySettings = new ODataQuerySettings();// requestContainer.GetRequiredService<ODataQuerySettings>();
Model = requestContainer.GetRequiredService <IEdmModel>();
// The IWebApiAssembliesResolver service is internal and can only be injected by WebApi.
// This code path may be used in the cases when the service container available
// but may not contain an instance of IWebApiAssembliesResolver.
InternalAssembliesResolver = requestContainer.GetRequiredService <IAssemblyProvider>();
}
public AutostartProvider(IAssemblyProvider assemblyProvider)
{
this.assemblyProvider = assemblyProvider;
// Default
this.IsEnabled = true;
this.CheckAccess();
// Find a key, if we can, which points to our current location
if (this.CanRead)
this.keyName = this.FindKeyName();
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultAssemblyProvider"/> class.
/// </summary>
public DefaultAssemblyProvider()
{
var localAssemblies = AppDomain.CurrentDomain.GetAssemblies()
.Where(x => x.GetTypes()
.Where(t => string.IsNullOrEmpty(t.Namespace) == false)
.Where(t => t.Namespace.StartsWith(nameof(ConnectedDevelopment), StringComparison.OrdinalIgnoreCase))
.Any() == true)
.ToList();
var provider = new AssemblyProvider(localAssemblies);
_provider = provider;
}
private static void DiscoverAssemblies(IAssemblyProvider assemblyProvider, string extensionsPath, bool includingSubpaths)
{
// TODO: remove this workaround in the next major release
// (it is done this way now only to avoid changing the IAssemblyProvider public interface in the minor release).
if (assemblyProvider is DefaultAssemblyProvider)
{
ExtensionManager.SetAssemblies((assemblyProvider as DefaultAssemblyProvider).GetAssemblies(extensionsPath, includingSubpaths));
}
else
{
ExtensionManager.SetAssemblies(assemblyProvider.GetAssemblies(extensionsPath));
}
}
public ConfigurationResponseBuilder(ConfigCache configCache,
IEnvironment envs,
IAssemblyProvider assemblyProvider,
UsageTracking usageTracking,
ServiceArguments serviceArguments,
CurrentApplicationInfo appInfo)
{
UsageTracking = usageTracking;
ServiceArguments = serviceArguments;
AppInfo = appInfo;
ConfigCache = configCache;
Envs = envs;
AssemblyProvider = assemblyProvider;
}
public ResourceViewLocationProviderFixture()
{
ResourceViewLocationProvider.Ignore.Clear();
this.reader = A.Fake<IResourceReader>();
this.assemblyProvider = A.Fake<IAssemblyProvider>();
this.viewProvider = new ResourceViewLocationProvider(this.reader, this.assemblyProvider);
if (!ResourceViewLocationProvider.RootNamespaces.ContainsKey(this.GetType().Assembly))
{
ResourceViewLocationProvider.RootNamespaces.Add(this.GetType().Assembly, "Some.Resource");
}
A.CallTo(() => this.assemblyProvider.GetAssembliesToScan()).Returns(new[] { this.GetType().Assembly });
}
public PortableUpdateVariantHandler(
IUpdateDownloader updateDownloader,
IProcessStartProvider processStartProvider,
IFilesystemProvider filesystem,
IApplicationPathsProvider pathsProvider,
IAssemblyProvider assemblyProvider,
IApplicationState applicationState)
{
this.updateDownloader = updateDownloader;
this.processStartProvider = processStartProvider;
this.filesystem = filesystem;
this.pathsProvider = pathsProvider;
this.assemblyProvider = assemblyProvider;
this.applicationState = applicationState;
}
/// <summary>
/// Initializes a new instance of <see cref="ResourceBasedTextResource"/> to read strings from *.resx files
/// </summary>
public ResourceBasedTextResource(IAssemblyProvider assemblyProvider)
{
this.assemblyProvider = assemblyProvider;
var resources =
from assembly in this.assemblyProvider.GetAssembliesToScan()
from resourceName in assembly.GetManifestResourceNames()
where resourceName.EndsWith(".resources")
let parts = resourceName.Split(new[] { '.' })
let name = parts[parts.Length - 2]
let baseName = resourceName.Replace(".resources", string.Empty)
select new
{
Name = name,
Manager = new ResourceManager(baseName, assembly)
};
this.resourceManagers =
resources.ToDictionary(x => x.Name, x => x.Manager, StringComparer.OrdinalIgnoreCase);
}
internal static IEnumerable<Type> GetLoadedTypes(IAssemblyProvider assemblyProvider)
{
List<Type> result = new List<Type>();
// Go through all assemblies referenced by the application and search for types matching a predicate
IEnumerable<Assembly> assemblies = assemblyProvider.CandidateAssemblies;
foreach (Assembly assembly in assemblies)
{
Type[] exportedTypes = null;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetTypes on a null (or dynamic?) assembly
continue;
}
try
{
exportedTypes = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch
{
continue;
}
if (exportedTypes != null)
{
result.AddRange(exportedTypes.Where(t => t != null && t.GetTypeInfo().IsVisible));
}
}
return result;
}
public static void Register([NotNull] IAssemblyProvider provider)
{
_provider = provider;
}
/// <summary>
/// Initializes a new instance of <see cref="Assemblies"/>
/// </summary>
public Assemblies(IAssemblyProvider assemblyProvider)
{
_assemblies = assemblyProvider.GetAll();
}
/// <summary>
/// Initializes a new instance of <see cref="DefaultControllerTypeProvider"/>.
/// </summary>
/// <param name="assemblyProvider"><see cref="IAssemblyProvider"/> that provides assemblies to look for
/// controllers in.</param>
public DefaultControllerTypeProvider(IAssemblyProvider assemblyProvider)
{
_assemblyProvider = assemblyProvider;
}
public ProcessStartProvider(IAssemblyProvider assemblyProvider)
{
this.processRunnerPath = Path.Combine(Path.GetDirectoryName(assemblyProvider.Location), processRunner);
}
public NamespaceFilteredControllerTypeProvider(IAssemblyProvider provider)
: base(provider)
{
}
/// <summary>
/// Creates a new <see cref="DefaultViewComponentDescriptorProvider"/>.
/// </summary>
/// <param name="assemblyProvider">The <see cref="IAssemblyProvider"/>.</param>
public DefaultViewComponentDescriptorProvider(IAssemblyProvider assemblyProvider)
{
_assemblyProvider = assemblyProvider;
}
public ApplicationPathsProvider(IAssemblyProvider assemblyProvider)
{
this.ExePath = Path.GetDirectoryName(assemblyProvider.Location);
}
/// <summary>
/// Initializes a new instance of the <see cref="LightAssemblyBase"/> class.
/// </summary>
public LightAssemblyBase(IAssemblyProvider origin)
{
if (origin == null)
throw new ArgumentNullException("origin");
Origin = origin;
}
/// <summary>
/// Apply the filter query to the given IQueryable.
/// </summary>
/// <remarks>
/// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies
/// how this method should handle null propagation.
/// </remarks>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param>
/// <param name="assemblyProvider">The <see cref="IAssemblyProvider"/> to use.</param>
/// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns>
public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings, IAssemblyProvider assemblyProvider)
{
if (query == null)
{
throw Error.ArgumentNull("query");
}
if (assemblyProvider == null)
{
throw Error.ArgumentNull("assemblyProvider");
}
if (Context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
var filter = FilterBinder.Bind(FilterClause, Context.ElementClrType, Context.Model, assemblyProvider, querySettings);
return ExpressionHelpers.Where(query, filter, Context.ElementClrType);
}
public InstallerCertificateVerifier(IAssemblyProvider assemblyProvider, IFilesystemProvider filesystemProvider)
{
this.assemblyProvider = assemblyProvider;
this.filesystemProvider = filesystemProvider;
}
public UpdateCheckerFactory(IAssemblyProvider assemblyProvider, IUpdateNotificationClientFactory updateNotificationClientFactory)
{
this.assemblyProvider = assemblyProvider;
this.updateNotificationClientFactory = updateNotificationClientFactory;
}