C# IMessageBus.AsObservable方法代码示例

        public DemoTileListener(IMessageBus messageBus, ITrace trace)
        {
            _messageBus = messageBus;
            _trace = trace;

            _messageBus.AsObservable<TileLoadStartMessage>().Do(m => OnTileBuildStarted(m.TileCenter)).Subscribe();
            _messageBus.AsObservable<TileLoadFinishMessage>().Do(m => OnTileBuildFinished(m.Tile)).Subscribe();
            _messageBus.AsObservable<TileDestroyMessage>().Do(m => OnTileDestroyed(m.Tile)).Subscribe();
        }

        /// <summary> Creates instance of <see cref="EditorController"/>. </summary>
        public EditorController(ITileModelEditor tileModelEditor, IMessageBus messageBus)
        {
            _tileModelEditor = tileModelEditor;

            messageBus.AsObservable<TerrainPointMessage>().Subscribe(HandlePointMessage);
            messageBus.AsObservable<TerrainPolylineMessage>().Subscribe(HandlePolylineMessage);
            messageBus.AsObservable<TerrainPolygonMessage>().Subscribe(HandlePolygonMessage);

            messageBus.AsObservable<EditorActionMode>().Subscribe(a => _actionMode = a);
        }

        private void Initialize()
        {
            // wait for loading..
            //gameObject.GetComponent<Rigidbody>().constraints = RigidbodyConstraints.FreezeAll;
            var thirdPersonControll = gameObject.GetComponent<ThirdPersonController>();
            _initialGravity = thirdPersonControll.gravity;
            thirdPersonControll.gravity = 0;

            _appManager = ApplicationManager.Instance;

            _messageBus = _appManager.GetService<IMessageBus>();

            _appManager.CreateConsole(true);

            _messageBus.AsObservable<GameRunner.GameStartedMessage>()
                .Where(msg => msg.Tile.RenderMode == RenderMode.Scene)
                .Take(1)
                .Delay(TimeSpan.FromSeconds(2)) // give extra seconds..
                .ObserveOnMainThread()
                .Subscribe(_ =>
                {
                    var position = transform.position;
                    var elevation = _appManager.GetService<IElevationProvider>()
                        .GetElevation(new MapPoint(position.x, position.z));
                    transform.position = new Vector3(position.x, elevation + 90, position.z);
                    thirdPersonControll.gravity = _initialGravity;
                });

            // ASM should be started from non-UI thread
               Observable.Start(() => _appManager.RunGame(), Scheduler.ThreadPool);
        }

        void Awake()
        {
            var appManager = ApplicationManager.Instance;
            _geoPositionObserver = appManager.GetService<ITileController>();
            _messageBus = appManager.GetService<IMessageBus>();
            _trace = appManager.GetService<ITrace>();

            var elevationProvider = appManager.GetService<IElevationProvider>();

            _messageBus.AsObservable<GeoPosition>()
                .SubscribeOn(Scheduler.ThreadPool)
                .Do(position =>
                {
                    _trace.Info(CategoryName, "GeoPosition: {0}", position.ToString());
                    // notify ASM about position change to process tiles
                    _geoPositionObserver.OnNext(position.Coordinate);
                    // calculate new world position
                    var mapPoint = GeoProjection.ToMapCoordinate(appManager.Coordinate, position.Coordinate);
                    var elevation = elevationProvider.GetElevation(position.Coordinate);
                    var worldPosition = new Vector3((float)mapPoint.X, elevation, (float)mapPoint.Y);
                    // set transform on UI thread
                    Observable.Start(() => transform.position = worldPosition, Scheduler.MainThread);

                }).Subscribe();

            _messageBus.AsObservable<TileLoadFinishMessage>()
                .Take(1)
                .ObserveOnMainThread()
                .Subscribe(_ =>
                {
                    Observable.Start(() =>
                    {
                        // read nmea file with gps data
                        using (Stream stream = new FileStream(GpsTrackFile, FileMode.Open))
                        {
                            _trace.Info(CategoryName, "start to read geopositions from {0}", GpsTrackFile);

                            _mocker = new NmeaPositionMocker(stream, _messageBus);
                            _mocker.OnDone += (s, e) => _trace.Info(CategoryName, "trace is finished");
                            _mocker.Start(Thread.Sleep);
                        }
                    }, Scheduler.ThreadPool);
                });
        }

        public IrcConnection(IMessageBus messageBus)
            : base(messageBus)
        {
            commands = new IrcCommands(this.WriteLine);
            this.messageBus = messageBus;

            var myMessages = messageBus
                .AsObservable<DataReceivedMessage>()
                .Where(m => m.Connection == this); //only handle messages sent by this connection

            AttachParser(messageBus, myMessages);

            myMessages
                .Where(m => Patterns.ActionRegex.IsMatch(m.Data))
                .Do(_ => Console.ForegroundColor = ConsoleColor.Gray)
                .Do(m => Console.WriteLine("*** ActionRegex Message ****"))
                .Subscribe();

            myMessages
                .Where(m => Patterns.CtcpRequestRegex.IsMatch(m.Data))
                .Do(_ => Console.ForegroundColor = ConsoleColor.Gray)
                .Do(m => Console.WriteLine("*** CtcpRequestRegex Message ****"))
                .Subscribe();

            myMessages
                .Where(m => Patterns.InviteRegex.IsMatch(m.Data))
                .Do(_ => Console.ForegroundColor = ConsoleColor.Gray)
                .Do(m => Console.WriteLine("*** InviteRegex Message ****"))
                .Subscribe();

            myMessages
                .Where(m => Patterns.TopicRegex.IsMatch(m.Data))
                .Do(_ => Console.ForegroundColor = ConsoleColor.Gray)
                .Do(m => Console.WriteLine("*** TopicRegex Message ****"))
                .Subscribe();



            myMessages
                .Where(m => Patterns.KickRegex.IsMatch(m.Data))
                .Do(_ => Console.ForegroundColor = ConsoleColor.Gray)
                .Do(m => Console.WriteLine("*** KickRegex Message ****"))
                .Subscribe();

            myMessages
                .Where(m => Patterns.CtcpReplyRegex.IsMatch(m.Data))
                .Do(_ => Console.ForegroundColor = ConsoleColor.Gray)
                .Do(m => Console.WriteLine("*** CtcpReply Message ****"))
                .Subscribe();
        }

        private void Initialize()
        {
            // initialize services
            _compositionRoot = TestHelper.GetCompositionRoot(_worldZeroPoint);

            // get local references
            _messageBus = _compositionRoot.GetService<IMessageBus>();
            _trace = _compositionRoot.GetService<ITrace>();
            _tileController = _compositionRoot.GetService<ITileController>();

            SetupMapData();

            // set observer to react on geo position changes
            _messageBus.AsObservable<GeoPosition>()
                .ObserveOn(Scheduler.MainThread)
                .Subscribe(position =>
            {
                _trace.Debug(TraceCategory, "GeoPosition: {0}", position.ToString());
                _tileController.OnPosition(position.Coordinate, LevelOfDetails);
            });
        }

