public void positive_test()
{
var rule = NamespaceRule.For <Red.Message1>();
rule.Matches(typeof(Red.Message1)).ShouldBeTrue();
rule.Matches(typeof(Red.Message2)).ShouldBeTrue();
rule.Matches(typeof(Red.Message3)).ShouldBeTrue();
}
private static Func <Type, bool> GetNamespacePredicate(string @namespace, NamespaceRule namespaceRule)
{
return(namespaceRule switch
{
NamespaceRule.StartsWith => (t) => t.Namespace !.StartsWith(@namespace),
NamespaceRule.Equals => (t) => t.Namespace == @namespace,
_ => throw new ArgumentOutOfRangeException(nameof(namespaceRule)),
});
public void negative_test()
{
var rule = NamespaceRule.For <Red.Message1>();
rule.Matches(typeof(Green.Message1)).ShouldBeFalse();
rule.Matches(typeof(Green.Message2)).ShouldBeFalse();
rule.Matches(typeof(Green.Message3)).ShouldBeFalse();
}
public ShellAppBuilder <TAppBuilder> RegisterAllAppModels(NamespaceRule namespaceRule = NamespaceRule.StartsWith)
{
var appType = this.appBuilder.ApplicationType;
containerBuilder.RegisterAllModels(appType.Assembly, appType.Namespace !, namespaceRule);
return(this);
}
public void add_namespace_publishing_rule_2()
{
theRegistry.Channel(x => x.Outbound).AcceptsMessagesInNamespace(typeof(BusSettings).Namespace);
channelFor(x => x.Outbound).Rules.Single()
.ShouldBe(NamespaceRule.For <BusSettings>());
channelFor(x => x.Upstream).Rules.Any().ShouldBeFalse();
}
public void add_namespace_publishing_rule()
{
theRegistry.Channel(x => x.Outbound).AcceptsMessagesInNamespaceContainingType <BusSettings>();
channelFor(x => x.Outbound).Rules.Single()
.ShouldEqual(NamespaceRule.For <BusSettings>());
channelFor(x => x.Upstream).Rules.Any().ShouldBeFalse();
}
public static ContainerBuilder RegisterMenus <TModule>(this ContainerBuilder builder, NamespaceRule namespaceRule = NamespaceRule.StartsWith)
where TModule : IModule
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
var moduleType = typeof(TModule);
return(builder.RegisterMenus(moduleType.Assembly, moduleType.Namespace !, namespaceRule));
}
public static ContainerBuilder RegisterViewModels(this ContainerBuilder builder, Assembly assembly, string @namespace, NamespaceRule namespaceRule = NamespaceRule.StartsWith)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (@namespace is null)
{
throw new ArgumentNullException(nameof(@namespace));
}
var namespacePredicate = GetNamespacePredicate(@namespace !, namespaceRule);
builder.RegisterAssemblyTypes(assembly)
.AssignableTo <ViewModel>()
.Where(t => namespacePredicate(t))
.AsSelf()
.InstancePerDependency();
return(builder);
}
public static ContainerBuilder RegisterAllModels(this ContainerBuilder builder, Assembly assembly, string @namespace, NamespaceRule namespaceRule = NamespaceRule.StartsWith)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (@namespace is null)
{
throw new ArgumentNullException(nameof(@namespace));
}
builder.RegisterViewModels(assembly, @namespace, namespaceRule);
builder.RegisterDocuments(assembly, @namespace, namespaceRule);
builder.RegisterTools(assembly, @namespace, namespaceRule);
builder.RegisterMenus(assembly, @namespace, namespaceRule);
builder.RegisterToolBars(assembly, @namespace, namespaceRule);
builder.RegisterCommands(assembly, @namespace, namespaceRule);
return(builder);
}
public static ContainerBuilder RegisterTools(this ContainerBuilder builder, Assembly assembly, string @namespace, NamespaceRule namespaceRule = NamespaceRule.StartsWith)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (@namespace is null)
{
throw new ArgumentNullException(nameof(@namespace));
}
var namespacePredicate = GetNamespacePredicate(@namespace !, namespaceRule);
builder.RegisterAssemblyTypes(assembly)
.AssignableTo <ITool>()
.Where(t => namespacePredicate(t))
.AsSelf()
.AsImplementedInterfaces()
.SingleInstance();
return(builder);
}
public static ContainerBuilder RegisterToolBars(this ContainerBuilder builder, Assembly assembly, string @namespace, NamespaceRule namespaceRule = NamespaceRule.StartsWith)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (@namespace is null)
{
throw new ArgumentNullException(nameof(@namespace));
}
var namespacePredicate = GetNamespacePredicate(@namespace !, namespaceRule);
builder.RegisterAssemblyTypes(assembly)
.AssignableTo <ToolBarTrayViewModel>()
.Where(t => namespacePredicate(t))
.OnActivating(e =>
{
if (e.Instance is ToolBarTrayViewModel m)
{
e.Context.Resolve <IToolBarManager>().Register(m.Definition);
}
})
.AsSelf()
.InstancePerDependency();
return(builder);
}
public ChannelExpression AcceptsMessagesInNamespaceContainingType <TMessageType>()
{
alter = node => node.Rules.Add(NamespaceRule.For <TMessageType>());
return(this);
}
