ReactiveUI 7.0如何處理拋出異常時處置的observables

Question

我真的開始挖掘這個rx的東西......基本上，我跟着this video一起學習了一些關於ReactiveUI的知識，然後開始使用它真的！

我試圖創建一個情況，當我們使用WhenAnyValue來執行一個限制搜索你的類型。而且，如果搜索函數拋出一個異常，我想在視圖模型上設置一個名爲IsError的屬性（這樣我可以顯示一個X或某個東西）。這是我工作的ViewModel的重要部分：

public ReactiveCommand<string, IEnumerable<DictItem>> SearchCmmand; 

... in vm constructor: 

//create our command async from task. executes on worker thread 
SearchCmmand = ReactiveCommand.CreateFromTask<string, IEnumerable<DicItem>>(async x => { 
    this.IsError = false; 
    //this may throw an exception: 
    return await GetFilteredAsync(this.SearchText); 
    }); 

//SearchCommand is subscribable. 
//set the Filtered Items property. executes on main thread 
SearchCmmand.Subscribe(filteredItems => { 
    this.FilteredItems = filteredItems; 
}); 

//any unhandled exceptions that are thown in SearchCommand will bubble up through the ThrownExceptions observable  
SearchCmmand.ThrownExceptions.Subscribe(ex=> { 
    this.IsError = true; 
    //but after this, then the WhenAnyValue no longer continues to work. 
    //how to get it back? 
}); 

//invoke the command when SearchText changes 
this.WhenAnyValue(v => v.SearchText) 
    .Throttle(TimeSpan.FromMilliseconds(500)) 
    .InvokeCommand(SearchCmmand); 

而且這個工作。當我的GetFilteredAsync引發異常時，SearchCmmand.ThrownExceptions被調用，我可以設置我的IsError屬性。

但是，當SearchCmmand.ThrownExceptions第一次發生時，this.WhenAnyValue(v => v.SearchText)停止工作。我可以看到它被丟棄。對SearchText的後續更改不會調用該命令。 （雖然命令仍然有效，如果我有一個按鈕綁定到它）

看來這是打算的行爲，但我們怎麼能得到可觀察的工作呢？我意識到我可以把它全部包裝在try/catch中，並返回一些非例外的東西，但是，我在video（約39:03）看到，在他的情況下，searchtext在拋出異常後繼續工作？ （該vid的源代碼是here）。

我也看到here東西約UserError，但現在標記爲遺產。

Answer 1

好的，我有一些工作，我雖然我會張貼它。有幾個問題我不得不處理。其中一個事實是，我在我的命令異步任務代碼（在後臺線程中觸發並因此引發異常）內部設置了我的IsError=false屬性，另一個是在ThrownExceptions冒泡後如何重新訂閱observable。還有，我發現工作方法2 /解決方法：

1. 處理中命令代碼異常，以便ThrownExceptions實際上從未被炒魷魚。
2. 如果ThrownExceptions沒有被觸發，那麼處置並重新訂閱WhenAnyValue可觀察值，以便繼續前進。 （這需要在WhenAnyValue對象中保留一個變量）。

這裏是整個視圖模型代碼似乎工作。警告：我自己是rx/rxui的新手，我不知道這是做這一切的最好方法！我正在成像，可能有更好的方法！

