public override void welcome(Publisher publisher, SubscriberStub subStub)
 {
     if (Greeter != null)
     {
         Greeter.Welcome(TypedPublisher, subStub);
     }
 }

        private static void Run()
        {
            using (var countdown = new CountdownEvent(2))
            {
                var subscriber = new Subscriber(MqttBrokerAddress, MqttBrokerPort);
                subscriber.Subscribe(Topic.Hello, Topic.Goodbye);
                subscriber.OnMessage += (topic, payload) =>
                {
                    if (topic == Topic.Hello)
                    {
                        var msg = JsonConvert.DeserializeObject<HelloMessage>(payload);
                        _log.Info("Topic: " + topic);
                        _log.Info("Message: " + msg);
                        countdown.Signal();
                    }
                    else if (topic == Topic.Goodbye)
                    {
                        var msg = JsonConvert.DeserializeObject<GoodbyeMessage>(payload);
                        _log.Info("Topic: " + topic);
                        _log.Info("Message: " + msg);
                        countdown.Signal();
                    }
                };

                var publisher = new Publisher(MqttBrokerAddress, MqttBrokerPort);
                publisher.Publish(Topic.Hello, new HelloMessage() { Name = "John Smith", Date = DateTime.Now });
                publisher.Publish(Topic.Goodbye, new GoodbyeMessage() { Name = "Jane Smith", Date = DateTime.Now });
                countdown.Wait();
            }
        }

 public override void farewell(Publisher publisher, SubscriberStub subStub)
 {
     if (Greeter != null)
     {
         Greeter.Farewell(TypedPublisher, subStub);
     }
 }

 public Publisher AddPublisher(Publisher publisher)
 {
     var query = Ninject.Get<InsertPublisherQuery>();
     query.Publisher = publisher;
     query.Execute();
     return publisher;
 }

        public void FireGenericEventArgs(
            Publisher publisher,
            Subscriber subscriber)
        {
            const int Value = 42;

            "establish a publisher firing an event with generic event args"._(() =>
                {
                    publisher = new Publisher();
                });

            "establish a subscriber listening to the event of the publisher"._(() =>
                {
                    subscriber = new Subscriber();

                    subscriber.RegisterEvent(publisher);
                });

            "when the publisher fires the event"._(() =>
                {
                    publisher.FireEvent(Value);
                });

            "it should pass value to event handler"._(() =>
                {
                    subscriber.ReceivedValue
                        .Should().Be(Value);
                });
        }

 static void Main(string[] args)
 {
     Publisher publish = new Publisher();
     Subscriber sub = new Subscriber(publish);
     CustemerEventArgs arg = new CustemerEventArgs(3000);
     publish.DoSomething(arg);
 }

 public Publisher DeletePublisher(Publisher publisher)
 {
     var query = Ninject.Get<DeletePublisherQuery>();
     query.Publisher = publisher;
     query.Execute();
     return publisher;
 }

        static void Main(string[] args)
        {
            /*
             * Make sure this path contains the umundoNativeCSharp.dll!
             */
            SetDllDirectory("C:\\Users\\sradomski\\Desktop\\build\\umundo\\lib");
            org.umundo.core.Node node = new org.umundo.core.Node();
            Publisher pub = new Publisher("pingpong");
            PingReceiver recv = new PingReceiver();
            Subscriber sub = new Subscriber("pingpong", recv);
            node.addPublisher(pub);
            node.addSubscriber(sub);

            while (true)
            {
                Message msg = new Message();
                String data = "data";
                System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
                byte[] buffer = enc.GetBytes(data);
                msg.setData(buffer);
                msg.putMeta("foo", "bar");
                Console.Write("o");
                pub.send(msg);
                System.Threading.Thread.Sleep(1000);
            }
        }

        public void One_Publisher_One_Subscriber_Batch_Broadcast()
        {
            using (var publisher = new Publisher())
            using (var subscriber = new Subscriber())
            {
                var endpoint = GetEndpoint();
                publisher.Bind(endpoint);
                subscriber.Connect(endpoint);

                Thread.Sleep(100);

                var counterSignal = new CounterSignal(NumberOfMessagesToReceive);
                subscriber.MessageReceived += (s, m) => counterSignal.Increment();

                var messageSent = new TestMessage();

                var batch = new List<TestMessage>();
                for (var i = 0; i < NumberOfMessagesToReceive; i++)
                    batch.Add(messageSent);

                var sw = Stopwatch.StartNew();
                publisher.Broadcast(batch);
                Assert.IsTrue(counterSignal.Wait(TimeOut), "Timeout waiting for message");
                sw.Stop();

                Assert.Inconclusive("{0} elapsed reading {1} messages ({2:N0} per second)", sw.Elapsed, NumberOfMessagesToReceive, NumberOfMessagesToReceive / sw.Elapsed.TotalSeconds);
            }
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="publisher">Frame publisher instance</param>
 /// <param name="dispatcher">Dispatcher instance used to show frame canvas thread</param>
 /// <param name="screen">Canvas to draw image on</param>
 public FrameUiMonitor(Publisher<IFrame> publisher, Dispatcher dispatcher, System.Windows.Controls.Canvas screen)
     : base(publisher)
 {
     _dispatcher = dispatcher;
     _canvas = screen;
     _imageBrush = new ImageBrush();
 }

 /// <summary>
 /// Welcomes the specified publisher.
 /// </summary>
 /// <param name="pub">The publisher.</param>
 /// <param name="subStub">The subscriber stub.</param>
 public override void welcome(Publisher pub, SubscriberStub subStub)
 {
     Message greeting = Message.toSubscriber(subStub.getUUID());
     greeting.putMeta("participant", Username + ";" + Globals.Score.ToString());
     greeting.putMeta("subscriber", Globals.sub.getUUID());
     pub.send(greeting);
 }

 static void Main()
 {
     Publisher eventPublisher = new Publisher();
     new Subscriber("Pesho", eventPublisher);
     new Subscriber("Gosho", eventPublisher);
     eventPublisher.RaiseSampleEvent();
 }

        public static void Main()
        {
            var serverAddress = ConfigurationManager.AppSettings.Get("ServerAddress");
            var serverPort = int.Parse(ConfigurationManager.AppSettings.Get("ServerPort"));

            var clientAddress = ConfigurationManager.AppSettings.Get("ClientAddress");
            var clientPort = int.Parse(ConfigurationManager.AppSettings.Get("ClientPort"));

            var cs = new UdpClientServer();
            var serverChannel = new UdpCommunicationChannel(cs, new ChannelConfig { Address = serverAddress, Port = serverPort });
            var clientChannel = new UdpCommunicationChannel(cs, new ChannelConfig { Address = clientAddress, Port = clientPort });

            _userService = new GitHubUserSearchService(new HttpClientFactory());
            _githubBrowser = new GithubBrowser(new HttpClientFactory());

            var userListener = new Listener<UserQuery, UserResponse>(clientChannel, serverChannel);
            userListener.ListenObservable(GetUser);

            var repoListener = new Listener<RepoQuery, RepoResponse>(clientChannel, serverChannel);
            repoListener.ListenObservable(GetRepo);

            var favListener = new Listener<FavQuery, FavResponse>(clientChannel, serverChannel);
            favListener.ListenObservable(AddToFav);

            var publisher = new Publisher<RepoNotification>(serverChannel);
            _githubBrowser.NewCommitsFeed
                .Select(c => new RepoNotification { Commit = c })
                .Subscribe(publisher);

            Console.ReadLine();
        }

        public void Handlers_Can_Be_Unsubscribed()
        {
            var pub = new Publisher();
            var calledSubscribers = new List<int>();
            var sub1 = new InstanceSubscriber(1, pub, calledSubscribers.Add);
            var sub2 = new InstanceSubscriber(2, pub, calledSubscribers.Add);
            StaticSubscriber.FooWasRaised = false;
            StaticSubscriber.Subscribe(pub);

            // Make sure they really were subscribed
            pub.Raise();
            calledSubscribers.Should().Equal(1, 2);
            StaticSubscriber.FooWasRaised.Should().BeTrue();

            calledSubscribers.Clear();
            sub1.Unsubscribe(pub);
            pub.Raise();
            calledSubscribers.Should().Equal(2);

            StaticSubscriber.FooWasRaised = false;
            StaticSubscriber.Unsubscribe(pub);
            pub.Raise();
            StaticSubscriber.FooWasRaised.Should().BeFalse();

            calledSubscribers.Clear();
            sub2.Unsubscribe(pub);
            pub.Raise();
            calledSubscribers.Should().BeEmpty();

            // Make sure subscribers are not collected before the end of the test
            GC.KeepAlive(sub1);
            GC.KeepAlive(sub2);
        }

 public void publisher_can_bind_multiple_different_endpoints()
 {
     using (var publisher = new Publisher())
     {
         publisher.Bind(new RedFoxEndpoint("/path1"));
         publisher.Bind(new RedFoxEndpoint("/path2"));
     }
 }

 public ActionResult Delete(int PublisherID)
 {
     myHandler = new BusinessLogicHandler();
     publisher = new Publisher();
     publisher.PublisherID = PublisherID;
     publisher = myHandler.GetPublisher(PublisherID);
     return View(publisher);
 }

        public void Init()
        {
            // discover and wire up components

            // start inital controllers
            Publisher = new Publisher();
            Publisher.Init(_endPoint);
        }

    static void Main()
    {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber(Message, pub);

        // Call the method that raises the event.
        pub.Execute(1000);
    }

        static void Main()
        {
            Publisher eventPublisher = new Publisher();
            new Subscriber("Pesho", eventPublisher); //create subscribers for the event
            new Subscriber("Gosho", eventPublisher);

            eventPublisher.RaiseSampleEvent(); //sample event is raised by the publisher and handled by the subscribers
        }

 public void publishers_bind_same_endpoint_twice_fails()
 {
     using (var publisher = new Publisher())
     {
         var endpoint = new RedFoxEndpoint("/path");
         publisher.Bind(endpoint);
         Assert.Throws<InvalidOperationException>(() => publisher.Bind(endpoint));
     }
 }