Example #1
0
 private void Unsubscribe(IMessageBusSubscription subscription)
 {
     lock (mutex)
     {
         this.subscriptions.Remove(subscription as Subscription);
     }
 }
Example #2
0
        public MessageBusListenerService(IConfiguration configuration, IMessageBusSubscription busTopicSubscription)//, ILoggerFactory loggerFactory)
        {
            // this.logger = loggerFactory.CreateLogger<BusListenerService>();
            this.configuration = configuration;
            subscriptionClient = new SubscriptionClient(
                configuration.GetConnectionString("ServiceBusConnectionString"),
                TOPIC_PATH,
                SUBSCRIPTION_NAME);

            topicSubscription = busTopicSubscription;
            handler           = ProcessMessageAsync;
        }
        public ClientSubscription(IConfiguration configuration, IProcessMessage processData)
        {
            this.configuration = configuration;
            //subscriptionClient = new SubscriptionClient(
            //    configuration.GetConnectionString("ServiceBusConnectionString"),
            //    TOPIC_PATH,
            //  SUBSCRIPTION_NAME);
            _processData = processData;
            // _processData = new MessageConsumer();

            topicSubscription = new ServiceBusTopicSubscription(processData, configuration);// busTopicSubscription;
            //handler = ProcessMessageAsync;
        }
Example #4
0
        private void EnsureInitialized()
        {
            if (isInitialized)
            {
                return;
            }
            if (this.broadcastSubscription == null)
            {
                this.broadcastSubscription = messageBus.Subscribe <IGameSessionCommand>(MessageBus.Broadcast, Broadcast);
            }

            client.Initialize(credentialsProvider.Get());
            isInitialized = true;
        }
Example #5
0
        private void EnsureInitialized()
        {
            if (isInitialized)
            {
                return;
            }

            if (this.broadcastSubscription == null)
            {
                this.broadcastSubscription = messageBus.Subscribe <string>(MessageBus.Broadcast, Broadcast);
            }
            if (this.messageSubscription == null)
            {
                this.messageSubscription = messageBus.Subscribe <string>(MessageBus.Message, MessageUser);
            }

            client.Initialize(credentialsProvider.Get(), channelProvider.Get());
            isInitialized = true;
        }
Example #6
0
        public static async Task HotdogsAsync()
        {
            ColorConsole.WriteLine();
            ColorConsole.WriteLine(ConsoleColor.White, "** Hotdogs example **");

            IMessageBusSubscription subscription = null;

            try
            {
                // Subscribe to the default FileToRead message bus
                subscription = Use <FileToRead> .Bus.SubscribeSimple(
                    async message =>
                {
                    ColorConsole.WriteLine($"Looking for hotdogs in {Path.GetFileName(message.Filename)}...");

                    using (var fileStream = File.OpenText(message.Filename))
                    {
                        while (fileStream.EndOfStream == false)
                        {
                            var line = await fileStream.ReadLineAsync();
                            if (line.IndexOf("hotdog", StringComparison.InvariantCultureIgnoreCase) != -1)
                            {
                                Console.WriteLine("* Oh! I love hotdogs! " + line);
                            }
                        }
                    }

                    Console.WriteLine($"Looking for hotdogs in {Path.GetFileName(message.Filename)} done...");
                });

                var filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "hotdogsexample\\hotdata.txt");

                Console.WriteLine();
                ColorConsole.WriteLine(ConsoleColor.White, "*** await PublishAsync ***");

                // Publish asynchronous
                await Use <FileToRead> .Bus.PublishAsync(
                    new FileToRead
                {
                    Filename = filePath
                });

                Console.WriteLine("await PublishAsync done!");
                Console.WriteLine();

                Console.WriteLine("*** Publish ***");

                // Publish asynchronous
                Use <FileToRead> .Bus.Publish(
                    new FileToRead
                {
                    Filename = filePath
                });

                Console.WriteLine("Publish done!");

                // Just to make sure the message is done before continuing
                await Task.Delay(200);

                ColorConsole.WriteLine();
                ColorConsole.WriteLine(ConsoleColor.White, "** End of hotdogs example **");
            }
            finally
            {
                // Unsubscribe!
                // to prevent us from adding subscription after subscription when running the example multiple times.
                subscription?.Dispose();
            }
        }