public TasksController(
EventsDispatcher<GuidEvent> guidEventsDispather,
EventsDispatcher<ServerEvent> serverEventsDispather)
{
_guidEventsBuilder = guidEventsDispather.Events;
_serverEventsBuilder = serverEventsDispather.Events;
}
void LockSignature()
{
if (_eb == null)
{
_eb = _owner.TypeBuilder.DefineEvent(ImplementedInterface == null ? Name : ImplementedInterface.FullName + "." + Name, EventAttributes.None, _type);
_owner.RegisterForCompletion(this);
}
}
public void BuildEvent(EventBuilder builder)
{
builder.Build(
this.eventId,
this.eventTitle,
this.eventStart,
this.eventEnd,
this.isOwner,
this.isDelegate,
this.isAuthoriser,
this.isPrivateEvent,
this.eventType);
}
public void 事件_T4_通过字符串生成()
{
EventBuilder builder = EventBuilder.FromCode(@"[Display(Name = ""a"")]
[Key]
public event T t1 = AAA;");
var result = builder.ToFormatCode();
#if Log
_tempOutput.WriteLine(result);
#endif
Assert.Equal(@"[Display(Name = ""a"")]
[Key]
public event T t1 = AAA;", result);
}
public EventEmitter(AbstractTypeEmitter typeEmitter, string name, EventAttributes attributes, Type type)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
this.typeEmitter = typeEmitter;
this.type = type;
eventBuilder = typeEmitter.TypeBuilder.DefineEvent(name, attributes, type);
}
protected override void Context()
{
base.Context();
var e1 = new EventBuilder().WithName("Event");
e1.OneTime = true;
var e2 = new EventBuilder().WithName("Event");
e2.OneTime = false;
_object1 = e1;
_object2 = e2;
}
private static FieldBuilder CreatePropertyChangedEvent(TypeBuilder typeBuilder)
{
// public event PropertyChangedEventHandler PropertyChanged;
FieldBuilder eventField =
typeBuilder.DefineField("PropertyChanged", typeof(PropertyChangedEventHandler), FieldAttributes.Private);
EventBuilder eventBuilder = typeBuilder.DefineEvent("PropertyChanged", EventAttributes.None,
typeof(PropertyChangedEventHandler));
eventBuilder.SetAddOnMethod(CreateAddRemoveMethod(typeBuilder, eventField, true));
eventBuilder.SetRemoveOnMethod(CreateAddRemoveMethod(typeBuilder, eventField, false));
return(eventField);
}
public string Serialize(Contract contract, string template, List <Contract> contracts)
{
var nodes = NodeHelper.GetEvents(contract).ToList();
if (!nodes.Any())
{
return(template.Replace("{{Events}}", string.Empty));
}
var builder = new EventBuilder(nodes);
template = template.Replace("{{Events}}", builder.Build());
return(template);
}
public async Task TestMouseMoveTo()
{
var sim = new EventBuilder();
sim
.MoveTo(0, 0)
.Wait(1000)
.MoveTo(65535, 65535)
.Wait(1000)
.MoveTo(65535 / 2, 65535 / 2)
;
await sim.Invoke();
}
public void 事件_T2_初始化值()
{
EventBuilder builder = CodeSyntax.CreateEvent("t1")
.WithType("T")
.WithAccess(MemberAccess.Public)
.WithName("t1")
.WithInit("AAA");
var result = builder.ToFormatCode();
#if Log
_tempOutput.WriteLine(result);
#endif
Assert.Equal("public event T t1 = AAA;", result);
}
public static void Invoke_Event_Add_And_Remove_And_Raise_Invokes_Correct_Methods()
{
// C# cannot emit raise_Xxx method for the event, so we must use System.Reflection.Emit to generate such event.
AssemblyBuilder ab = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("EventBuilder"), AssemblyBuilderAccess.Run);
ModuleBuilder modb = ab.DefineDynamicModule("mod");
TypeBuilder tb = modb.DefineType("TestType_IEventService", TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract);
EventBuilder eb = tb.DefineEvent("AddRemoveRaise", EventAttributes.None, typeof(EventHandler));
eb.SetAddOnMethod(tb.DefineMethod("add_AddRemoveRaise", MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual, typeof(void), new Type[] { typeof(EventHandler) }));
eb.SetRemoveOnMethod(tb.DefineMethod("remove_AddRemoveRaise", MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual, typeof(void), new Type[] { typeof(EventHandler) }));
eb.SetRaiseMethod(tb.DefineMethod("raise_AddRemoveRaise", MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual, typeof(void), new Type[] { typeof(EventArgs) }));
TypeInfo ieventServiceTypeInfo = tb.CreateTypeInfo();
List <MethodInfo> invokedMethods = new List <MethodInfo>();
object proxy =
typeof(DispatchProxy)
.GetRuntimeMethod("Create", Type.EmptyTypes).MakeGenericMethod(ieventServiceTypeInfo.AsType(), typeof(TestDispatchProxy))
.Invoke(null, null);
((TestDispatchProxy)proxy).CallOnInvoke = (method, args) =>
{
invokedMethods.Add(method);
return(null);
};
EventHandler handler = new EventHandler((sender, e) => { });
proxy.GetType().GetRuntimeMethods().Single(m => m.Name == "add_AddRemoveRaise").Invoke(proxy, new object[] { handler });
proxy.GetType().GetRuntimeMethods().Single(m => m.Name == "raise_AddRemoveRaise").Invoke(proxy, new object[] { EventArgs.Empty });
proxy.GetType().GetRuntimeMethods().Single(m => m.Name == "remove_AddRemoveRaise").Invoke(proxy, new object[] { handler });
Assert.True(invokedMethods.Count == 3, String.Format("Expected 3 method invocations but received {0}", invokedMethods.Count));
EventInfo eventInfo = ieventServiceTypeInfo.GetDeclaredEvent("AddRemoveRaise");
Assert.NotNull(eventInfo);
MethodInfo expectedMethod = eventInfo.AddMethod;
Assert.True(invokedMethods[0] != null && expectedMethod == invokedMethods[0], String.Format("First invoke should have been {0} but actual was {1}",
expectedMethod.Name, invokedMethods[0]));
expectedMethod = eventInfo.RaiseMethod;
Assert.True(invokedMethods[1] != null && expectedMethod == invokedMethods[1], String.Format("Second invoke should have been {0} but actual was {1}",
expectedMethod.Name, invokedMethods[1]));
expectedMethod = eventInfo.RemoveMethod;
Assert.True(invokedMethods[2] != null && expectedMethod == invokedMethods[2], String.Format("Third invoke should have been {0} but actual was {1}",
expectedMethod.Name, invokedMethods[1]));
}
public EventBuilder Build()
{
var contextUri = state.ConnectState.ContextUri;
var @event = new EventBuilder(EventType.NEW_SESSION_ID);
@event.Append(sessionId);
@event.Append(contextUri);
@event.Append(contextUri);
@event.Append(TimeProvider.CurrentTimeMillis().ToString());
@event.Append("").Append(state.GetContextSize().ToString());
@event.Append(state.ConnectState.ContextUrl);
return(@event);
}
private void AddEventDefinition(EventInfo @event, MethodBuilder addMethod, MethodBuilder removeMethod)
{
EventBuilder newEvent = this.typeBuilder.DefineEvent(@event.Name, @event.Attributes, @event.EventHandlerType);
if (addMethod != null)
{
newEvent.SetAddOnMethod(addMethod);
}
if (removeMethod != null)
{
newEvent.SetRemoveOnMethod(removeMethod);
}
}
public void TheEventStartDateIsNotUpdatedWithAnLaterAttendanceIsAdded()
{
// Arrange
var attendance = new AttendanceBuilder().Arrival(DateTime.Now).Build();
var laterAttendance = new AttendanceBuilder().Arrival(DateTime.Now.AddHours(Randomiser.Int(60))).Build();
var happening = new EventBuilder().AddAttendance(attendance).Build();
// Act
happening.AddAttendance(laterAttendance);
// Assert
Assert.AreEqual(attendance.Arrival, happening.Start);
}
public void TheEventEndDateIsUpdatedWithALaterAttendanceIsAdded()
{
// Arrange
var user = new UserBuilder().Build();
var attendance = new AttendanceBuilder().User(user).Arrival(DateTime.Now).Build();
var happening = new EventBuilder().AddAttendance(attendance).Build();
var earlierAttendance = new AttendanceBuilder().User(user).Arrival(DateTime.Now.AddHours(-Randomiser.Int(60))).Build();
// Act
happening.AddAttendance(earlierAttendance);
// Assert
Assert.AreEqual(earlierAttendance.Departure, happening.End);
}
private void SendWebSocketNotification(string userId, IEventMessage message)
{
try
{
this._gameManager.WebSocketServices.SendTo(
GameManager.UserWsPath,
EventBuilder.Build(message).Serialize(),
this._gameManager.GetUser(userId).UserWebSocketId
);
}
catch
{
// ignored
}
}
public async Task InitializeAsync()
{
var(@event, _) = EventBuilder.CreateEvent("Cool Event").Build();
Event = @event;
using (var session = _factory.SessionFactory.CreateCommandSession())
{
await session.ExecuteAsync(new InsertEventCommand(Event));
session.Commit();
}
Response = await _factory.HttpClient
.GetAsync($"/api/events/byevent/{Event.EventId}");
}
public void TestAddOtherMethodWithStaticMethod()
{
byte[] bytes = new byte[MethodBodyLength];
TestLibrary.Generator.GetBytes(bytes);
EventBuilder ev = TypeBuilder.DefineEvent("Event_PosTest3", EventAttributes.None, typeof(TestEventHandler));
MethodBuilder method = TypeBuilder.DefineMethod("Method_PosTest3", MethodAttributes.Static);
ILGenerator ilgen = method.GetILGenerator();
ilgen.Emit(OpCodes.Ret);
ev.AddOtherMethod(method);
// add this method again
ev.AddOtherMethod(method);
}
public void TestThrowsExceptionOnCreateTypeCalled()
{
try
{
EventBuilder ev = TypeBuilder.DefineEvent("Event_NegTest2", EventAttributes.None, typeof(TestEventHandler));
MethodBuilder method = TypeBuilder.DefineMethod("Method_NegTest2", MethodAttributes.Abstract | MethodAttributes.Virtual);
TypeBuilder.CreateTypeInfo().AsType();
Assert.Throws <InvalidOperationException>(() => { ev.SetRemoveOnMethod(method); });
}
finally
{
_typeBuilder = null;
}
}
/// <summary>
/// Adds the property and its accessor methods to the type builder.
/// </summary>
internal void AddToTypeBuilder()
{
Debug.Assert(IsFrozen);
if (mEventBuilder == null)
{
mAddAccessorMethod.AddToTypeBuilder();
mRemoveAccessorMethod.AddToTypeBuilder();
mRaiserMethod.AddToTypeBuilder();
mEventBuilder = Engine.TypeBuilder.DefineEvent(mName, EventAttributes.None, mType);
mEventBuilder.SetAddOnMethod(mAddAccessorMethod.MethodBuilder);
mEventBuilder.SetRemoveOnMethod(mRemoveAccessorMethod.MethodBuilder);
}
}
protected EventBuilder CreateEvent(string level, string name)
{
var eventMsg = new VentMessage
{
Name = name,
MessageType = MessageType.Event,
Timestamp = DateTime.Now
};
var builder = new EventBuilder(_logger, eventMsg);
builder.Level(level);
return(builder);
}
/// <summary>
/// 添加属性集合
/// </summary>
/// <param name="builder">事件生成器</param>
/// <param name="content">日志转换器</param>
private void AddProperties(EventBuilder builder, ILogConvert content)
{
if (content == null)
{
return;
}
foreach (var parameter in content.To().OrderBy(t => t.SortId))
{
if (string.IsNullOrWhiteSpace(parameter.Value.SafeString()))
{
continue;
}
builder.SetProperty($"{GetLine()}. {parameter.Text}", parameter.Value);
}
}
/// <summary>
/// 添加扩展属性集合
/// </summary>
/// <param name="builder">事件生成器</param>
/// <param name="content">日志转换器</param>
private void AddExtraProperties(EventBuilder builder, ILogContent content)
{
if (content == null)
{
return;
}
foreach (var parameter in content.ExtraProperties)
{
if (string.IsNullOrWhiteSpace(parameter.Value.SafeString()))
{
continue;
}
builder.SetProperty(parameter.Key, parameter.Value);
}
}
public void TestOnInstanceMethod()
{
byte[] bytes = new byte[MethodBodyLength];
_generator.GetBytes(bytes);
EventBuilder ev = TypeBuilder.DefineEvent("Event_PosTest2", EventAttributes.None, typeof(TestEventHandler));
MethodBuilder method = TypeBuilder.DefineMethod("Method_PosTest2", MethodAttributes.Public);
ILGenerator ilgen = method.GetILGenerator();
ilgen.Emit(OpCodes.Ret);
ev.SetRemoveOnMethod(method);
// add this method again
ev.SetRemoveOnMethod(method);
}
public static void GenHookupEvent(TypeBuilder typeB, EventInfo declEvent, string @interface, HashSet <MethodInfo> evaluating)
{
EventBuilder event_builder = typeB.DefineEvent(declEvent.Name,
declEvent.Attributes,
declEvent.EventHandlerType);
MethodInfo[] sources = new MethodInfo[] { declEvent.GetAddMethod(),
declEvent.GetRemoveMethod() };
foreach (MethodInfo source in sources)
{
if (null == source)
{
continue;
}
evaluating.Remove(source);
MethodBuilder meth_builder = CreateMethodBuilder(typeB, source);
ILGenerator ilg = meth_builder.GetILGenerator();
bool adding = sources[0] == source;
EmitThis(ilg);
//interface
ilg.Emit(OpCodes.Ldstr, @interface);
ilg.Emit(OpCodes.Ldstr, declEvent.Name);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(OpCodes.Ldc_I4, adding ? 1 : 0);
ilg.Emit(OpCodes.Tailcall);
ilg.Emit(toggleSignalMethod.IsFinal ? OpCodes.Call : OpCodes.Callvirt, toggleSignalMethod);
ilg.Emit(OpCodes.Ret);
if (adding)
{
event_builder.SetAddOnMethod(meth_builder);
}
else
{
event_builder.SetRemoveOnMethod(meth_builder);
}
}
}
public static void Define(TypeBuilder typeB, Interface iface)
{
foreach (Method declMethod in iface.Methods)
{
DefineMethod(typeB, declMethod.Name, ifaceMethAttr, declMethod.Arguments, false);
}
if (iface.Properties != null)
{
foreach (NDesk.DBus.Introspection.Property prop in iface.Properties)
{
Type propType = new Signature(prop.Type).ToType();
PropertyBuilder prop_builder = typeB.DefineProperty(prop.Name, PropertyAttributes.None, propType, Type.EmptyTypes);
if (prop.Access == propertyAccess.read || prop.Access == propertyAccess.readwrite)
{
prop_builder.SetGetMethod(typeB.DefineMethod("get_" + prop.Name, ifaceMethAttr | MethodAttributes.SpecialName, propType, Type.EmptyTypes));
}
if (prop.Access == propertyAccess.write || prop.Access == propertyAccess.readwrite)
{
prop_builder.SetSetMethod(typeB.DefineMethod("set_" + prop.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] { propType }));
}
}
}
if (iface.Signals != null)
{
foreach (NDesk.DBus.Introspection.Signal signal in iface.Signals)
{
Type eventType = DefineHandler(modBdef, signal);
EventBuilder event_builder = typeB.DefineEvent(signal.Name, EventAttributes.None, eventType);
event_builder.SetAddOnMethod(typeB.DefineMethod("add_" + signal.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] { eventType }));
event_builder.SetRemoveOnMethod(typeB.DefineMethod("remove_" + signal.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] { eventType }));
}
}
//apply InterfaceAttribute
ConstructorInfo interfaceAttributeCtor = typeof(InterfaceAttribute).GetConstructor(new Type[] { typeof(string) });
CustomAttributeBuilder cab = new CustomAttributeBuilder(interfaceAttributeCtor, new object[] { iface.Name });
typeB.SetCustomAttribute(cab);
}
/// <summary>
/// Creates a MoBi Event by the given SBML Event.
/// </summary>
internal void CreateEvent(Event sbmlEvent)
{
EventBuilder = new EventBuilder()
.WithId(sbmlEvent.getId() + SBMLConstants.SBML_EVENTBUILDER)
.WithName(sbmlEvent.getId())
.WithDescription(sbmlEvent.getNotesString());
if (sbmlEvent.isSetTrigger())
{
CreateCondition(sbmlEvent.getTrigger());
}
CreateEventAssignments(sbmlEvent);
CreateWarningsForUnsupportedFeatures(sbmlEvent);
EventGroupBuilder.Add(EventBuilder);
}
public void CallingRemoveAttendanceRemovesTheCorrectAttendanceWhenTheAttandanceExistsByReference()
{
// Arrange
var user = new UserBuilder().Build();
var happening = new EventBuilder().AddAttendance(_attendance).Build();
happening.AddAttendance(new AttendanceBuilder().User(user).Build());
happening.AddAttendance(new AttendanceBuilder().Build());
// Act
happening.RemoveAttendance(user);
// Assert
Assert.AreEqual(2, happening.Attendances.Count);
Assert.IsNull(happening.Attendances.FirstOrDefault(a => a.User.Username == user.Username));
}
protected override void Context()
{
base.Context();
var e1 = new EventBuilder().WithName("Event");
e1.OneTime = true;
e1.Formula = new ExplicitFormula("Time>StartTime");
var e2 = new EventBuilder().WithName("Event");
e2.OneTime = true;
e2.Formula = new ExplicitFormula("Time>StopTime");
_object1 = e1;
_object2 = e2;
}
public virtual IEventStoreConnection GetEventStoreConnection()
{
ConnectionSettings settings = ConnectionSettings.Create();
IPEndPoint endPoint = GetEventStoreIpEndPoint();
IEventStoreConnection connection = EventStoreConnection.Create(settings, endPoint);
Task connecting = connection.ConnectAsync();
connecting.Wait();
EventData connectionEvent = EventBuilder.CreateClientConnectedEvent(GetEventStoreClientName());
Task notify = connection.AppendToStreamAsync(GetEventStoreConnectionLogStreamName(), ExpectedVersion.Any, connectionEvent);
notify.Wait();
return(connection);
}
public void TestCreateUser()
{
RemoveAll();
Event user = new EventBuilder()
.SetId(1)
.SetTitle("title")
.SetGenre("genre")
.SetDate(DateTime.Now)
.SetDescription("Des")
.SetNoTickets(1)
.SetPrice(1.0)
.Build();
Assert.IsTrue(eventRepo.Create(user));
RemoveAll();
}
private static void Submit(EventBuilder builder, string[] tags, List <KeyValuePair <string, object> > propertys)
{
if (tags != null)
{
builder.AddTags(tags);
}
if (propertys != null)
{
foreach (var property in propertys)
{
builder.SetProperty(property.Key, property.Value);
}
}
builder.Submit();
}
protected override void OnWebSocketClose(CloseEventArgs e)
{
// Close all websocket connections if the user websocket connection is closed
this._gameManager.WebSocketServices.GetSessions(GameManager.ChatWsPath).CloseSession(this._warsimUser.ChatWebSocketId);
this._gameManager.WebSocketServices.GetSessions(GameManager.GameHostWsPath).CloseSession(this._warsimUser.GameHostWebSocketId);
this._gameManager.WebSocketServices.GetSessions(GameManager.LocalGameWsPath).CloseSession(this._warsimUser.LocalGameWebSocketId);
var ev = EventBuilder.Build(new UserDisconnectedMessage
{
UserId = this._warsimUser.UserId
});
this.Sessions.Broadcast(ev.Serialize());
this._userManager.DisconnectUser(this._warsimUser.UserId);
}
public void Setup() {
_randomEventBuilder = GetException(Guid.NewGuid().ToString()).ToExceptionless();
_fixedEventBuilder = GetException().ToExceptionless();
}
public override bool Define ()
{
if (!base.Define ())
return false;
if (!MemberType.IsDelegate) {
Report.Error (66, Location, "`{0}': event must be of a delegate type", GetSignatureForError ());
}
if (!CheckBase ())
return false;
//
// Now define the accessors
//
var AddBuilder = Add.Define (Parent);
if (AddBuilder == null)
return false;
var RemoveBuilder = remove.Define (Parent);
if (RemoveBuilder == null)
return false;
EventBuilder = Parent.TypeBuilder.DefineEvent (GetFullName (MemberName), EventAttributes.None, MemberType.GetMetaInfo ());
EventBuilder.SetAddOnMethod (AddBuilder);
EventBuilder.SetRemoveOnMethod (RemoveBuilder);
spec = new EventSpec (Parent.Definition, this, MemberType, ModFlags, Add.Spec, remove.Spec);
Parent.MemberCache.AddMember (this, GetFullName (MemberName), spec);
Parent.MemberCache.AddMember (this, AddBuilder.Name, Add.Spec);
Parent.MemberCache.AddMember (this, RemoveBuilder.Name, remove.Spec);
return true;
}
