C# IMessenger.Send方法代码示例

		public GroupedMoviesViewModel(
			IMessenger messenger,
			IMovieRepository movieRepository)
		{
			MovieRepository = movieRepository;

			if (MovieRepository != null)
			{
				MovieGroups = MovieRepository.LoadMovies()
					.GroupBy(m => m.Genre)
					.Select(g => new MovieGroupViewModel(messenger)
					{
						Title = g.Key.ToString(),
						Movies = g.ToList(),
						GroupImageUrl = g.First().ImageUrl
					});
			}

			MovieTappedCommand = new RelayCommand<Movie>((movie) =>
				{
					var movieGroup = MovieGroups.First(mg => mg.Movies.Contains(movie));
					messenger.Send<MovieSelectedMessage>(new MovieSelectedMessage { Movie = movie, MovieGroup = movieGroup });
				});

			MovieSelectedCommand = new RelayCommand(() =>
				{
					var movieGroup = MovieGroups.First(mg => mg.Movies.Contains(SelectedMovie));
					messenger.Send<MovieSelectedMessage>(new MovieSelectedMessage { Movie = SelectedMovie, MovieGroup = movieGroup });
				});
		}

        public AgileBoardViewModel(IJiraApi jiraApi,
           JiraSessionViewModel jiraSession,
           IMessenger messenger,
           IssuesStatisticsCalculator statisticsCalculator,
           RawAgileBoard board)
        {
            Board = board;

            _messenger = messenger;
            _jiraApi = jiraApi;
            _jiraSession = jiraSession;
            _statisticsCalculator = statisticsCalculator;

            PickUpSprintCommand = new RelayCommand(OpenPickUpSprint, () => Board.Type == "scrum");
            OpenPivotAnalysisCommand = new RelayCommand(() => _messenger.Send(new OpenPivotAnalysisMessage(BoardContent.Issues)));
            OpenEpicsOverviewCommand = new RelayCommand(() => _messenger.Send(new OpenEpicsOverviewMessage(BoardContent.Issues, BoardContent.Epics)), () => Board.Type == "scrum");
            BrowseIssuesCommand = new RelayCommand(() => _messenger.Send(new OpenIssuesBrowserMessage(BoardContent.Issues)));
            OpenGraveyardCommand = new RelayCommand(() => _messenger.Send(new OpenBoardGraveyardMessage(BoardContent.Issues)));
            OpenSprintsVelocityCommand = new RelayCommand(() => _messenger.Send(new OpenSprintsVelocityMessage(BoardContent)), () => Board.Type == "scrum");

            RefreshDataCommand = new RelayCommand(() =>
            {
                _forceReload = true;
                DownloadElements();
            }, () => IsBusy == false);
            FetchChangesCommand = new RelayCommand(() =>
            {
                DownloadElements();
            }, () => IsBusy == false);

            DownloadElements();
        }

		public MovieGroupViewModel(IMessenger messenger)
		{
			SelectCommand = new RelayCommand(() =>
				{
					messenger.Send<GroupSelectedMessage>(new GroupSelectedMessage { GroupName = Title });
				});

			MovieTappedCommand = new RelayCommand<Movie>((movie) =>
				{
					messenger.Send<MovieSelectedMessage>(new MovieSelectedMessage { Movie = movie, MovieGroup = this });
				});
		}

        public MainViewModel(IMessenger bus)
        {
            _bus = bus;

             AddCommand = new RelayCommand(() => _bus.Send(new AddPasswordEntryMessage()));
             BrowseCommand = new RelayCommand(() => _bus.Send(new OpenDirectoriesBrowserMessage()));
             SearchCommand = new RelayCommand(() => _bus.Send(new SearchForEntryMessage()));
             SettingsCommand = new RelayCommand(() => _bus.Send(new ShowSettingsMessage()));
             LockCommand = new RelayCommand(Lock);
             HelpCommand = new RelayCommand(() => _bus.Send(new ShowHelpMessage()));
             RateCommand = new RelayCommand(Rate);
        }

        public ListViewModel(
            IToDoService toDoService, 
            IMessenger messenger, 
            IDispatcher dispatcher,
            ISearchService searchService,
            ISharingService sharingService
            )
        {
            _toDoService = toDoService;
            _searchService = searchService;
            _dispatcher = dispatcher;
            _messenger = messenger;
            _sharingService = sharingService;

            Items = new ObservableCollection<ToDoItem>();
            SearchResult = new ObservableCollection<ToDoItem>();

            RegisterSubscriptions();
            SetupCommands();
            
            Items.CollectionChanged += (s, c) =>
            {
                var count = Items.Count;
                Count = count;
                messenger.Send(new ItemCountChanged { Count = count });
            };
            PopulateItems();
        }

        public SprintDetailsViewModel(RawAgileSprint sprint,
         IList<JiraIssue> issues,
         IMessenger messenger,
         IssuesStatisticsCalculator statisticsCalculator)
        {
            Sprint = sprint;
            Issues = issues;

            _messenger = messenger;
            _statisticsCalculator = statisticsCalculator;

            ScrumCardsCommand = new RelayCommand(() => _messenger.Send(new OpenScrumCardsMessage(Issues)));
            BurnDownCommand = new RelayCommand(() => _messenger.Send(new OpenBurnDownMessage(Sprint, Issues)));
            EngagementCommand = new RelayCommand(() => _messenger.Send(new OpenEngagementChartMessage(Issues)));
            BrowseIssuesCommand = new RelayCommand(() => _messenger.Send(new OpenIssuesBrowserMessage(Issues)));

            GatherStatistics();
        }

        public AgileBoardSelectViewModel(IMessenger messenger, AssistantSettings settings, IJiraApi jiraApi)
        {
            _messenger = messenger;
            _jiraApi = jiraApi;
            _settings = settings;

            Boards = new ObservableCollection<RawAgileBoard>();
            RecentBoards = new ObservableCollection<RawAgileBoard>();
            OpenBoardCommand = new RelayCommand<RawAgileBoard>(OpenBoard);
            OpenSettingsCommand = new RelayCommand(() => _messenger.Send(new OpenSettingsMessage()));
        }

      public BoardGraveyardViewModel(IList<JiraIssue> issues,
         IMessenger messenger,
         AssistantSettings appSettings,
         GraveyardSettings graveyardSettings)
      {
         Issues = issues;
         _messenger = messenger;
         _graveyardSettings = graveyardSettings;
         _graveyardSettings.PropertyChanged += (sender, args) => _reloadNeeded = true;
         _appSettings = appSettings;

         OpenDetailsCommand = new RelayCommand<JiraIssue>(issue => _messenger.Send(new OpenIssueDetailsMessage(issue)));
         OpenInBrowserCommand = new RelayCommand<JiraIssue>(issue => Process.Start(string.Format("{0}/browse/{1}", _appSettings.JiraUrl, issue.Key)));

         OldCreated = new ObservableCollection<JiraIssue>();
         ArchaicCreated = new ObservableCollection<JiraIssue>();
         OldUpdated = new ObservableCollection<JiraIssue>();
         InactiveAssignee = new ObservableCollection<JiraIssue>();
         MissingDescription = new ObservableCollection<JiraIssue>();
      }

        public DetailsViewModel(IMessenger messenger)
        {
            _messenger = messenger;
             if (IsInDesignMode)
             {
            Entry = new PasswordEntry
            {
               Domain = "company.com",
               PasswordLength = 15,
               Tag = "Some tag",
               TagAsCurrentMonth = false,
               UseCapitalLetters = true,
               UseDigits = true,
               UseSpecialCharacters = false,
               Username = "username"
            };
             }

             GenerateCommand = new RelayCommand(Generate);
             EditCommand = new RelayCommand(() => _messenger.Send(new EditEntryMessage(Entry)));
             DeleteCommand = new RelayCommand(Delete);
        }

        public static bool UserPasswordChange(string newPassword, string confirmPassword, IMessenger messenger)
        {
            if (!newPassword.Equals(confirmPassword))
            {
                throw new Csla.Rules.ValidationException("New password and confirmation password must be the same.");
            }

            var user = User.FetchUser(
                new UserCriteria
                    {
                        UserId = BusinessPrincipal.GetCurrentIdentity().UserId
                    });

            if (user != null)
            {
                var password = newPassword;

                user.SetPassword(password);

                user = user.Save();

                if (messenger == null)
                {
                    messenger = MessageHelper.InitializeMessageForUserPasswordChange(user.Email);
                }

                messenger.Message = messenger.Message.Replace(MessageParameter.Password, password);

                messenger.Send();
            }
            else
            {
                throw new ArgumentException("No such user exists.");
            }

            return true;
        }

        public static UserPassword UserPasswordReset(string name, out string password, IMessenger messenger)
        {
            var user = UserPassword.FetchUserPassword(
                new UserPasswordCriteria
                    {
                        Name = name
                    });

            if (user != null)
            {
                password = PasswordHelper.GetRandomPassword(10);

                user.SetPassword(password);

                user = user.Save();

                if (messenger == null)
                {
                    messenger = MessageHelper.InitializeMessageForUserPasswordReset(user.Email);
                }

                messenger.Message = messenger.Message.Replace(MessageParameter.Password, password);

                messenger.Send();
            }
            else
            {
                throw new ArgumentException("No such user exists.");
            }

            return user;
        }

        /// <summary>
        /// Initializes a new instance of the OptionsViewModel class.
        /// </summary>
        public OptionsViewModel(IMessenger msngr)
        {
            MessengerInstance = msngr;
            SaveOptions = new RelayCommand(
                () =>
                {
                    if (UserOptions != null && Options != null)
                    {
                        if (SelectedCP != null)
                        {
                            if (Options.CurrentConnection != SelectedCP)
                            {
                                Options.CurrentConnection = SelectedCP;
                                MessengerInstance.Send<ExecuteAction>(Action.DisconnectRepositories);
                                MessengerInstance.Send<NavigateToPage>(Page.Connections);
                            }

                        }
                        UserOptions.setOptions(Options);
                    }
                },
                () =>
                {
                    return Options.Error == null;
                });
        }

        public MainViewModel(IMessenger messenger)
        {
            _messenger = messenger;

            _messenger.Send(new LoginMessage());
        }