C# ReactiveList.FirstOrDefault方法代码示例

        public RecentViewModel(Guid id, string metaDataSlug, IEnumerable<RecentItemViewModel> recentItems) {
            _id = id;
            RecentItems = new ReactiveList<RecentItemViewModel>(recentItems);

            // TODO: This is a tab, and tabs are only active while shown
            // but we want to receive these events regardless of being active or not, otherwise we are not uptodate when the user switches to us.
            // Or we need to find a different approach!
            Listen<ContentUsed>()
                .Where(x => {
                    var contentId = GetId(x.Content);
                    lock (RecentItems)
                        return _id == x.Content.GameId && RecentItems.All(r => r.Id != contentId);
                })
                .Select(x => {
                    var ri = x.Content.MapTo<RecentItemViewModel>();
                    if (x.Token != null)
                        ri.UpdateExecute(x.Token);
                    return ri;
                })
                .ObserveOnMainThread()
                .Subscribe(x => {
                    lock (RecentItems)
                        RecentItems.Insert(0, x);
                });

            Listen<RecentItemRemoved>()
                .ObserveOnMainThread()
                .Subscribe(x => {
                    lock (RecentItems) {
                        RecentItems.RemoveAll(r => r.Id == x.Content.Id);
                    }
                });

            // TODO: Stop manually moving, start auto sorting in View (ICollectionView or ReactiveDerivedCollection)...
            // Then remove this event
            Listen<ContentUsed>()
                .Select(x => {
                    var contentId = GetId(x.Content);
                    lock (RecentItems)
                        return RecentItems.FirstOrDefault(r => r.Id == contentId);
                })
                .Where(x => x != null)
                .ObserveOnMainThread()
                .Subscribe(x => {
                    lock (RecentItems)
                        RecentItems.Move(RecentItems.IndexOf(x), 0);
                });

            AddContent =
                ReactiveCommand.CreateAsyncTask(
                    async x => await RequestAsync(new OpenWebLink(ViewType.Browse, metaDataSlug)).ConfigureAwait(false));


            this.WhenActivated(d => {
                RefreshUpdated();
                d(new TimerWithoutOverlap(TimeSpan.FromMinutes(1),
                    () => RxApp.MainThreadScheduler.Schedule(RefreshUpdated)));
            });
        }

        public RepositoryPublishViewModel(
            IRepositoryHosts hosts,
            IRepositoryPublishService repositoryPublishService,
            IVSServices vsServices,
            IConnectionManager connectionManager)
        {
            this.vsServices = vsServices;
            this.hosts = hosts;

            title = this.WhenAny(
                x => x.SelectedHost,
                x => x.Value != null ?
                    string.Format(CultureInfo.CurrentCulture, "Publish repository to {0}", x.Value.Title) :
                    "Publish repository"
            )
            .ToProperty(this, x => x.Title);

            Connections = new ReactiveList<IConnection>(connectionManager.Connections);
            this.repositoryPublishService = repositoryPublishService;

            if (Connections.Any())
            {
                SelectedConnection = Connections.FirstOrDefault(x => x.HostAddress.IsGitHubDotCom()) ?? Connections[0];
            }

            accounts = this.WhenAny(x => x.SelectedConnection, x => x.Value != null ? hosts.LookupHost(x.Value.HostAddress) : RepositoryHosts.DisconnectedRepositoryHost)
                .Where(x => !(x is DisconnectedRepositoryHost))
                .SelectMany(host => host.ModelService.GetAccounts())
                .ObserveOn(RxApp.MainThreadScheduler)
                .ToProperty(this, x => x.Accounts, initialValue: new ReadOnlyCollection<IAccount>(new IAccount[] {}));

            this.WhenAny(x => x.Accounts, x => x.Value)
                .WhereNotNull()
                .Where(accts => accts.Any())
                .Subscribe(accts => {
                    var selectedAccount = accts.FirstOrDefault();
                    if (selectedAccount != null)
                    {
                        SelectedAccount = accts.FirstOrDefault();
                    }
                });

            isHostComboBoxVisible = this.WhenAny(x => x.Connections, x => x.Value)
                .WhereNotNull()
                .Select(h => h.Count > 1)
                .ToProperty(this, x => x.IsHostComboBoxVisible);

            InitializeValidation();

            PublishRepository = InitializePublishRepositoryCommand();

            canKeepPrivate = CanKeepPrivateObservable.CombineLatest(PublishRepository.IsExecuting,
                (canKeep, publishing) => canKeep && !publishing)
                .ToProperty(this, x => x.CanKeepPrivate);

            isPublishing = PublishRepository.IsExecuting
                .ToProperty(this, x => x.IsPublishing);

            var defaultRepositoryName = repositoryPublishService.LocalRepositoryName;
            if (!string.IsNullOrEmpty(defaultRepositoryName))
            {
                DefaultRepositoryName    = defaultRepositoryName;
            }

            this.WhenAny(x => x.SelectedConnection, x => x.SelectedAccount,
                (a,b) => true)
                .Where(x => RepositoryNameValidator.ValidationResult != null && SafeRepositoryNameWarningValidator.ValidationResult != null)
                .Subscribe(async _ =>
                {
                    var name = RepositoryName;
                    RepositoryName = null;
                    await RepositoryNameValidator.ResetAsync();
                    await SafeRepositoryNameWarningValidator.ResetAsync();
                    RepositoryName = name;
                });
        }