//.........这里部分代码省略.........
               .Where(f => f.Success)
               .Select(f => new IrcJoinMessage 
               { 
                   Connection = this, 
                   User = f.Groups[1].Value,
                   UserIdentity = f.Groups[2].Value,
                   Channel = f.Groups[3].Value.ToUpperInvariant(),
               })
               .Do(m => messageBus.Send(m))
               .Subscribe();

            //send typed part message
            myMessages
               .Select(m => Patterns.PartRegex.Match(m.Data))
               .Where(f => f.Success)
               .Select(f => new IrcPartMessage
               {
                   Connection = this,
                   User = f.Groups[1].Value,
                   UserIdentity = f.Groups[2].Value,
                   Channel = f.Groups[3].Value.ToUpperInvariant()
               })
               .Do(m => messageBus.Send(m))
               .Subscribe();

            //send typed part message
            myMessages
               .Select(m => Patterns.QuitRegex.Match(m.Data))
               .Where(f => f.Success)
               .Select(f => new IrcQuitMessage
               {
                   Connection = this,
                   User = f.Groups[1].Value,
                   UserIdentity = f.Groups[2].Value,
               })
               .Do(m => messageBus.Send(m))
               .Subscribe();

            //send typed channel message
            myMessages
               .Select(m => Patterns.MessageRegex.Match(m.Data))
               .Where(f => f.Success)
               .Where(f => f.Groups[3].Value.StartsWith("#"))
               .Select(f => new IrcChannelSayMessage 
               { 
                   Connection = this,
                   User = f.Groups[1].Value,
                   UserIdentity=f.Groups[2].Value,
                   Channel = f.Groups[3].Value.ToUpperInvariant(),
                   Message=f.Groups[4].Value }
               )
               .Do(m => messageBus.Send(m))
               .Subscribe();

            //send typed private message
            myMessages
               .Select(m => Patterns.MessageRegex.Match(m.Data))
               .Where(f => f.Success)
               .Where(f => !f.Groups[3].Value.StartsWith("#"))
               .Select(f => new IrcPrivateSayMessage
               {
                   Connection = this,
                   User = f.Groups[1].Value,
                   UserIdentity = f.Groups[2].Value,
                   ToUser = f.Groups[3].Value,
                   Message = f.Groups[4].Value
               }
               )
               .Do(m => messageBus.Send(m))
               .Subscribe();

            myMessages
               .Select(m => Patterns.NickRegex.Match(m.Data))
               .Where(f => f.Success)
               .Select(f => new IrcNickMessage
               {
                   Connection = this,
                   User = f.Groups[1].Value,
                   UserIdentity = f.Groups[2].Value,
                   NewNick = f.Groups[3].Value,
               })
               .Do(m => messageBus.Send(m))
               .Subscribe();

            var replyCodes = messageBus.AsObservable<IrcReplyCodeMessage>();

            //send typed channel info
            replyCodes
                .Where(m => m.Code == 332)
                .Select(m => SendChannelInfo(m))
                .Do(m => messageBus.Send(m))
                .Subscribe();

            //send typed channel member info
            replyCodes
                .Where(m => m.Code == 353)                               
                .Do(m => SendChannelMembers(m))
                .Subscribe();

        }

 void Start()
 {
     _messageBus= ApplicationManager.Instance.GetService<IMessageBus>();
     _messageBus.AsObservable<TerrainInputMode>().Subscribe(m => _inputMode = m);
 }