public void OnNext(TSource value)
{
var key = default(TKey);
try
{
key = _parent._keySelector(value);
}
catch (Exception exception)
{
Error(exception);
return;
}
var fireNewMapEntry = false;
var writer = default(ISubject <TElement>);
try
{
writer = _map.GetOrAdd(key, () => new Subject <TElement>(), out fireNewMapEntry);
}
catch (Exception exception)
{
Error(exception);
return;
}
if (fireNewMapEntry)
{
var group = new GroupedObservable <TKey, TElement>(key, writer, _parent._refCountDisposable);
var duration = default(IObservable <TDuration>);
var durationGroup = new GroupedObservable <TKey, TElement>(key, writer);
try
{
duration = _parent._durationSelector(durationGroup);
}
catch (Exception exception)
{
Error(exception);
return;
}
lock (base._observer)
base._observer.OnNext(group);
var md = new SingleAssignmentDisposable();
_parent._groupDisposable.Add(md);
md.Disposable = duration.SubscribeSafe(new δ(this, key, writer, md));
}
var element = default(TElement);
try
{
element = _parent._elementSelector(value);
}
catch (Exception exception)
{
Error(exception);
return;
}
writer.OnNext(element);
}
public void OnNext(TSource value)
{
var key = default(TKey);
try
{
key = _parent._keySelector(value);
}
catch (Exception exception)
{
Error(exception);
return;
}
var fireNewMapEntry = false;
var writer = default(ISubject <TElement>);
try
{
//
// Note: The box instruction in the IL will be erased by the JIT in case T is
// a value type. In fact, the whole if block will go away and we'll end
// up with nothing but the GetOrAdd call below.
//
// See GroupBy for more information and confirmation of this fact using
// the SOS debugger extension.
//
if (key == null)
{
lock (_nullGate)
{
if (_null == null)
{
_null = new Subject <TElement>();
fireNewMapEntry = true;
}
writer = _null;
}
}
else
{
writer = _map.GetOrAdd(key, () => new Subject <TElement>(), out fireNewMapEntry);
}
}
catch (Exception exception)
{
Error(exception);
return;
}
if (fireNewMapEntry)
{
var group = new GroupedObservable <TKey, TElement>(key, writer, _parent._refCountDisposable);
var duration = default(IObservable <TDuration>);
var durationGroup = new GroupedObservable <TKey, TElement>(key, writer);
try
{
duration = _parent._durationSelector(durationGroup);
}
catch (Exception exception)
{
Error(exception);
return;
}
lock (base._observer)
base._observer.OnNext(group);
var md = new SingleAssignmentDisposable();
_parent._groupDisposable.Add(md);
md.Disposable = duration.SubscribeSafe(new δ(this, key, writer, md));
}
var element = default(TElement);
try
{
element = _parent._elementSelector(value);
}
catch (Exception exception)
{
Error(exception);
return;
}
//
// ISSUE: Rx v1.x shipped without proper handling of the case where the duration
// sequence fires concurrently with the OnNext code path here. In such a
// case, the subject can be completed before we get a chance to send out
// a new element. However, a resurrected group for the same key won't get
// to see the element either. To guard against this case, we'd have to
// check whether the OnNext call below lost the race, and resurrect a new
// group if needed. Unfortunately, this complicates matters when the
// duration selector triggers synchronously (e.g. Return or Empty), which
// causes the group to terminate immediately. We should not get stuck in
// this case, repeatedly trying to resurrect a group that always ends
// before we can send the element into it. Also, users may expect this
// base case to mean no elements will ever be produced, so sending the
// element into the group before starting the duration sequence may not
// be a good idea either. For the time being, we'll leave this as-is and
// revisit the behavior for vNext. Nonetheless, we'll add synchronization
// to ensure no concurrent calls to the subject are made.
//
lock (writer)
writer.OnNext(element);
}
