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