public class SearchViewModel1 : ReactiveObject { 

IEnumerable<DictItem> itemList; //holds the master items. used like a repo (just for demo, i'd use a separate repo or service class for real) 

ObservableAsPropertyHelper<bool> _isBusy; 
public bool IsBusy { 
    get { return _isBusy.Value; } 
} 

bool _isError; 
public bool IsError { 
    get { return _isError; } 
    set { this.RaiseAndSetIfChanged(ref _isError, value); } 
} 

//the filtered items property that we want to bind our list to 
IEnumerable<DictItem> _filteredItems; 
public IEnumerable<DictItem> FilteredItems { 
    get { return _filteredItems; } 
    set { this.RaiseAndSetIfChanged(ref _filteredItems, value); } 
} 

//the search text, this will be bound 
//and this viewmodel will respond to changes to the property. 
string _searchText; 
public string SearchText { 
    get { return _searchText; } 
    set { this.RaiseAndSetIfChanged(ref _searchText, value); } 
} 

//this is the reacive command that takes a string as a parameter, 
public ReactiveCommand<string, IEnumerable<DictItem>> SearchCmmand { get; set; } 

//a reference to our observable in case we lose it and need to resubscribe 
IDisposable whenAnySearchText; 


//convenience method to set the IsError property. can be called by a worker thread 
void SetIsErrorFromWorkerThread(bool isError) { 
    Observable.Return(isError) 
    .SubscribeOn(RxApp.MainThreadScheduler) 
    .Subscribe(b => this.IsError = b); 
} 


//constructor is where we wire it all up 
public SearchViewModel1(IEnumerable<DictItem> itemList) { 

    this.itemList = itemList; 

    FilteredItems = itemList; 

    //this observable keeps track of when SearchText is blank. 
    var searchTextHasValue = this.WhenAnyValue(x => x.SearchText) 
    .Select(x => !string.IsNullOrWhiteSpace(x)); 

    //create our command async from task. 
    //it will only actually fire if searchTextHasValue is true. 
    SearchCmmand = ReactiveCommand.CreateFromTask<string, IEnumerable<DictItem>>(async x => { 
     SetIsErrorFromWorkerThread(false); 
     //first we'll try to capture any exceptions here, so we don't lose the observable. 
     try { 
      return await GetFilteredAsync(SearchText, itemList); 
     } catch (Exception ex) { 
      SetIsErrorFromWorkerThread(true); 
      return Enumerable.Empty<DictItem>(); 
     } 
    }, 
    searchTextHasValue); 

    //searchCommand is subscribable. set the Filtered Items property synchronous here on main thread 
    SearchCmmand.Subscribe(filteredItems => { 
    FilteredItems = filteredItems; 
    }); 

    //any unhandled exceptions that are thown in SearchCommand will bubble up through the ThrownExceptions observable 
    SearchCmmand.ThrownExceptions.Subscribe(ex => { 
    //note: because we are handling exceptions in the command code, 
    //this should be a very last-case and never-happen scenario. 
    //but we seem to be able to recover by re-subscribing the observable 
    IsError = true; 
    //we have lost the subscription. so set it again? 
    //is this even a good idea? 
    whenAnySearchText.Dispose(); 
    whenAnySearchText = this.WhenAnyValue(v => v.SearchText) 
     .Throttle(TimeSpan.FromMilliseconds(500)) 
     .InvokeCommand(SearchCmmand); 
    }); 

    //the IsBusy can just be wired from the Command observable stream 
    _isBusy = SearchCmmand.IsExecuting.ToProperty(this, vm => vm.IsBusy); 

    //bind our whenAnySearchText 
    whenAnySearchText = this.WhenAnyValue(v => v.SearchText) 
    .Throttle(TimeSpan.FromMilliseconds(500)) 
    .InvokeCommand(SearchCmmand); 
} 

//the task to run the search/filter 
async Task<IEnumerable<DictItem>> GetFilteredAsync(string filterText, IEnumerable<DictItem> items) { 
    await Task.Delay(1000); 
    if (filterText.Length == 5) { 
    throw new InvalidOperationException("You cannot search 5 characters! Why? No reason, it's contrived."); 
    } 
    return items.Where(x => x.Name.IndexOf(filterText, StringComparison.OrdinalIgnoreCase) >= 0); 
} 

} 

Answer 2

你可以在此使用interactions

public enum ErrorRecoveryOption 
{ 
    Retry, 
    Abort 
} 

public static class Interactions 
{ 
    public static readonly Interaction<Exception, ErrorRecoveryOption> Errors = new Interaction<Exception, ErrorRecoveryOption>(); 
} 

public class SomeViewModel : ReactiveObject 
{ 
    public async Task SomeMethodAsync() 
    { 
     while (true) 
     { 
      Exception failure = null; 

      try 
      { 
       DoSomethingThatMightFail(); 
      } 
      catch (Exception ex) 
      { 
       failure = ex; 
      } 

      if (failure == null) 
      { 
       break; 
      } 

      // this will throw if nothing handles the interaction 
      var recovery = await Interactions.Errors.Handle(failure); 

      if (recovery == ErrorRecoveryOption.Abort) 
      { 
       break; 
      } 
     } 
    } 
} 

public class RootView 
{ 
    public RootView() 
    { 
     Interactions.Errors.RegisterHandler(
      async interaction => 
      { 
       var action = await this.DisplayAlert(
        "Error", 
        "Something bad has happened. What do you want to do?", 
        "RETRY", 
        "ABORT"); 

       interaction.SetOutput(action ? ErrorRecoveryOption.Retry : ErrorRecoveryOption.Abort); 
      }); 
    } 
} 

看： https://docs.reactiveui.net/en/user-guide/interactions/index.html