This document discusses using UniRx (Reactive Extensions for Unity) to make asynchronous network requests in a reactive and error-handling manner. Key points include: 1. Wrapping ObservableWWW requests in an ObservableClient to handle errors, timeouts, and retries in a consistent way across methods. 2. Using LINQ operators like Select, Catch, and Timeout to process the network response and handle errors in a reactive pipeline. 3. Implementing more complex retry logic by publishing and connecting an observable to retry requests automatically. 4. Combining multiple asynchronous requests using WhenAll to run them in parallel.

2. Work
http://grani.jp/
Unity
Private
http://neue.cc/
@neuecc
https://github.com/neuecc

3. LINQ to GameOject
https://github.com/neuecc/LINQ-to-GameObject-for-Unity
https://www.assetstore.unity3d.com/jp/#!/content/24256
// destroy all filtered(tag == "foobar") objects
root.Descendants()
.Where(x => x.tag == "foobar")
.Destroy();
// get FooScript under self childer objects and self
var fooScripts = root.ChildrenAndSelf().OfComponent<FooScript>();

4. History

5. https://github.com/neuecc/UniRx

6. Push Event Stream
Event Processing
Interactive/Visualize

7. CoreLibrary
Framework Adapter
Port of Rx.NET
FromCoroutine
MainThreadScheduler
ObservableTriggers
ReactiveProperty

8. 2014/04/19 - UniRx 1.0
http://www.slideshare.net/neuecc/unityrx-reactive-extensions-for-unity
2014/05/28 - UniRx 4.0

9. 2014/07/10 - UniRx 4.3
https://github.com/neuecc/UniRx/wiki/AOT-Exception-Patterns-and-Hacks
2014/07/30
http://www.slideshare.net/neuecc/reactive-programming-by-unirxfor-asynchronous-event-processing

10. 2015/01/22 - UniRx 4.4~4.6

11. 2015/03/10 - UniRx 4.7
2015/04/10 - UniRx 4.8

12. 2015/04/16
http://www.slideshare.net/neuecc/observable-everywhere-rxuni-rx
2015/05/26 - UniRx 4.8.1

13. Practices & Pitfalls

14. https://github.com/neuecc/LightNode

15. ObservableWWW + Frequent methods

16. // Wrap the ObservableWWW and aggregate network access
public class ObservableClient
{
public IObservable<WWW> GetHogeAsync(int huga)
{
return ObservableWWW.GetWWW("http://hogehoge.com/Hoge?huga=" + huga);
}
}

17. public class ObservableClient
{
public IObservable<HogeResponse> GetHogeAsync(int huga)
{
return ObservableWWW.GetWWW("http://hogehoge.com/Hoge?huga=" + huga)
.Select(www =>
{
// This is used JSON.NET for Unity(payed asset)
// LitJson or MiniJson etc, return the deserialized value
return JsonConvert.DeserializeObject<HogeResponse>(www.text);
})
}
}

18. public class ObservableClient
{
public IObservable<HogeResponse> GetHogeAsync(int huga)
{
return ObservableWWW.GetWWW("http://hogehoge.com/Hoge?huga=" + huga)
.Select(www =>
{
return JsonConvert.DeserializeObject<HogeResponse>(www.text);
})
.Catch((WWWErrorException error) =>
{
// Failed in WWW
// For example shows dialog and await user input,
// you can do even if input result is IObservable
return Observable.Empty<HogeResponse>();
});
}
}

19. public class ObservableClient
{
public IObservable<HogeResponse> GetHogeAsync(int huga)
{
return ObservableWWW.GetWWW("http://hogehoge.com/Hoge?huga=" + huga)
.Timeout(TimeSpan.FromSeconds(30)) // 30 Seconds timeout
.Select(www =>
{
return JsonConvert.DeserializeObject<HogeResponse>(www.text);
})
.Catch((WWWErrorException error) =>
{
return Observable.Empty<HogeResponse>();
});
}
}

20. public class ObservableClient
{
public IObservable<HogeResponse> GetHogeAsync(int huga)
{
return ObservableWWW.GetWWW("http://hogehoge.com/Hoge?huga=" + huga)
.Timeout(TimeSpan.FromSeconds(30))
.Select(www =>
{
return JsonConvert.DeserializeObject<HogeResponse>(www.text);
})
.Catch((TimeoutException error) =>
{
// Observable.Empty<T>? Observable.Throw? etc
return Observable.Throw<HogeResponse>(error);
})
.Catch((WWWErrorException error) =>
{
return Observable.Empty<HogeResponse>();
});
}
}

