public async Task <IHttpActionResult> PutEventOwner(int id, EventOwner eventOwner)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != eventOwner.EventOwnerId)
{
return(BadRequest());
}
db.Entry(eventOwner).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EventOwnerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void assertGroup()
{
Event e = new Event()
{
Title = "Test title",
Description = "Test description",
Start = new DateTime(2018, 4, 6, 9, 0, 0),
End = new DateTime(2018, 4, 6, 9, 0, 0),
};
User u1 = new User()
{
FirstName = "Elliot",
LastName = "Alderson",
Type = backend.Types.Type.Student,
Role = Role.Basic,
};
User u2 = new User()
{
FirstName = "Darlene",
LastName = "Alderson",
Type = backend.Types.Type.Student,
Role = Role.Basic,
};
EventOwner eo1 = new EventOwner()
{
Event = e,
People = u1,
};
EventAttendee ea1 = new EventAttendee()
{
Event = e,
People = u1,
};
EventAttendee ea2 = new EventAttendee()
{
Event = e,
People = u2,
};
Group g = new Group()
{
Name = "Linux Hackers",
EventsOwn = new List <EventOwner> {
eo1
},
EventsAttend = new List <EventAttendee> {
ea1, ea2
},
};
Assert.Equal("Linux Hackers", g.Name);
Assert.Equal(1, g.EventsOwn.Count);
Assert.Equal(2, g.EventsAttend.Count);
}
public void SubscribeTwice(EventOwner eventOwner)
{
EventHandler h = null;
h += OnMyEvent;
h += OnMyEvent;
eventOwner.MyEvent += h;
}
public void SubscribeStaticEventTwice(EventOwner eventOwner)
{
EventHandler h = null;
h += OnMyEvent;
h += OnMyEvent;
EventOwner.MyStaticEvent += h;
}
public void SubscribePrivate(EventOwner e, bool stat)
{
if (stat)
{
EventOwner.MyStaticEvent += PrivateOnEvent;
}
else
{
e.MyEvent += PrivateOnEvent;
}
}
public void SubscribeInternal(EventOwner e, bool stat)
{
if (stat)
{
EventOwner.MyStaticEvent += InternalOnEvent;
}
else
{
e.MyEvent += InternalOnEvent;
}
}
public void SibscribeStatic(EventOwner e, bool stat)
{
if (stat)
{
EventOwner.MyStaticEvent += StaticOnEvent;
}
else
{
e.MyEvent += StaticOnEvent;
}
}
public async Task <IHttpActionResult> GetEventOwner(int id)
{
EventOwner eventOwner = await db.EventOwners.FindAsync(id);
if (eventOwner == null)
{
return(NotFound());
}
return(Ok(eventOwner));
}
public void SibscribeAnonymousStatic(EventOwner e, bool stat)
{
if (stat)
{
EventOwner.MyStaticEvent += (s, args) => _StaticOnEvent = args != null;
}
else
{
e.MyEvent += (s, args) => _StaticOnEvent = args != null;
}
}
public async Task <IHttpActionResult> PostEventOwner(EventOwner eventOwner)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.EventOwners.Add(eventOwner);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = eventOwner.EventOwnerId }, eventOwner));
}
WeakReference MemoryCoreAlloc(Action <Subscriber2, EventOwner> subscribe, Action <Subscriber2> check, Action <EventOwner> raise)
{
EventOwner e = new EventOwner();
Subscriber2 s = new Subscriber2();
subscribe(s, e);
Collect();
raise(e);
check(s);
s.Clear();
return(new WeakReference(s));
}
public void Order()
{
var e = new EventOwner();
List <string> args = new List <string>();
e.MyEvent2 += (s, x) => args.Add("first");
e.MyEvent2 += (s, x) => args.Add("second");
e.RaiseMyEvent2("test");
Assert.AreEqual("first", args[0]);
Assert.AreEqual("second", args[1]);
}
public void source_is_only_subscribed_to_once_for_multiple_connections()
{
EventOwner owner = new EventOwner();
var source = owner.GetObservableEvent();
var obs = source.Prune();
obs.Connect();
obs.Connect();
Assert.AreEqual(1, owner.SubscriptionCount);
}
public async Task <IHttpActionResult> DeleteEventOwner(int id)
{
EventOwner eventOwner = await db.EventOwners.FindAsync(id);
if (eventOwner == null)
{
return(NotFound());
}
db.EventOwners.Remove(eventOwner);
await db.SaveChangesAsync();
return(Ok(eventOwner));
}
WeakReference SubscribeUnsubsribeCoreAlloc(EventOwner e, object sender, PropertyChangedEventArgs args, Action raise,
Action <EventOwner, EventArgs> raiseMyEvent1, Action <EventOwner, object, EventArgs> raiseMyEvent2,
Action <Subscriber, EventOwner> subscribe, Action <Subscriber, EventOwner> subscribeTwice, Action <Subscriber, EventOwner> unsubscribe)
{
var s = new Subscriber();
subscribe(s, e);
raise();
Assert.AreEqual(sender, s.Sender);
Assert.AreEqual(args, s.E);
Assert.AreEqual(1, s.Count);
raise();
Assert.AreEqual(sender, s.Sender);
Assert.AreEqual(args, s.E);
Assert.AreEqual(2, s.Count);
s.Clear();
subscribe(s, e);
raise();
Assert.AreEqual(sender, s.Sender);
Assert.AreEqual(args, s.E);
Assert.AreEqual(2, s.Count);
s.Clear();
unsubscribe(s, e);
raise();
Assert.AreEqual(sender, s.Sender);
Assert.AreEqual(args, s.E);
Assert.AreEqual(1, s.Count);
s.Clear();
unsubscribe(s, e);
raise();
Assert.AreEqual(null, s.Sender);
Assert.AreEqual(null, s.E);
Assert.AreEqual(0, s.Count);
s.Clear();
subscribeTwice(s, e);
raise();
Assert.AreEqual(sender, s.Sender);
Assert.AreEqual(args, s.E);
Assert.AreEqual(2, s.Count);
unsubscribe(s, e);
unsubscribe(s, e);
unsubscribe(s, e);
subscribe(s, e);
return(new WeakReference(s));
}
public void source_is_not_subscribed_to_until_connect()
{
EventOwner owner = new EventOwner();
var source = owner.GetObservableEvent();
var obs = source.Prune();
Assert.IsFalse(owner.HasSubscriptions);
obs.Connect();
Assert.IsTrue(owner.HasSubscriptions);
}
/**
* 注册事件监听
*/
public void RegisterEvent(string regKey, EventListener listener)
{
EventOwner eventOwner;
if (_eventList.TryGetValue(regKey, out eventOwner))
{
eventOwner.Event += listener;
}
else
{
eventOwner = new EventOwner();
eventOwner.Event += listener;
_eventList.Add(regKey, eventOwner);
}
}
public void source_is_unscribed_from_on_disconnect()
{
EventOwner owner = new EventOwner();
var source = owner.GetObservableEvent();
var obs = source.Prune();
var connection = obs.Connect();
Assert.IsTrue(owner.HasSubscriptions);
connection.Dispose();
Assert.IsFalse(owner.HasSubscriptions);
}
void MemoryCore(Action <Subscriber2, EventOwner> subscribe, Action <Subscriber2> check, Action <EventOwner> raise)
{
var e = new EventOwner();
var s = new Subscriber2();
subscribe(s, e);
Collect();
raise(e);
check(s);
s.Clear();
WeakReference sRef = new WeakReference(s);
s = null;
Collect();
Assert.AreEqual(false, sRef.IsAlive);
}
public void all_sources_are_unsubscribed_when_complete_is_received()
{
var sourceA = new EventOwner();
var sourceC = new EventOwner();
var obs = Observable.Amb(
sourceA.GetObservableEvent(),
Observable.Empty <IEvent <EventArgs> >(),
sourceC.GetObservableEvent()
);
var stats = new StatsObserver <IEvent <EventArgs> >();
obs.Subscribe(stats);
Assert.IsFalse(sourceA.HasSubscriptions);
Assert.IsFalse(sourceC.HasSubscriptions);
}
public void catch_with_observer_subscribes_to_first_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
StatsObserver <IEvent <EventArgs> > observer = new StatsObserver <IEvent <EventArgs> >();
EventOwner owner = new EventOwner();
Observable.FromEvent <EventArgs>(x => owner.Event += x, x => owner.Event -= x)
.Catch(Observable.Empty <IEvent <EventArgs> >(), scheduler)
.Subscribe(observer);
Assert.IsFalse(owner.HasSubscriptions);
scheduler.RunAll();
Assert.IsTrue(owner.HasSubscriptions);
}
public void complete_does_not_equate_to_value()
{
var eventOwnerA = new EventOwner();
var observableA = Observable.FromEvent <EventArgs>(x => eventOwnerA.Event += x, x => eventOwnerA.Event -= x);
var stats = new StatsObserver <IEvent <EventArgs> >();
observableA
.SkipUntil(Observable.Empty <int>())
.Subscribe(stats);
eventOwnerA.Fire();
eventOwnerA.Fire();
eventOwnerA.Fire();
Assert.AreEqual(0, stats.NextCount);
Assert.IsFalse(stats.CompletedCalled);
}
public void all_sources_are_unsubscribed_when_error_is_received()
{
var sourceA = new EventOwner();
var sourceB = new EventOwner();
var obs = Observable.Amb(
sourceA.GetObservableEvent(),
sourceB.GetObservableEvent(),
Observable.Throw <IEvent <EventArgs> >(new Exception())
);
var stats = new StatsObserver <IEvent <EventArgs> >();
obs.Subscribe(stats);
Assert.IsFalse(sourceA.HasSubscriptions);
Assert.IsFalse(sourceB.HasSubscriptions);
Assert.IsTrue(stats.ErrorCalled);
}
public void returns_values_after_other_emits_value()
{
var eventOwnerA = new EventOwner();
var eventOwnerB = new EventOwner();
var observableA = Observable.FromEvent <EventArgs>(x => eventOwnerA.Event += x, x => eventOwnerA.Event -= x);
var observableB = Observable.FromEvent <EventArgs>(x => eventOwnerB.Event += x, x => eventOwnerB.Event -= x);
var stats = new StatsObserver <IEvent <EventArgs> >();
observableA.SkipUntil(observableA)
.Subscribe(stats);
eventOwnerA.Fire();
eventOwnerA.Fire();
eventOwnerA.Fire();
eventOwnerB.Fire();
eventOwnerA.Fire();
Assert.AreEqual(3, stats.NextCount);
}
public void T846808()
{
var eventOwner = new EventOwner();
int c1 = 0;
int c2 = 0;
EventHandler h1 = null;
EventHandler h2 = null;
h1 = (s, e) => { c1++; eventOwner.MyEvent -= h1; };
h2 = (s, e) => { c2++; };
eventOwner.MyEvent += h1;
eventOwner.MyEvent += h2;
eventOwner.RaiseMyEvent(EventArgs.Empty);
Assert.AreEqual(1, c1);
Assert.AreEqual(1, c2);
eventOwner.RaiseMyEvent(EventArgs.Empty);
Assert.AreEqual(1, c1);
Assert.AreEqual(2, c2);
}
public void other_sources_are_unsubscribed_when_value_is_received()
{
var sourceA = new EventOwner();
var sourceB = new EventOwner();
var sourceC = new EventOwner();
var obs = Observable.Amb(
sourceA.GetObservableEvent(),
sourceB.GetObservableEvent(),
sourceC.GetObservableEvent()
);
var stats = new StatsObserver <IEvent <EventArgs> >();
obs.Subscribe(stats);
sourceB.Fire();
Assert.IsFalse(sourceA.HasSubscriptions);
Assert.IsTrue(sourceB.HasSubscriptions);
Assert.IsFalse(sourceC.HasSubscriptions);
}
public void RemoveEventOwner(EventOwner eventOwner)
{
if (eventOwner.IsUsingAwakeEarly())
{
eventOwnersAwakeEarly.Remove(eventOwner);
}
if (eventOwner.IsUsingAwakeDefault())
{
eventOwnersAwakeDefault.Remove(eventOwner);
}
if (eventOwner.IsUsingAwakeLate())
{
eventOwnersAwakeLate.Remove(eventOwner);
}
if (eventOwner.IsUsingStartEarly())
{
eventOwnersStartEarly.Remove(eventOwner);
}
if (eventOwner.IsUsingStartDefault())
{
eventOwnersStartDefault.Remove(eventOwner);
}
if (eventOwner.IsUsingStartLate())
{
eventOwnersStartLate.Remove(eventOwner);
}
if (eventOwner.IsUsingUpdateEarly())
{
eventOwnersUpdateEarly.Remove(eventOwner);
}
if (eventOwner.IsUsingUpdateDefault())
{
eventOwnersUpdateDefault.Remove(eventOwner);
}
if (eventOwner.IsUsingUpdateLate())
{
eventOwnersUpdateLate.Remove(eventOwner);
}
}
public void catch_with_observer_subscribes_to_next_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
StatsObserver <IEvent <EventArgs> > observer = new StatsObserver <IEvent <EventArgs> >();
EventOwner owner = new EventOwner();
var eventObs = Observable.FromEvent <EventArgs>(x => owner.Event += x, x => owner.Event -= x);
Observable.Throw <IEvent <EventArgs> >(new ApplicationException())
.Catch(eventObs, scheduler)
.Subscribe(observer);
scheduler.RunNext();
Assert.IsFalse(owner.HasSubscriptions);
scheduler.RunNext();
Assert.IsTrue(owner.HasSubscriptions);
}
public override bool registerEvent(string ID, Type eventType)
{
if (eventType != null && !eventType.IsSubclassOf(typeof(IEvent)))
{
Debug.LogError(string.Format("EventDispatcher.registerEvent Failed, {0} is not a subclass of IEvent", eventType));
return(false);
}
EventOwner ew;
if (registers_.TryGetValue(ID, out ew))
{
Debug.LogError(string.Format("EventDispatcher.registerEvent Failed,{0} is allways registered", ID));
return(false);
}
ew = new EventOwner();
ew.evtID = ID;
ew.evtType = eventType;
registers_.Add(ID, ew);
// Debug.LogError(string.Format("EventDispatcher.registerEvent Successful,ID={0},type={1}", ID, eventType));
return(true);
}
void SubscribeUnsubsribeCore(bool passSender, Action <EventOwner, EventArgs> raiseMyEvent1, Action <EventOwner, object, EventArgs> raiseMyEvent2,
Action <Subscriber, EventOwner> subscribe, Action <Subscriber, EventOwner> subscribeTwice, Action <Subscriber, EventOwner> unsubscribe)
{
var e = new EventOwner();
var sender = passSender ? new object() : e;
var args = new PropertyChangedEventArgs("Test");
Action raise = () => {
if (passSender)
{
raiseMyEvent2(e, sender, args);
}
else
{
raiseMyEvent1(e, args);
}
};
WeakReference sRef = SubscribeUnsubsribeCoreAlloc(e, sender, args, raise, raiseMyEvent1, raiseMyEvent2, subscribe, subscribeTwice, unsubscribe);
MemoryLeaksHelper.CollectOptional(sRef);
MemoryLeaksHelper.EnsureCollected(sRef);
raise();
}
public void catch_with_observer_subscribes_to_first_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
StatsObserver<IEvent<EventArgs>> observer = new StatsObserver<IEvent<EventArgs>>();
EventOwner owner = new EventOwner();
Observable.FromEvent<EventArgs>(x => owner.Event += x, x => owner.Event -= x)
.Catch(Observable.Empty<IEvent<EventArgs>>(), scheduler)
.Subscribe(observer);
Assert.IsFalse(owner.HasSubscriptions);
scheduler.RunAll();
Assert.IsTrue(owner.HasSubscriptions);
}
public void Setup()
{
ev = new EventOwner();
obs = Observable.FromEvent<EventArgs>(e => ev.Event += e, e => ev.Event -= e);
}
public void catch_with_observer_subscribes_to_next_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
StatsObserver<IEvent<EventArgs>> observer = new StatsObserver<IEvent<EventArgs>>();
EventOwner owner = new EventOwner();
var eventObs = Observable.FromEvent<EventArgs>(x => owner.Event += x, x => owner.Event -= x);
Observable.Throw<IEvent<EventArgs>>(new ApplicationException())
.Catch(eventObs, scheduler)
.Subscribe(observer);
scheduler.RunNext();
Assert.IsFalse(owner.HasSubscriptions);
scheduler.RunNext();
Assert.IsTrue(owner.HasSubscriptions);
}
