C# BusConfiguration.Conventions方法代码示例

    protected override void OnStart(string[] args)
    {
        var busConfiguration = new BusConfiguration();
        busConfiguration.EndpointName("SendNsbMessage");
        busConfiguration.UseSerialization<XmlSerializer>();

        if (Environment.UserInteractive && Debugger.IsAttached)
        {
            //TODO: For production use, please select a durable persistence.
            busConfiguration.UsePersistence<InMemoryPersistence>();

            //TODO: For production use, please script your installation.
            busConfiguration.EnableInstallers();
            busConfiguration.Conventions()
                .DefiningCommandsAs(t => t.Namespace != null && t.Namespace == "IntegrationSample.Messages.Commands");
            busConfiguration.Conventions()
                .DefiningEventsAs(t => t.Namespace != null && t.Namespace == "IntegrationSample.Messages.Events");
        }
        var startableBus = Bus.Create(busConfiguration);
        bus = startableBus.Start();
        Console.WriteLine("\r\nPress '1' to send an NSB message\r\n");

        while (true)
        {
            var key = Console.ReadKey(true);
            if (key.KeyChar == '1')
                bus.Send(new ProcessOrder()
                {
                    OrderId = Guid.NewGuid(),

                });
            Console.WriteLine("\r\nPress '1' to send an NSB message\r\n");
        }
    }

        public void Customize(BusConfiguration configuration)
        {
            configuration.UseSerialization<JsonSerializer>();
            configuration.UsePersistence<InMemoryPersistence>();

            // configure message definitions
            configuration.Conventions().DefiningCommandsAs(e => e.Namespace != null & e.Namespace.EndsWith("Commands"));
            configuration.Conventions().DefiningEventsAs(e => e.Namespace != null & e.Namespace.EndsWith("Events"));
        }

        public void Customize(BusConfiguration config)
        {
            if (Environment.UserInteractive)
                Console.Title = "Saga";

            // herewith we can avoid implementation of the ICommand interface in the Nsb.Commands assembly
            config.Conventions().DefiningCommandsAs(t => t.Namespace != null && t.Namespace.StartsWith("Nsb") && t.Name.EndsWith("Command"));

            // herewith we can avoid implementation of the IMessage interface in the Nsb.Messages assembly
            config.Conventions().DefiningMessagesAs(t => t.Namespace != null && t.Namespace.StartsWith("Nsb") && t.Name.EndsWith("Message"));

            config.UsePersistence<InMemoryPersistence>();
        }

        public void Should_not_throw_propertyType_is_not_serializable_if_a_IDataBusSerializer_is_already_registered()
        {
            if (!Debugger.IsAttached)
            {
                Assert.Ignore("This only work in debug mode.");
            }

            var builder = new BusConfiguration();
            builder.EndpointName("xyz");
            builder.TypesToScan(new[]
                {
                    typeof(MessageWithNonSerializableDataBusProperty)
                });
            builder.Conventions().DefiningDataBusPropertiesAs(p => p.Name.EndsWith("DataBus"));
            builder.RegisterComponents(c =>
            {
                c.RegisterSingleton<IDataBus>(new InMemoryDataBus());
                c.ConfigureComponent<IDataBusSerializer>(() => new MyDataBusSerializer(), DependencyLifecycle.SingleInstance);
            });

            var config = builder.BuildConfiguration();
            var feature = new DataBus();

            Assert.DoesNotThrow(() => feature.CheckPrerequisites(new FeatureConfigurationContext(config)));
        }

        static void Main()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<Program>();

            var container = builder.Build();

            var configuration = new BusConfiguration();

            configuration.UseContainer<AutofacBuilder>(c => c.ExistingLifetimeScope(container));

            configuration.UseTransport<AzureStorageQueueTransport>()
                .ConnectionString("UseDevelopmentStorage=true");
            configuration.UsePersistence<AzureStoragePersistence>();
            configuration.UseSerialization<JsonSerializer>();

            configuration.DisableFeature<Sagas>();
            configuration.DisableFeature<TimeoutManager>();

            configuration.Conventions().DefiningCommandsAs(t => t.Namespace != null && t.Namespace.StartsWith("NServiceBusDemo.Messages.Commands"));
            configuration.Conventions().DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("NServiceBusDemo.Messages.Events"));
            configuration.Conventions().DefiningMessagesAs(t => t.Namespace != null && t.Namespace.StartsWith("NServiceBusDemo.Messages.Responses"));

            Bus.Create(configuration).Start();

            using (var scope = container.BeginLifetimeScope())
            {
                scope.Resolve<Program>().Run();
            }
        }

        static void Main()
        {
            // configure the bus
            var busConfiguration = new BusConfiguration();
            busConfiguration.UseSerialization<JsonSerializer>();
            busConfiguration.UsePersistence<RavenDBPersistence>();
            busConfiguration.Conventions().DefiningCommandsAs(e => e.Namespace != null & e.Namespace.EndsWith("Commands"));
            busConfiguration.Conventions().DefiningEventsAs(e => e.Namespace != null & e.Namespace.EndsWith("Events"));

            // start the bus
            var startableBus = Bus.Create(busConfiguration);
            using (var bus = startableBus.Start())
            {
                Start(bus);
            }
        }

        public void Customize(BusConfiguration configuration)
        {
            XmlConfigurator.Configure();
            configuration.UseContainer<NinjectBuilder>(k => k.ExistingKernel(CreateKernel()));
            configuration.RegisterComponents(x => x.ConfigureComponent<IRepository>(
                builder =>
                {
                    return new Repository(() =>
                    {
                        var nh = builder.Build<NHibernateStorageContext>();
                        var e = new OrderContext((DbConnection)nh.Connection);
                        return e;
                    });
                },
                DependencyLifecycle.InstancePerUnitOfWork));
            configuration.RegisterComponents(components => components.ConfigureComponent<UnitOfWork>(DependencyLifecycle.InstancePerUnitOfWork));

            configuration.UsePersistence<NHibernatePersistence>();
            configuration.UseTransport<MsmqTransport>();
            configuration.UseDataBus<FileShareDataBus>().BasePath(Constants.NServiceBus_DataBusBasePath);
            configuration.RijndaelEncryptionService();
            configuration.Transactions();
            configuration.EnableOutbox();
            configuration.Conventions().OrderConventions();
            //
        }

        static void Main( string[] args )
        {
            var config = new BusConfiguration();
            config.UsePersistence<InMemoryPersistence>();
            config.UseSerialization<JsonSerializer>();
            config.UseTransport<RabbitMQTransport>()
                .DisableCallbackReceiver();

            config.Transactions()
                .DisableDistributedTransactions();

            config.EnableInstallers();
            config.Conventions()
                .DefiningCommandsAs( t => t.Namespace != null && t.Namespace.EndsWith( ".Commands" ) )
                .DefiningEventsAs( t => t.Namespace != null && t.Namespace.EndsWith( ".Events" ) )
                .DefiningMessagesAs( t => t.Namespace != null && t.Namespace.EndsWith( ".Messages" ) );

            using( var bus = Bus.Create( config ).Start() )
            {
                Logic.Run( setup =>
                {
                    setup.DefineAction( ConsoleKey.P, "Publish sample event", () =>
                    {
                        bus.Publish<IMessagePublished>(e =>
                        {
                            e.ClientId = "client-id";
                            e.MessageId = "sample-message-id";
                        });
                    } );
                } );
            }
        }

        static void Main(string[] args)
        {
            Console.Title = "Complaint.Backend";

            Console.WriteLine("Complaint Backend starting up...");

            var configuration = new BusConfiguration();
            configuration.Conventions()
                .DefiningCommandsAs(t => t.Namespace != null && t.Namespace.StartsWith("SiriusCyberneticsCorp.InternalMessages"))
                .DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("SiriusCyberneticsCorp.Contract"));

            configuration.CustomConfigurationSource(new CustomConfigurationSource());

            configuration.UseSerialization<JsonSerializer>();
            configuration.UsePersistence<RavenDBPersistence>();
            configuration.UseTransport<MsmqTransport>();

            var bus = Bus.Create(configuration).Start();

            Console.WriteLine("Press any key to shut down.");

            Console.ReadLine();
            Console.WriteLine("Complaint Backend shutting down...");

            bus.Dispose();
        }

    static void Main()
    {
        BusConfiguration busConfiguration = new BusConfiguration();
        busConfiguration.EndpointName("Samples.Scaleout.Sender");
        busConfiguration.EnableInstallers();
        busConfiguration.UseSerialization<JsonSerializer>();
        busConfiguration.UsePersistence<InMemoryPersistence>();
        busConfiguration.Conventions()
            .DefiningMessagesAs(t => t.GetInterfaces().Contains(typeof (IMessage)));

        using (IBus bus = Bus.Create(busConfiguration).Start())
        {
            Console.WriteLine("Press 'Enter' to send a message.");
            Console.WriteLine("Press any other key to exit.");
            while (true)
            {
                ConsoleKeyInfo key = Console.ReadKey();
                Console.WriteLine();

                if (key.Key != ConsoleKey.Enter)
                {
                    return;
                }

                SendMessage(bus);
            }
        }
    }

        public void Customize(BusConfiguration configuration)
        {
            configuration.Conventions()
                .DefiningMessagesAs(t => t.Namespace != null && t.Namespace.EndsWith(".Contracts"));

            configuration.UsePersistence<RavenDBPersistence>();
        }

 Usage(BusConfiguration busConfiguration)
 {
     #region DefiningEncryptedPropertiesAs
     ConventionsBuilder conventions = busConfiguration.Conventions();
     conventions.DefiningEncryptedPropertiesAs(info => info.Name.EndsWith("EncryptedProperty"));
     #endregion
 }

 public void Customize(BusConfiguration config)
 {
     config.Conventions()
         .DefiningCommandsAs(t => t.Namespace != null && t.Namespace.StartsWith("Example2.Internal.Commands"))
         .DefiningEventsAs(t => t.Namespace != null && t.Namespace.StartsWith("Example2.Contracts"))
         .DefiningMessagesAs(t => t.Namespace != null && t.Namespace.StartsWith("Example2.Internal.Messages"));
 }

 public void Customize(BusConfiguration configuration)
 {
     configuration.UseTransport<RabbitMQTransport>();
     configuration.UsePersistence<InMemoryPersistence>();
     configuration.RijndaelEncryptionService();
     UnobtrusiveMessageConventions.Init(configuration.Conventions());
 }

        public static void Init()
        {
            if (Bus != null)
            return;

              lock (SyncLock)
              {
            if (Bus != null)
              return;
            var cfg = new BusConfiguration();

            cfg.EndpointName(MethodBase.GetCurrentMethod().DeclaringType.Namespace);
            cfg.UseTransport<MsmqTransport>();
            cfg.UsePersistence<InMemoryPersistence>();
            cfg.EnableInstallers();
            cfg.UseSerialization<JsonSerializer>();

            cfg.Conventions()
               .DefiningMessagesAs(t => t.Namespace != null && t.Namespace.EndsWith(".Messages"))
               .DefiningCommandsAs(t => t.Namespace != null && t.Namespace.EndsWith(".Commands"))
               .DefiningEventsAs(t => t.Namespace != null && t.Namespace.EndsWith(".Events"));

            Bus = NServiceBus.Bus.Create(cfg).Start();
              }
        }