21. // complex retyable edition
public class ObservableClient
{
public IObservable<HogeResponse> GetHogeAsync(int huga)
{
//for retry
IObservable<HogeResponse> asyncRequest = null;
asyncRequest = ObservableWWW.GetWWW("http://hogehoge.com/Hoge?huga=" + huga)
.Timeout(TimeSpan.FromSeconds(30))
.Select(www => JsonConvert.DeserializeObject<HogeResponse>(www.text))
.Catch((TimeoutException error) => Observable.Throw<HogeResponse>(error))
.Catch((WWWErrorException error) =>
{
// If retry, you can return self such as "return asyncRequest"
// If retry after 3 seconds you can write
// asyncRequest.DelaySubscription(TimeSpan.FromSeconds(3))
return Observable.Empty<HogeResponse>();
});
// PublishLast, remove Cold behaivour, returns one result when called multiple
// RefCount automate subscribable for PublishLast's .Connect
return asyncRequest.PublishLast().RefCount();
}
}

22. public class ObservableClient
{
// outside in method
IObservable<T> WithErrorHandling<T>(IObservable<WWW> source)
{
IObservable<T> asyncRequest = null;
asyncRequest = source
.Timeout(TimeSpan.FromSeconds(30))
.Select(www => JsonConvert.DeserializeObject<T>(www.text))
.Catch((TimeoutException error) => Observable.Throw<T>(error))
.Catch((WWWErrorException error) => Observable.Throw<T>(error))
.Catch((Exception error) => Observable.Throw<T>(error));
return asyncRequest.PublishLast().RefCount();
}
//
public IObservable<HogeResponse> GetHogeAsync(int huga)
{
return WithErrorHandling<HogeResponse>(ObservableWWW.GetWWW("http://hogehoge.com/Hoge?huga=" + huga));
}
public IObservable<HugaResponse> GetHugaAsync(int huga)
{
return WithErrorHandling<HugaResponse>(ObservableWWW.GetWWW("http://hogehoge.com/Huga?huga=" + huga));
}
}

23. WhenAll makes easy for parallel request
var client = new ObservableClient();
Observable.WhenAll(
client.GetFooAsync(),
client.GetFooAsync(),
client.GetFooAsync())
.Subscribe(xs => { });
// Compile error detected when each return type is not same!
Observable.WhenAll(
client.GetFooAsync(),
client.GetBarAsync(),
client.GetBazAsync())
.Subscribe(xs => { });

24. Use Cast
Observable.WhenAll(
client.GetFooAsync().Cast(default(object)),
client.GetBarAsync().Cast(default(object)),
client.GetBazAsync().Cast(default(object)))
.Subscribe(xs =>
{
var foo = xs[0] as FooResponse;
var bar = xs[1] as BarResponse;
var baz = xs[2] as BazResponse;
});

25. WhenAll in Infinite Sequence?

26. Single(1) for "-Async" suffix

28. Completed callback as IObservable<T>
// for example
public static class DoTweenExtensions
{
public static IObservable<Sequence> CompletedAsObservable(this Sequence sequence)
{
var subject = new AsyncSubject<Sequence>();
sequence.AppendCallback(() =>
{
subject.OnNext(sequence);
subject.OnCompleted();
});
return subject.AsObservable();
}
}

