/// <summary> /// Gets all available types that are considered to be controllers. /// </summary> /// <returns> /// The types that are controllers. /// </returns> public IEnumerable <Type> GetControllerTypes() { return(_assemblyProvider.GetAssemblies() .SelectMany(a => a.GetTypes()) .Where(IsControllerType) .Where(IsIncluded)); }
/// <summary> /// Initial common kernel setup for mocks /// </summary> protected virtual (StandardKernel k, IAssemblyProvider providerMock, IFileSystem fileSystemMock) Setup() { var k = new StandardKernel(); k.Load(new ConfigVerificationModule(new ConsoleLogLoggersModules(), new ServiceArguments(), "InfraTests", infraVersion: null)); var cfg = new HostEnvironment( new TestHostEnvironmentSource( "InfraTests")); k.Bind <IEnvironment>().ToConstant(cfg); k.Bind <CurrentApplicationInfo>().ToConstant(cfg.ApplicationInfo); IAssemblyProvider providerMock = Substitute.For <IAssemblyProvider>(); providerMock.GetAssemblies().Returns(info => new[] { GetType().Assembly }); IFileSystem fileSystemMock = Substitute.For <IFileSystem>(); fileSystemMock.ReadAllTextFromFile(Arg.Any <string>()).Returns(a => LoadPaths); fileSystemMock.Exists(Arg.Any <string>()).Returns(a => true); k.Rebind <IAssemblyProvider>().ToConstant(providerMock); k.Rebind <IFileSystem>().ToConstant(fileSystemMock); return(k, providerMock, fileSystemMock); }
private void MatchUrl(string url) { try { LogInfo($"MatchUrl: {url}"); _log.Info($"MatchUrl: {url}"); var assemblies = _assemblyProvider.GetAssemblies(); if (assemblies != null) { LogInfo($"Compiled successfully."); var urlMatcher = new UrlMatcher(assemblies.Item1, assemblies.Item2); var matchUrlResult = urlMatcher.Match(url); LogInfo($"Matched successfully: {matchUrlResult.ServiceId}-{matchUrlResult.PageId}"); _browserConnection.SendUrlMatchResult(matchUrlResult); if (!string.IsNullOrWhiteSpace(matchUrlResult.PageId)) { OpenDocumentWithType(matchUrlResult.PageId); } } } catch (Exception e) { LogInfo($"Error!!!"); LogInfo(e.Message); LogInfo(e.StackTrace); if (e.InnerException != null) { LogInfo(e.InnerException.Message); LogInfo(e.InnerException.StackTrace); } } }
protected virtual AutoPersistenceModel GetAutoPersistenceModel(IAssemblyProvider assemblyProvider) { IEnumerable <Assembly> allLoadedAssemblies = assemblyProvider.GetAssemblies(); AutoPersistenceModel autoPersistenceModel = GetAutoPersistenceModel(allLoadedAssemblies); return(autoPersistenceModel); }
private List <Type> GetPublicExportedTypes() { return(_typeCache ?? (_typeCache = _assemblyProvider .GetAssemblies() .SelectMany(x => x.GetExportedTypes()) .Where(x => x.IsPublic).ToList())); }
/// <summary> /// Gets all available types that are considered to be controllers. /// </summary> /// <returns> /// The types that are controllers. /// </returns> public IEnumerable <Type> GetControllerTypes() { return(_assemblyProvider.GetAssemblies() .SelectMany(GetAssemblyTypes) .Where(t => !t.IsAbstract) .Where(IsControllerType) .Where(IsIncluded)); }
public TypeResolver(IAssemblyProvider assemblyProvider) { if (assemblyProvider == null) { throw new ArgumentNullException(nameof(assemblyProvider)); } LoadedTypes = assemblyProvider.GetAssemblies() .SelectMany(a => a.GetTypes()) .ToList(); }
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)); } }
private void DiscoverAssemblies() { var modulesPath = _configuration?["Modules:Path"]; var assembliesPath = string.IsNullOrEmpty(modulesPath) ? null : _hostingEnvironment.ContentRootPath + modulesPath; var assemblies = new List <Assembly>(); foreach (var extDirectory in Directory.GetDirectories(assembliesPath)) { var extAssemblies = _assemblyProvider.GetAssemblies(extDirectory); assemblies.AddRange(extAssemblies); } ExtensionManager.SetAssemblies(assemblies); }
public bool IsTestMethod(StackFrame details) { foreach (var assembly in _assemblyProvider.GetAssemblies()) { var type = assembly.GetType(details.TypeName); var method = type?.GetTypeInfo().GetDeclaredMethod(details.MethodName); if (method == null) { continue; } var attributes = method.GetCustomAttributes(); return(attributes.Any(x => AttributeNames.Any(p => p == x.GetType().Name))); } return(false); }
/// <summary> /// Initial common kernel setup for mocks /// </summary> public (StandardKernel k, IAssemblyProvider providerMock, IFileSystem fileSystemMock) Setup() { var k = new StandardKernel(); k.Load(new ConfigVerificationModule(new ConsoleLogLoggersModules(), new ServiceArguments(), "InfraTests", infraVersion: null)); IAssemblyProvider providerMock = Substitute.For <IAssemblyProvider>(); providerMock.GetAssemblies().Returns(info => new[] { GetType().Assembly }); IFileSystem fileSystemMock = Substitute.For <IFileSystem>(); fileSystemMock.ReadAllTextFromFile(Arg.Any <string>()).Returns(a => _loadPaths); fileSystemMock.Exists(Arg.Any <string>()).Returns(a => true); k.Rebind <IAssemblyProvider>().ToConstant(providerMock); k.Rebind <IFileSystem>().ToConstant(fileSystemMock); return(k, providerMock, fileSystemMock); }
public Stream GetAsStream(string resourceName = null, bool exactMatch = false) { var frame = _stackTraceProvider.GetStack().FirstOrDefault(_methodDetailsFilter.IsTestMethod); if (frame == null) { return(Stream.Null); } resourceName = resourceName ?? frame.MethodName; foreach (var assembly in _resourceAssemblyProvider.GetAssemblies()) { var resources = assembly.GetManifestResourceNames(); return(exactMatch ? GetExactMatchResource(assembly, resourceName, resources) : GetSimilarResource(frame, assembly, resourceName, resources)); } return(Stream.Null); }
private void SearchAssembliesAndRebindIConfig(IKernel kernel) { IAssemblyProvider aProvider = kernel.Get <IAssemblyProvider>(); foreach (Assembly assembly in aProvider.GetAssemblies()) { foreach (Type configType in assembly.GetTypes().Where(ConfigObjectCreator.IsConfigObject)) { IConfigObjectCreatorWrapper cocWrapper = kernel.Get <IConfigObjectCreatorWrapper>(new ConstructorArgument("type", configType)); dynamic getLataestLambda = cocWrapper.GetLambdaOfGetLatest(configType); kernel.Rebind(typeof(Func <>).MakeGenericType(configType)).ToMethod(t => getLataestLambda()); Type sourceBlockType = typeof(ISourceBlock <>).MakeGenericType(configType); kernel.Rebind(sourceBlockType).ToMethod(m => cocWrapper.GetChangeNotifications()); dynamic changeNotificationsLambda = cocWrapper.GetLambdaOfChangeNotifications(sourceBlockType); kernel.Rebind(typeof(Func <>).MakeGenericType(sourceBlockType)).ToMethod(i => changeNotificationsLambda()); kernel.Rebind(configType).ToMethod(i => cocWrapper.GetLatest()); } } }
public IEnumerable <AutoRunModuleInfo> Discover() { var assemblies = _assemblyProvider.GetAssemblies(); return(Reflect.Reflect .AssembliesMarkedByAttribute <AutoRunDiscoverableAttribute>(assemblies.ToArray()) .TypesMarkedByAttribute <AutoRunAttribute>() .Select(type => new AutoRunModuleInfo { ModuleType = type.ReflectedType, ModuleFactory = () => { var factoryType = type.Attribute.FactoryType; var factory = factoryType?.GetConstructor(Type.EmptyTypes)?.Invoke(new object[] { }); if (factory is IModuleFactory moduleFactory) { return moduleFactory.New(); } try { if (Activator.CreateInstance(type.ReflectedType) is ISImplModule sImplModule) { return sImplModule; } } catch (Exception) { // ignored } throw new Exception( $"The AutoRunModule: '{type.ReflectedType.FullName}' is required to either contain a parameterless constructor or implement IModuleFactory "); } }));
private IDictionary <Type, IList <Type> > FindAnnotatedTypes(TypeDefined typeDefined) { IEnumerable <Type> types = appDomain.GetAssemblies() .SelectMany(assembly => assembly.GetTypes()); IDictionary <Type, IList <Type> > typesPerAttribute = new Dictionary <Type, IList <Type> > { { typeof(RegisterTypeAttribute), new List <Type>() }, { typeof(RegisterProviderAttribute), new List <Type>() } }; foreach (Type classType in types) { // todo avoid nested loop #pragma warning disable AV1532 foreach (KeyValuePair <Type, IList <Type> > kv in typesPerAttribute) #pragma warning restore AV1532 { Type attributeType = kv.Key; IList <Type> typesWithAttribute = kv.Value; if (classType.IsDefined(attributeType, typeDefined == TypeDefined.Inherit)) { if (classType.IsStatic() || classType.IsAbstract) { throw new InvalidOperationException( $"Class type must not be static or abstract to be used with RegisterTypeAttribute: {classType.FullName}"); } typesWithAttribute.Add(classType); } } } return(typesPerAttribute); }
public static IEnumerable <Assembly> GetAssemblies(IAssemblyProvider assemblyProvider) { return(assemblyProvider.GetAssemblies()); }
private static IEnumerable <AssemblyDiffPair> CreateAssemblyPairs(IAssemblyProvider firstProvider, IAssemblyProvider secondProvider) => firstProvider.GetAssemblies(_targets).Join(secondProvider.GetAssemblies(_targets), f => f.Name.ToUpperInvariant(), f => f.Name.ToUpperInvariant(), (f1, f2) => new AssemblyDiffPair(f1, f2));
private static void DiscoverAssemblies(IAssemblyProvider assemblyProvider, string extensionsPath) { ExtensionManager.SetAssemblies(assemblyProvider.GetAssemblies(extensionsPath)); }
private static void DiscoverAssemblies(IAssemblyProvider assemblyProvider, string extensionsPath, bool includingSubpaths) { ExtensionManager.SetAssemblies(assemblyProvider.GetAssemblies(extensionsPath, includingSubpaths)); }
/// <summary> /// Find classes of type /// </summary> /// <param name="assignTypeFrom">Assign type from</param> /// <param name="onlyConcreteClasses">A value indicating whether to find only concrete classes</param> /// <returns>Result</returns> /// <returns></returns> public IEnumerable <Type> FindClassesOfType(Type assignTypeFrom, bool onlyConcreteClasses = true) { return(FindClassesOfType(assignTypeFrom, _assemblyProvider.GetAssemblies(), onlyConcreteClasses)); }
/// <summary> /// Initializes a new instance of the <see cref="FilteringAssemblyProvider"/> class. /// </summary> /// <param name="provider">The provider.</param> public FilteringAssemblyProvider(IAssemblyProvider provider) { this.assemblies = provider == null ? new Assembly[] { } : provider.GetAssemblies(); }
protected virtual AutoPersistenceModel GetAutoPersistenceModel(IAssemblyProvider assemblyProvider) { IEnumerable<Assembly> allLoadedAssemblies = assemblyProvider.GetAssemblies(); AutoPersistenceModel autoPersistenceModel = GetAutoPersistenceModel(allLoadedAssemblies); return autoPersistenceModel; }