internal async Task <HandlerCall[]> FindCalls(JasperOptions options) { if (_conventionalDiscoveryDisabled) { return(_explicitTypes.SelectMany(actionsFromType).ToArray()); } if (options.ApplicationAssembly == null) { return(new HandlerCall[0]); } _assemblies.Add(options.ApplicationAssembly); var types = await TypeRepository.FindTypes(_assemblies, TypeClassification.Concretes | TypeClassification.Closed, type => _typeFilters.Matches(type)) .ConfigureAwait(false); return(types .Where(x => !x.HasAttribute <JasperIgnoreAttribute>()) .Concat(_explicitTypes) .Distinct() .SelectMany(actionsFromType).ToArray()); }
public void find_type_set() { var widget1 = typeof(IWidget).Assembly; var widget2 = typeof(StructureMap.Testing.Widget2.Rule1).Assembly; var widget3 = typeof(StructureMap.Testing.Widget3.ColorService).Assembly; var task = TypeRepository.FindTypes(new[] { widget1, widget2, widget3 }, type => type.Name.Contains("Color")); task.Wait(); var types = task.Result; /* * ColorRule * ColorService * ColorWidget * ColorWidgetMaker * IColor * Widget1Color * Widget2Color */ types.AllTypes().OrderBy(x => x.Name).Select(x => x.Name) .ShouldHaveTheSameElementsAs("ColorRule", "ColorService", "ColorWidget", "ColorWidgetMaker", "IColor", "Widget1Color", "Widget2Color"); types.FindTypes(TypeClassification.Interfaces).OrderBy(x => x.Name) .ShouldHaveTheSameElementsAs(typeof(IColor)); }
Task <ActionCall[]> IActionSource.FindActions(Assembly applicationAssembly) { var assemblies = _applies.Assemblies.Any() ? _applies.Assemblies : new Assembly[] { applicationAssembly }; return(TypeRepository.FindTypes(assemblies, TypeClassification.Concretes, _typeFilters.Matches) .ContinueWith(x => x.Result.SelectMany(actionsFromType).ToArray())); }
internal async Task <HandlerCall[]> FindCalls(JasperOptionsBuilder registry) { if (_conventionalDiscoveryDisabled) { return(_explicitTypes.SelectMany(actionsFromType).ToArray()); } if (registry.ApplicationAssembly == null) { return(new HandlerCall[0]); } // TODO -- need to expose the module assemblies off of this var types = await TypeRepository.FindTypes(registry.ApplicationAssembly, TypeClassification.Concretes | TypeClassification.Closed, type => _typeFilters.Matches(type)) .ConfigureAwait(false); return(types .Where(x => !x.HasAttribute <JasperIgnoreAttribute>()) .Concat(_explicitTypes) .Distinct() .SelectMany(actionsFromType).ToArray()); }
public IEnumerable <Type> Find() { var assemblies = AssemblyFinder.FindDependentAssemblies().ToArray(); return (TypeRepository.FindTypes(assemblies, TypeClassification.Concretes, x => x.IsConcreteTypeOf <FubuRegistry>() && x.IsConcreteWithDefaultCtor()).Result()); }
public Task <BehaviorChain[]> BuildChains(BehaviorGraph graph, IPerfTimer timer) { var types = TypeRepository.FindTypes(graph.AllAssemblies(), TypeClassification.Concretes, type => type.CanBeCastTo <Topic>()); return (types.ContinueWith( t => { return t.Result.Select(x => new SseTopicChain(x).As <BehaviorChain>()).ToArray(); })); }
public void LookForFeatures() { _types = TypeRepository .FindTypes( GetType().Assembly, TypeClassification.Concretes | TypeClassification.Closed, x => x.CanBeCastTo <IFeatureSettings>() ); }
public void assert_no_type_scanning_failures_happy_path() { TypeRepository.ClearAll(); TypeRepository.FindTypes(GetType().GetTypeInfo().Assembly, TypeClassification.All).Wait(); // SAMPLE: assert-no-type-scanning-failures TypeRepository.AssertNoTypeScanningFailures(); // ENDSAMPLE }
public void TypeRepository_mechanics() { var task = TypeRepository.FindTypes(GetType().Assembly, TypeClassification.Interfaces); task.Wait(); task.Result.ShouldContain(typeof(Interface1)); task.Result.ShouldContain(typeof(Interface2)); task.Result.ShouldNotContain(typeof(Concrete1)); }
public void Start() { if (!Conventions.Any()) { throw new InvalidOperationException($"There are no {nameof(IRegistrationConvention)}'s in this scanning operation. "); } _typeFinder = TypeRepository.FindTypes(_assemblies, type => _filter.Matches(type)); }
public void assert_no_type_scanning_failures_happy_path() { TypeRepository.ClearAll(); TypeRepository.FindTypes(GetType().GetAssembly(), TypeClassification.All).Wait(); #region sample_assert-no-type-scanning-failures TypeRepository.AssertNoTypeScanningFailures(); #endregion }
public static Task Compile(BehaviorGraph graph, IPerfTimer timer, FubuRegistry registry) { return(TypeRepository.FindTypes(graph.AllAssemblies(), TypeClassification.Concretes | TypeClassification.Closed, IsValidationRegistration) .ContinueWith(t => { t.Result.Distinct() .Each(type => registry.Services.For(typeof(IValidationRegistration)).Add(type)); })); }
public void ScanForTypes(PluginGraph pluginGraph) { var registry = new Registry(); TypeRepository.FindTypes(_assemblies, TypeClassification.All, _filter.Matches) .ContinueWith(t => { t.Result.Each(type => _conventions.Each(c => c.Process(type, registry))); }).Wait(); registry.As <IPluginGraphConfiguration>().Configure(pluginGraph); _postScanningActions.Each(x => x(pluginGraph)); }
public Task <Registry> ScanForTypes() { return(TypeRepository.FindTypes(_assemblies, type => _filter.Matches(type)).ContinueWith(t => { var registry = new Registry(); _records.AddRange(t.Result.Records); _conventions.Each(x => x.ScanTypes(t.Result, registry)); return registry; })); }
public static Task Compile(BehaviorGraph graph, IPerfTimer timer) { return(TypeRepository.FindTypes(graph.AllAssemblies(), TypeClassification.Concretes | TypeClassification.Closed, IsAccessorRule) .ContinueWith(t => { var rules = new AccessorRules(); t.Result.Distinct() .Select(x => Activator.CreateInstance(x).As <IAccessorRulesRegistration>()) .Each(x => x.AddRules(rules)); graph.Settings.Replace(rules); })); }
public static Task <ConnegGraph> Build(BehaviorGraph behaviorGraph) { var graph = new ConnegGraph(); var writers = TypeRepository.FindTypes(behaviorGraph.AllAssemblies(), TypeClassification.Concretes | TypeClassification.Closed, x => x.Closes(typeof(IMediaWriter <>))) .ContinueWith(t => graph.Writers.AddRange(t.Result)); var readers = TypeRepository.FindTypes(behaviorGraph.AllAssemblies(), TypeClassification.Concretes | TypeClassification.Closed, x => x.Closes(typeof(IReader <>))) .ContinueWith(t => graph.Readers.AddRange(t.Result)); return(Task.WhenAll(writers, readers).ContinueWith(t => graph)); }
public Task <ActionCall[]> FindActions(Assembly applicationAssembly) { return(TypeRepository.FindTypes(applicationAssembly, TypeClassification.Concretes | TypeClassification.Closed, t => t.CanBeCastTo <ISendMessages>()) .ContinueWith(t => { return t.Result.SelectMany(type => { var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance) .Where(ActionSource.IsCandidate); return methods.Select(method => new ActionCall(type, method)); }).ToArray(); })); }
Task <HandlerCall[]> IHandlerSource.FindCalls(Assembly applicationAssembly) { if (applicationAssembly == null) { throw new ArgumentNullException("applicationAssembly"); } var types = _assemblies.Any() ? TypeRepository.FindTypes(_assemblies, TypeClassification.Concretes, _typeFilters.Matches) : TypeRepository.FindTypes(applicationAssembly, TypeClassification.Concretes, _typeFilters.Matches); return(types.ContinueWith(x => { return x.Result.SelectMany(actionsFromType).ToArray(); })); }
internal async Task <HandlerCall[]> FindCalls(IJasperRegistry registry) { if (registry.ApplicationAssembly == null) { return(new HandlerCall[0]); } // TODO -- need to expose the module assemblies off of this var types = await TypeRepository.FindTypes(registry.ApplicationAssembly, TypeClassification.Concretes | TypeClassification.Closed, type => _typeFilters.Matches(type)) .ConfigureAwait(false); return(types.Where(x => !x.HasAttribute <NotHandlerAttribute>()).SelectMany(actionsFromType).ToArray()); }
internal async Task <MethodCall[]> FindActions(Assembly applicationAssembly) { if (applicationAssembly == null || _disableConventionalDiscovery) { return(_explicitTypes.SelectMany(actionsFromType).ToArray()); } var assemblies = Applies.Assemblies.Any() ? Applies.Assemblies : new[] { applicationAssembly }; var discovered = await TypeRepository.FindTypes(assemblies, TypeClassification.Concretes, _typeFilters.Matches); return(discovered .Concat(_explicitTypes) .Distinct() .SelectMany(actionsFromType).ToArray()); }
public Task <BehaviorChain[]> BuildChains(BehaviorGraph graph, IPerfTimer timer) { var types = TypeRepository.FindTypes(graph.ApplicationAssembly, TypeClassification.Closed | TypeClassification.Concretes, t => t.HasAttribute <ViewSubjectAttribute>()); return(types.ContinueWith(t => { return t.Result.Select(type => { var chain = ChainForType(type); chain.Tags.Add("ActionlessView"); chain.UrlCategory.Category = Categories.VIEW; return chain; }).ToArray(); })); }
public Task <Registry> ScanForTypes() { if (!Conventions.Any()) { throw new StructureMapConfigurationException($"There are no {nameof(IRegistrationConvention)}'s in this scanning operation. "); } return(TypeRepository.FindTypes(_assemblies, type => _filter.Matches(type)).ContinueWith(t => { var registry = new Registry(); _records.AddRange(t.Result.Records); Conventions.Each(x => x.ScanTypes(t.Result, registry)); return registry; })); }
private static async Task applyExtensions(JasperRegistry registry, IEnumerable <Assembly> assemblies) { if (!assemblies.Any()) { return; } Func <Type, bool> filter = type => type.CanBeCastTo <IJasperExtension>() && type.IsConcreteWithDefaultCtor(); var extensionTypes = await TypeRepository.FindTypes(assemblies, TypeClassification.Concretes | TypeClassification.Closed, filter).ConfigureAwait(false); foreach (var extensionType in extensionTypes) { var extension = Activator.CreateInstance(extensionType).As <IJasperExtension>(); extension.Configure(registry); } }
public async Task <ServiceCapabilities> Compile(HandlerGraph handlers, SerializationGraph serialization, IChannelGraph channels, JasperRuntime runtime, ITransport[] transports, UriAliasLookup lookups) { if (runtime.ApplicationAssembly != null) { var publishedTypes = await TypeRepository.FindTypes(runtime.ApplicationAssembly, TypeClassification.Concretes | TypeClassification.Closed, type => _publishFilters.Any(x => x(type))); foreach (var type in publishedTypes) { Publish(type); } } var capabilities = await compile(handlers, serialization, channels, transports, lookups, runtime); capabilities.ServiceName = runtime.ServiceName; return(capabilities); }
private Type findClosedTypeByFullName(string typeFullName, Action <string> log) { var types = TypeRepository.FindTypes(_graph.AllAssemblies().Concat(new [] { Assembly.GetExecutingAssembly() }), TypeClassification.Closed | TypeClassification.Concretes, x => x.FullName == typeFullName).Result(); var typeCount = types.Count(); if (typeCount == 1) { return(types.First()); } log("Unable to set view model type : {0}".ToFormat(typeFullName)); if (typeCount > 1) { var candidates = types.Select(x => x.AssemblyQualifiedName).Join(", "); log("Type ambiguity on: {0}".ToFormat(candidates)); } return(null); }