29. Represents Value＋Event
[Serializable]
public class Character : MonoBehaviour
{
public Action<int> HpChanged;
[SerializeField]
int hp = 0;
public int Hp
{
get
{
return hp;
}
set
{
hp = value;
var h = HpChanged;
if (h != null)
{
h.Invoke(hp);
}
}
[Serializable]
public class Character : MonoBehaviour
{
public IntReactiveProperty Hp;
}
+ notify when their value is changed even
when it is changed in the inspector

30. Unity + Rx's UI Pattern
Passive View
Presenter
(Supervising Controller)
Model
updates view
state-change
events
user events
update model
UIControl.XxxAsObservable
UnityEvent.AsObservable
ObservableEventTrigger
Subscribe
ToReactiveProperty
ReactiveProperty
Subscribe
SubscribeToText
SubscribeToInteractable

31. public class CalculatorPresenter : MonoBehaviour
{
public InputField Left;
public InputField Right;
public Text Result;
void Start()
{
var left = this.Left
.OnValueChangeAsObservable()
.Select(x => int.Parse(x));
var right = this.Right
.OnValueChangeAsObservable()
.Select(x => int.Parse(x));
left.CombineLatest(right, (l, r) => l + r)
.SubscribeToText(this.Result);
}
}

32. Issue of P and serializable value
// Child
[Serializable]
public class ChildPresenter : MonoBehaviour
{
public IntReactiveProperty Hp; // serializable
public ReadOnlyReactiveProperty<bool> IsDead
{ get; private set; }
void Start()
{
IsDead = Hp.Select(x => x <= 0)
.ToReadOnlyReactiveProperty();
}
}
// Parent
[Serializable]
public class ParentPresenter : MonoBehaviour
{
public ChildPresenter ChildPresenter;
public Text IsDeadDisplay;
void Start()
{
// Can you touch IsDead?
ChildPresenter.IsDead
.SubscribeToText(IsDeadDisplay);
}
}

33. Issue of P and serializable value
// Child
[Serializable]
public class ChildPresenter : MonoBehaviour
{
public IntReactiveProperty Hp; // serializable
public ReadOnlyReactiveProperty<bool> IsDead
{ get; private set; }
void Start()
{
IsDead = Hp.Select(x => x <= 0)
.ToReadOnlyReactiveProperty();
}
}
// Parent
[Serializable]
public class ParentPresenter : MonoBehaviour
{
public ChildPresenter ChildPresenter;
public Text IsDeadDisplay;
void Start()
{
// Can you touch IsDead?
ChildPresenter.IsDead
.SubscribeToText(IsDeadDisplay);
}
}

34. MonoBehaviour's order is uncontrollable

35. // Parent
public class ParentPresenter : PresenterBase
{
public ChildPresenter ChildPresenter;
public Text IsDeadDisplay;
protected override IPresenter[] Children
{
get { return new IPresenter[] { ChildPresenter }; } // Children
}
protected override void BeforeInitialize()
{
ChildPresenter.PropagateArgument(1000); // Pass initial argument to child
}
protected override void Initialize()
{
// After initialzied
ChildPresenter.IsDead.SubscribeToText(IsDeadDisplay);
}

36. // Child
[Serializable]
public class ChildPresenter : PresenterBase<int>
{
public IntReactiveProperty Hp; // serializable
public ReadOnlyReactiveProperty<bool> IsDead { get; set; }
protected override IPresenter[] Children
{
get { return EmptyChildren; }
}
protected override void BeforeInitialize(int argument) { }
// argument from parent
protected override void Initialize(int argument)
{
Hp.Value = argument;
IsDead = Hp.Select(x => x <= 0).ToReadOnlyReactiveProperty();
}
}

37. https://github.com/neuecc/UniRx#presenterbase

38. Doesn't fire(I forget Subscribe)
// Return type is IObservable<Unit>
// Nothing happens...
new ObservableClient().SetNewData(100);

39. Doesn't fire(I forget Subscribe)

40. // button click in uGUI to asynchronous operation
button.OnClickAsObservable()
.SelectMany(_ => new ObservableClient().FooBarAsync(100))
.Subscribe(_ =>
{
Debug.Log("done");
});

41. button.OnClickAsObservable()
.SelectMany(_ =>
{
throw new Exception("something happen");
return new ObservableClient(). FooBarAsync(100);
})
.Subscribe(_ =>
{
Debug.Log("done");
});

42. button.OnClickAsObservable()
.SelectMany(_ =>
{
throw new Exception("something happen");
return new ObservableClient(). FooBarAsync(100);
})
.OnErrorRetry()
.Subscribe(_ =>
{
Debug.Log("done");
});

43. button.OnClickAsObservable().Subscribe(_ =>
{
// Subscribe in Subscribe...!
new ObservableClient(). FooBarAsync(100).Subscribe(__ =>
{
Debug.Log("done");
});
});

44. Can't avoid error and Retry is dangerous
button.OnClickAsObservable().Subscribe(_ =>
{
// Subscribe in Subscribe...!
new ObservableClient().NanikaHidoukiAsync(100).Subscribe(__ =>
{
Debug.Log("done");
});
});

45. Conclusion

46. We use UniRx
Real World UniRx