示例#1
0
        private void InitializeBindings()
        {
            LogFilesSourceCache.Connect()
            .AutoRefresh(logFile => logFile.IsOpen)
            .AutoRefresh(logFile => logFile.RefreshIndicator)
            .Sort(SortExpressionComparer <LogFile> .Descending(logFile => logFile.DateLastOpened))
            .Filter(logFile => logFile.IsOpen && _selectedLogView != null && _selectedLogView.LogFilePaths.Contains(logFile.NetworkFile?.FullName))
            .ObserveOnDispatcher()
            .Bind(out _logFiles)
            .DisposeMany()
            .Subscribe();

            DatabasesSourceCache.Connect()
            .AutoRefresh(database => database.IsOpen)
            .AutoRefresh(database => database.RefreshIndicator)
            .Sort(SortExpressionComparer <Database> .Descending(database => database.DateLastOpened))
            .Filter(database => database.IsOpen && _selectedLogView != null && _selectedLogView.DatabaseNames.Contains(database.Name))
            .ObserveOnDispatcher()
            .Bind(out _databases)
            .DisposeMany()
            .Subscribe();

            //FileSizeText = fileWatcher.Latest.Select(fn => fn.Size)
            //    .Select(size => size.FormatWithAbbreviation())
            //    .DistinctUntilChanged()
            //    .ForBinding();

            //NumUnfilteredErrors = LogEntriesSourceCache.Connect().ToListObservable()
            //    .DistinctUntilChanged()
            //    .ForBinding();

            //LogEntriesSourceCache.Items
            //    .Where(l => (_selectedLogView.LogFilePaths.Contains(l.Identifier) || _selectedLogView.DatabaseNames.Contains(l.Identifier)) && l.Type == LogMessageType.Error)
            //    .Subscribe(
            //    NumUnfilteredErrors = 5,
            //    ex =>
            //    {
            //        NumUnfilteredErrors = 0;
            //    },
            //    () => { NumUnfilteredErrors = 0; });
        }
        private void InitializeBindings()
        {
            #region Log views
            var logViewsSharedSource = LogViewsSourceCache.Connect();
            logViewsSharedSource
            .AutoRefresh(l => l.DateLastOpened)
            .Sort(SortExpressionComparer <LogView> .Descending(l => l.DateLastOpened))
            .ObserveOnDispatcher()
            .Bind(out var logViews)
            .Subscribe();
            logViewsSharedSource
            .AutoRefresh(l => l.DateLastOpened)
            .Sort(SortExpressionComparer <LogView> .Descending(l => l.DateLastOpened))
            .Top(_numberInRecents)
            .ObserveOnDispatcher()
            .Bind(out var recentlyUsedLogViews)
            .Subscribe();
            logViewsSharedSource
            .AutoRefresh(l => l.DateLastOpened)
            .AutoRefresh(l => l.IsPinned)
            .Filter(l => l.IsPinned)
            .Sort(SortExpressionComparer <LogView> .Descending(l => l.DateLastOpened))
            .ObserveOnDispatcher()
            .Bind(out var pinnedLogViews)
            .Subscribe();

            LogViews             = logViews;
            RecentlyUsedLogViews = recentlyUsedLogViews;
            PinnedLogViews       = pinnedLogViews;
            #endregion

            #region Log files
            var logFilesSharedSource = LogFilesSourceCache.Connect();

            logFilesSharedSource
            .AutoRefresh(l => l.DateLastOpened)
            .Sort(SortExpressionComparer <LogFile> .Descending(l => l.DateLastOpened))
            .ObserveOnDispatcher()
            .Bind(out var allLogFiles)
            .Subscribe();
            logFilesSharedSource
            .AutoRefresh(l => l.DateLastOpened)
            .Sort(SortExpressionComparer <LogFile> .Descending(l => l.DateLastOpened))
            .Top(_numberInRecents)
            .ObserveOnDispatcher()
            .Bind(out var recentlyUsedLogFiles)
            .Subscribe();
            logFilesSharedSource
            .AutoRefresh(l => l.IsPinned)
            .AutoRefresh(l => l.DateLastOpened)
            .Filter(l => l.IsPinned)
            .Sort(SortExpressionComparer <LogFile> .Descending(l => l.DateLastOpened))
            .ObserveOnDispatcher()
            .Bind(out var pinnedLogFiles)
            .Subscribe();

            LogFiles             = allLogFiles;
            RecentlyUsedLogFiles = recentlyUsedLogFiles;
            PinnedLogFiles       = pinnedLogFiles;
            #endregion

            #region Databases
            var databasesSharedSource = DatabasesSourceCache.Connect();

            databasesSharedSource
            .ObserveOnDispatcher()
            .Bind(out var databases)
            .Subscribe();
            databasesSharedSource
            .AutoRefresh(d => d.DateLastOpened)
            .Sort(SortExpressionComparer <Database> .Descending(d => d.DateLastOpened))
            .Top(_numberInRecents)
            .ObserveOnDispatcher()
            .Bind(out var recentlyUsedDatabases)
            .Subscribe();
            databasesSharedSource
            .AutoRefresh(l => l.IsPinned)
            .AutoRefresh(d => d.DateLastOpened)
            .Filter(l => l.IsPinned)
            .Sort(SortExpressionComparer <Database> .Descending(d => d.DateLastOpened))
            .ObserveOnDispatcher()
            .Bind(out var pinnedDatabases)
            .Subscribe();

            Databases             = databases;
            RecentlyUsedDatabases = recentlyUsedDatabases;
            PinnedDatabases       = pinnedDatabases;
            #endregion

            #region Searchable openable objects
            //TODO: Right now if item added to source caches, this source cache won't see it. Maybe do a join?
            //TODO: Need to open search popup when user clicks on search box if there's text in the search box.
            AllOpenableObjectsSourceCache.AddOrUpdate(LogViewsSourceCache.Items);
            AllOpenableObjectsSourceCache.AddOrUpdate(LogFilesSourceCache.Items);
            AllOpenableObjectsSourceCache.AddOrUpdate(DatabasesSourceCache.Items);


            AllOpenableObjectsSourceCache.Connect()
            .AutoRefresh(d => SearchTerm)
            .Filter(o => string.IsNullOrEmpty(SearchTerm) || o.Identifier.ToLower().Contains(SearchTerm.ToLower()))
            .ObserveOnDispatcher()
            .Bind(out var searchableOpenableObjects)
            .Subscribe();
            SearchableOpenableObjects = searchableOpenableObjects;
            #endregion
        }