/// <summary>
/// 添加事件及回调
/// </summary>
/// <param name="type">事件枚举</param>
/// <param name="handle">回调</param>
/// <param name="isUseOnce"></param>
public static void AddEvent(Enum type, EventHandle handle, bool isUseOnce = false)
{
if (isUseOnce)
{
if (mUseOnceEventDic.ContainsKey(type))
{
if (!mUseOnceEventDic[type].Contains(handle))
mUseOnceEventDic[type].Add(handle);
else
Debug.LogWarning("already existing EventType: " + type + " handle: " + handle);
}
else
{
List<EventHandle> temp = new List<EventHandle>();
temp.Add(handle);
mUseOnceEventDic.Add(type, temp);
}
}
else
{
if (mEventDic.ContainsKey(type))
{
if (!mEventDic[type].Contains(handle))
mEventDic[type].Add(handle);
else
Debug.LogWarning("already existing EventType: "+ type+" handle: "+ handle );
}
else
{
List<EventHandle> temp = new List<EventHandle>();
temp.Add(handle);
mEventDic.Add(type, temp);
}
}
}
public void AddEventListener(string type, EventHandle handle)
{
if (!mCallFuncHandleDic.ContainsKey(type))
{
mCallFuncHandleDic[type] = handle;
}
}
/// <summary>
/// 添加事件及回调
/// </summary>
/// <param name="type">事件枚举</param>
/// <param name="handle">回调</param>
/// <param name="isUseOnce"></param>
public static void AddEvent(Enum type, EventHandle handle, bool isUseOnce = false)
{
if (isUseOnce)
{
if (mUseOnceEventDic.ContainsKey(type))
{
if (!mUseOnceEventDic[type].Contains(handle))
{
mUseOnceEventDic[type].Add(handle);
}
else
{
Debug.LogWarning("already existing EventType: " + type + " handle: " + handle);
}
}
else
{
List <EventHandle> temp = new List <EventHandle>();
temp.Add(handle);
mUseOnceEventDic.Add(type, temp);
}
}
else
{
if (mEventDic.ContainsKey(type))
{
mEventDic[type] += handle;
}
else
{
mEventDic.Add(type, handle);
}
}
}
public void AddEventHandler(string type, NetEventHanlder handler, int priority = 0)
{
ArrayList handles = null;
if (!eventHandles.TryGetValue(type, out handles))
{
handles = new ArrayList();
eventHandles.Add(type, handles);
}
EventHandle handle = new EventHandle {
handler = handler, priority = priority
};
int index = 0;
for (int i = 0; i < handles.Count; i++)
{
if (((EventHandle)handles[i]).priority <= handle.priority)
{
index = i;
break;
}
}
handles.Insert(index, handle);
}
/// <summary>
/// 移除某类事件的一个回调
/// </summary>
/// <param name="type"></param>
/// <param name="handle"></param>
public static void RemoveEvent(Enum type, EventHandle handle)
{
if (mUseOnceEventDic.ContainsKey(type))
{
if (mUseOnceEventDic[type].Contains(handle))
{
mUseOnceEventDic[type].Remove(handle);
if (mUseOnceEventDic[type].Count == 0)
{
mUseOnceEventDic.Remove(type);
}
}
}
if (mEventDic.ContainsKey(type))
{
if (mEventDic[type].Contains(handle))
{
mEventDic[type].Remove(handle);
if (mEventDic[type].Count == 0)
{
mEventDic.Remove(type);
}
}
}
}
public override async Task OnActivateAsync()
{
await ReadSnapshotAsync();
while (true)
{
var eventList = await EventStorage.GetListAsync(this.GrainId, this.State.Version, this.State.Version + 1000, this.State.VersionTime);
foreach (var @event in eventList)
{
this.State.IncrementDoingVersion();//标记将要处理的Version
EventHandle.Apply(this.State, @event.Event);
if ([email protected])
{
using (var ms = new PooledMemoryStream())
{
Serializer.Serialize(ms, @event.Event);
await AfterEventSavedHandle(@event.Event, ms.ToArray());
}
}
this.State.UpdateVersion(@event.Event);//更新处理完成的Version
}
if (eventList.Count < 1000)
{
break;
}
}
;
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionHandle"/> class.
/// </summary>
internal SubscriptionHandle()
{
EventHandle = new EventHandle()
{
PublisherNodeId = EllaConfiguration.Instance.NodeId
};
}
/// <summary>
/// 移除某类事件的一个回调
/// </summary>
/// <param name="eventName"></param>
/// <param name="handle"></param>
public void RemoveEvent(string eventName, EventHandle handle)
{
if (mUseOnceEventDic.ContainsKey(eventName))
{
if (mUseOnceEventDic[eventName].Contains(handle))
{
mUseOnceEventDic[eventName].Remove(handle);
if (mUseOnceEventDic[eventName].Count == 0)
{
mUseOnceEventDic.Remove(eventName);
}
}
}
if (mEventDic.ContainsKey(eventName))
{
if (mEventDic[eventName].Contains(handle))
{
mEventDic[eventName].Remove(handle);
if (mEventDic[eventName].Count == 0)
{
mEventDic.Remove(eventName);
}
}
}
}
/// <summary>
/// 移除某类事件的一个回调
/// </summary>
/// <param name="type"></param>
/// <param name="handle"></param>
public static void RemoveEvent(string eventKey, EventHandle handle)
{
if (m_stringEventDic.ContainsKey(eventKey))
{
if (m_stringEventDic[eventKey].Contains(handle))
{
m_stringEventDic[eventKey].Remove(handle);
//if (m_stringEventDic[eventKey].Count == 0)
//{
// m_stringEventDic.Remove(eventKey);
//}
}
}
if (m_stringOnceEventDic.ContainsKey(eventKey))
{
if (m_stringOnceEventDic[eventKey].Contains(handle))
{
m_stringOnceEventDic[eventKey].Remove(handle);
//if (m_stringOnceEventDic[eventKey].Count == 0)
//{
// m_stringOnceEventDic.Remove(eventKey);
//}
}
}
}
public MacrosView()
{
InitializeComponent();
EventsBuiltin.RegisterListener <Recording>(EventID.REC,
(r) =>
{
this.Dispatcher.Invoke(() => { onRec(r); });
});
recLoaded = EventsBuiltin.RegisterEvent <Recording>(EventID.REC_LOADED);
//test
//model = new RecordingModel();
//keyframesControl.DataContext = model;
//var n1 = new OpenLinkedListNode<Recording.KeyFrame>(new Recording.KeyFrameK(KeyActions.PRESS, System.Windows.Forms.Keys.A, 1200));
//var n2 = new OpenLinkedListNode<Recording.KeyFrame>(new Recording.KeyFrameK(KeyActions.PRESS, System.Windows.Forms.Keys.B, 1300));
//n1.Next = n2;
//var container = new RecordingModel.FocusContainer();
//var t1 = new InfoTray(n1, null, focusedTray: container);
//var t2 = new InfoTray(n2, t1.Model, focusedTray: container);
//model.Keyframes.Add(t1);
//model.Keyframes.Add(t2);
//Recording rec = new Recording();
////rec.AddKeyFrame(new Recording.KeyFrameK(KeyActions.PRESS, System.Windows.Forms.Keys.A, 1200));
////rec.AddKeyFrame(new Recording.KeyFrameK(KeyActions.PRESS, System.Windows.Forms.Keys.B, 1300));
//rec.AddKeyframe(MouseAction.WM_LBUTTONDOWN, 25, 1, 1200);
//rec.AddKeyframe(MouseAction.WM_LBUTTONUP, 35, 2, 1300);
//onRec(rec);
}
static int AddEventListener(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
UIBase obj = (UIBase)ToLua.CheckObject(L, 1, typeof(UIBase));
System.Enum arg0 = (System.Enum)ToLua.CheckObject(L, 2, typeof(System.Enum));
EventHandle arg1 = null;
LuaTypes funcType3 = LuaDLL.lua_type(L, 3);
if (funcType3 != LuaTypes.LUA_TFUNCTION)
{
arg1 = (EventHandle)ToLua.CheckObject(L, 3, typeof(EventHandle));
}
else
{
LuaFunction func = ToLua.ToLuaFunction(L, 3);
arg1 = DelegateFactory.CreateDelegate(typeof(EventHandle), func) as EventHandle;
}
obj.AddEventListener(arg0, arg1);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
public IDisposable Register(Type type, Func <object, Task> callback)
{
var handler = new EventHandle(this, type, callback);
listeners.Add(handler);
return(handler);
}
public static AccountState FromBytes(byte[] bytes)
{
var cursor = new CursorBuffer(bytes);
var authenticationKeyLen = cursor.Read32();
var authenticationKey = cursor.ReadXBytes((int)authenticationKeyLen);
var balance = cursor.Read64();
var delegatedKeyRotationCapability = cursor.ReadBool();
var delegatedWithdrawalCapability = cursor.ReadBool();
var receivedEventsCount = cursor.Read32();
cursor.Read32(); // skip struct attribute sequence number
var receivedEventsKeyLen = cursor.Read32();
var receivedEventsKey = cursor.ReadXBytes((int)receivedEventsKeyLen);
var sentEventsCount = cursor.Read32();
cursor.Read32(); // skip struct attribute sequence number
var sentEventsKeyLen = cursor.Read32();
var sentEventsKey = cursor.ReadXBytes((int)sentEventsKeyLen);
var sequenceNumber = cursor.Read64();
var receivedEvents = new EventHandle(receivedEventsKey, receivedEventsCount);
var sentEvents = new EventHandle(sentEventsKey, sentEventsCount);
return(new AccountState(authenticationKey, balance, receivedEvents, sentEvents, sequenceNumber, delegatedWithdrawalCapability, delegatedKeyRotationCapability));
}
private void btnPortOpen_Click(object sender, EventArgs e)
{
try
{
if (!COM.IsOpen) // open
{
COMGetSettings();
COM.Open();
DataReceived += new EventHandle(COMGetData);
}
if (!loop) // begin read
{
loop = true;
thread = new Thread(new ThreadStart(PortRead));
thread.Start();
}
if (COM.IsOpen)
{
lbCOMstatus.Text = "串口已打开";
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public virtual void Init()
{
EventHandle.AddCommandHook(COMMAND_TYPE.GAME_START, OnStart);
EventHandle.AddCommandHook(COMMAND_TYPE.SCORE, OnScore);
EventHandle.AddCommandHook(COMMAND_TYPE.COMMAND_MAX, OnScore);
EventHandle.AddCommandHook(COMMAND_TYPE.GAME_OVERD, OnDied);
}
public Message(short cmd, short cmd_branch, object protoBuffer,EventHandle handle=null)
{
this.cmd = cmd;
this.cmd_branch = cmd_branch;
this.protoBuffer = protoBuffer;
this.eventHandle = handle;
encodeMessage();
}
/// <inheritdoc />
public IEventHandle <TEvent> GetHandle <TEvent>()
{
if (!_handleCache.ContainsKey(typeof(TEvent)))
{
_handleCache[typeof(TEvent)] = new EventHandle <TEvent>(this);
}
return((IEventHandle <TEvent>)_handleCache[typeof(TEvent)]);
}
public bool TryGetEvent(string name, out EventHandle handle)
{
if (this.eventDefs == null)
{
this.eventDefs = GetEventDefs(this.reader, this.typeHandle);
}
return(this.eventDefs.TryGetValue(name, out handle));
}
//
// eventHandle - the "tkEventDef" that identifies the event.
// definingType - the "tkTypeDef" that defined the field (this is where you get the metadata reader that created eventHandle.)
// contextType - the type that supplies the type context (i.e. substitutions for generic parameters.) Though you
// get your raw information from "definingType", you report "contextType" as your DeclaringType property.
//
// For example:
//
// typeof(Foo<>).GetTypeInfo().DeclaredMembers
//
// The definingType and contextType are both Foo<>
//
// typeof(Foo<int,String>).GetTypeInfo().DeclaredMembers
//
// The definingType is "Foo<,>"
// The contextType is "Foo<int,String>"
//
// We don't report any DeclaredMembers for arrays or generic parameters so those don't apply.
//
private NativeFormatRuntimeEventInfo(EventHandle eventHandle, NativeFormatRuntimeNamedTypeInfo definingTypeInfo, RuntimeTypeInfo contextTypeInfo, RuntimeTypeInfo reflectedType) :
base(contextTypeInfo, reflectedType)
{
_eventHandle = eventHandle;
_definingTypeInfo = definingTypeInfo;
_reader = definingTypeInfo.Reader;
_event = eventHandle.GetEvent(_reader);
}
//
// eventHandle - the "tkEventDef" that identifies the event.
// definingType - the "tkTypeDef" that defined the field (this is where you get the metadata reader that created eventHandle.)
// contextType - the type that supplies the type context (i.e. substitutions for generic parameters.) Though you
// get your raw information from "definingType", you report "contextType" as your DeclaringType property.
//
// For example:
//
// typeof(Foo<>).GetTypeInfo().DeclaredMembers
//
// The definingType and contextType are both Foo<>
//
// typeof(Foo<int,String>).GetTypeInfo().DeclaredMembers
//
// The definingType is "Foo<,>"
// The contextType is "Foo<int,String>"
//
// We don't report any DeclaredMembers for arrays or generic parameters so those don't apply.
//
private RuntimeEventInfo(EventHandle eventHandle, RuntimeNamedTypeInfo definingTypeInfo, RuntimeTypeInfo contextTypeInfo)
{
_eventHandle = eventHandle;
_definingTypeInfo = definingTypeInfo;
_contextTypeInfo = contextTypeInfo;
_reader = definingTypeInfo.Reader;
_event = eventHandle.GetEvent(_reader);
}
public EventProperties(EventHandle eventHandle)
{
InitializeComponent();
_eventHandle = eventHandle;
_eventHandle.Reference();
this.UpdateInfo();
}
public EventProperties(EventHandle eventHandle)
{
InitializeComponent();
_eventHandle = eventHandle;
_eventHandle.Reference();
this.UpdateInfo();
}
//
// eventHandle - the "tkEventDef" that identifies the event.
// definingType - the "tkTypeDef" that defined the field (this is where you get the metadata reader that created eventHandle.)
// contextType - the type that supplies the type context (i.e. substitutions for generic parameters.) Though you
// get your raw information from "definingType", you report "contextType" as your DeclaringType property.
//
// For example:
//
// typeof(Foo<>).GetTypeInfo().DeclaredMembers
//
// The definingType and contextType are both Foo<>
//
// typeof(Foo<int,String>).GetTypeInfo().DeclaredMembers
//
// The definingType is "Foo<,>"
// The contextType is "Foo<int,String>"
//
// We don't report any DeclaredMembers for arrays or generic parameters so those don't apply.
//
private RuntimeEventInfo(EventHandle eventHandle, RuntimeNamedTypeInfo definingTypeInfo, RuntimeTypeInfo contextTypeInfo)
{
_eventHandle = eventHandle;
_definingTypeInfo = definingTypeInfo;
_contextTypeInfo = contextTypeInfo;
_reader = definingTypeInfo.Reader;
_event = eventHandle.GetEvent(_reader);
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
string postString = string.Empty;
string action = Tool.WEBRequest.GetQueryString("action");
if (string.IsNullOrEmpty(action))
{
if (HttpContext.Current.Request.HttpMethod.ToUpper() == "POST")
{
using (Stream stream = HttpContext.Current.Request.InputStream)
{
Byte[] postBytes = new Byte[stream.Length];
stream.Read(postBytes, 0, (Int32)stream.Length);
postString = Encoding.UTF8.GetString(postBytes);
string msg = new EventHandle().ReturnMessage(postString);
Response.Write(msg);
}
}
if (HttpContext.Current.Request.HttpMethod.ToUpper() == "GET")
{
new WeiXin().Auth();
}
}
else if (action.ToLower() == "clearcache")
{
string user_Ip = Tool.WEBRequest.GetIP();
if (IsValidIp(user_Ip))
{
//清理客户端WCF缓存
//TuanDai.BalancedSystem.Client.BalancedSystemClient client = new TuanDai.BalancedSystem.Client.BalancedSystemClient();
//client.ClearCacheByClient();
Response.Write("1");
Response.End();
}
else
{
Response.Write("非法的来访IP");
Response.End();
}
}
else if (action.ToLower() == "cleartoken")
{
string strValidatePass = Tool.WEBRequest.GetQueryString("ValidatePass");
if (strValidatePass == "tuandaiisgood")
{
// TuanDai.WXApiWeb.Common.WeiXinApi.removeCache("WeiXinTicket");
//请求完检测DB中Token状态 Allen 2015-08-12
ThirdLoginSDK.CheckDBTokenDelegate chkStatus = new ThirdLoginSDK.CheckDBTokenDelegate(ThirdLoginSDK.CheckDBTokenStatus);
chkStatus.BeginInvoke(GlobalUtils.AppId, null, null);
}
}
}
catch (Exception ex)
{
SysLogHelper.WriteErrorLog("微信请求", "错误详细信息：" + ex.Message + "|" + ex.StackTrace);
}
}
public bool RemoveHandler(EventHandle handle)
{
if (this.events.Contains(handle))
{
this.events.Remove(handle);
return(true);
}
return(false);
}
private AccountState(byte[] authenticationKey, ulong balance, EventHandle receivedEvents, EventHandle sentEvents, ulong sequenceNumber, bool delegatedWithdrawalCapability)
{
this.AuthenticationKey = authenticationKey;
this.Balance = balance;
this.ReceivedEvents = receivedEvents;
this.SentEvents = sentEvents;
this.SequenceNumber = sequenceNumber;
this.DelegatedWithdrawalCapability = delegatedWithdrawalCapability;
}
} // Read
public static uint Read(this NativeReader reader, uint offset, out EventHandle handle)
{
uint value;
offset = reader.DecodeUnsigned(offset, out value);
handle = new EventHandle((int)value);
handle._Validate();
return(offset);
} // Read
IEnumerator RestartGame()
{
yield return(new WaitForSecondsRealtime(tickTime));
ResetGame();
EventHandle.Command(COMMAND_TYPE.GAME_RESET);
isGameStart = true;
EventHandle.Command(COMMAND_TYPE.GAME_START);
}
/// <summary>
/// キューに非同期メッセージを入れます
/// </summary>
/// <param name="d">呼び出すSendOrPostCallbackデリゲート</param>
/// <param name="state">デリゲートに渡されるオブジェクト</param>
public override void Post(SendOrPostCallback d, object state)
{
var msg = new Message(this, d, state);
lock (((ICollection)queue).SyncRoot) {
queue.Enqueue(msg);
EventHandle.Set();
}
}
//等一段时间再开始 让 reinforcement 把最后一次失败更新到 q_table
IEnumerator RestartGame()
{
yield return(new WaitForSecondsRealtime(tickTime));
ResetGame();
EventHandle.Command(COMMAND_TYPE.GAME_RESET);
GameManager.S.isGameStart = true;
EventHandle.Command(COMMAND_TYPE.GAME_START);
Scorers.S.SetLiveTime(true);
}
public void GameOver()
{
isGameOver = true;
EventHandle.Command(COMMAND_TYPE.GAME_OVERD);
if (isTrainning)
{
StartCoroutine(RestartGame());
}
}
public void AddEventListener(Enum EventEnum, EventHandle handle)
{
EventHandRegisterInfo info = new EventHandRegisterInfo();
info.m_EventKey = EventEnum;
info.m_hande = handle;
GlobalEvent.AddEvent(EventEnum, handle);
m_EventListeners.Add(info);
}
public bool AddHandler(EventHandle handle)
{
if (this.events.Exists((EventHandle item) => item == handle))
{
return(false);
}
this.events.Add(handle);
return(true);
}
public void AddEventListener(Enum EventEnum, EventHandle handle)
{
EventHandRegisterInfo info = new EventHandRegisterInfo();
info.m_EventKey = EventEnum;
info.m_hande = handle;
GlobalEvent.AddEvent(EventEnum, handle);
m_EventListeners.Add(info);
}
public bool DetachEvent(EventCode eventCode, EventHandle eventHandle)
{
List <EventHandle> list = _EventMap[(int)eventCode];
if (list != null)
{
return(list.Remove(eventHandle));
}
return(false);
}
internal override bool TryGetEventHandle(Cci.IEventDefinition def, out EventHandle handle)
{
var other = this.mapToMetadata.MapDefinition(def) as PEEventSymbol;
if ((object)other != null)
{
handle = other.Handle;
return true;
}
else
{
handle = default(EventHandle);
return false;
}
}
public void AddEventListener(string key, EventHandle handle)
{
if (_dict.ContainsKey(key))
{
Delegate[] _delegates = _dict[key].GetInvocationList();
for (int i = 0; i < _delegates.Length; i++)
{
if (_delegates[i] == handle)
{
return;
}
}
_dict[key] += handle;
}
else
{
_dict.Add(key, handle);
}
}
public void RemoveEventListener(string key, EventHandle handle)
{
if (_dict.ContainsKey(key))
{
Delegate[] _delegates = _dict[key].GetInvocationList();
for (int i = 0; i < _delegates.Length; i++)
{
if (_delegates[i] == handle)
{
_dict[key] -= handle;
return;
}
}
if (_dict[key] == null)
{
_dict.Remove(key);
}
}
}
public sealed override IEnumerable<CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, EventHandle eventHandle, TypeDefinitionHandle declaringTypeHandle)
{
return Empty<CustomAttributeData>.Enumerable;
}
public static bool IsTypeOf(INETWISEDriverSink sink, DatabaseHandle hDatabase, EventHandle hEvent)
{
WISE_RESULT wResult = WISEError.WISE_OK;
AttributeHandle hAttr = WISEConstants.WISE_INVALID_HANDLE;
string strEntityType = string.Empty;
if ((sink == null) || (hEvent == WISEConstants.WISE_INVALID_HANDLE))
{
return false;
}
// Initialize handle cache
Initialize(sink as INETWISEStringCache);
wResult = sink.GetEventAttributeHandle(hDatabase, hEvent, WISEConstants.WISE_TEMPLATE_EVENT_TYPE, ref hAttr,
DataType.String);
bool bResult = WISEError.CheckCallFailed(wResult);
wResult = sink.GetEventAttributeValue(hDatabase, hEvent, hAttr, ref strEntityType);
bResult = WISEError.CheckCallSucceeded(wResult);
return bResult && IsTypeOf(strEntityType);
}
public CBRNLCDControl(INETWISEDriverSink sink, DatabaseHandle databaseHandle, EventHandle eventHandle)
{
this.WISESink = sink;
this.Database = databaseHandle;
this.Handle = eventHandle;
}
protected override WISE_RESULT OnSendEvent(DateTime timeStamp, DatabaseHandle hDatabase, EventHandle hEvent,
ClassHandle hClass, TransactionHandle hTransaction)
{
WISE_RESULT result = WISEError.WISE_OK;
// Call base class implementation
result = base.OnSendEvent(timeStamp, hDatabase, hEvent, hClass, hTransaction);
WISEError.CheckCallFailedEx(result);
try
{
//
// TODO: Send event on driver communication interface.
//
// This method typically needs to perform the following steps;
// 1. Identify the type of event.
// 2. Based on the event type, extract event attributes.
// 3. Fill event attribute values into the protocol container associated with the event.
// 4. Send the event on the underlying protocol.
//
#region Sample code: Check event type
//ClassHandle hTestEventClass = ClassHandle.Invalid;
//// Get handle corresponding to class "TEST_EVENT" (this can be done once and then cached)
//result = this.WISETypeInfo.GetWISEClassHandle(hDatabase, "TEST_EVENT", ref hTestEventClass);
//WISEError.CheckCallFailedEx(result);
//if (hClass == hTestEventClass)
//{
// #region Sample code: Access TEST_EVENT attributes
// string stringAttributeValue = "";
// AttributeHandle hAttr = AttributeHandle.Invalid;
// result = this.Sink.GetEventAttributeHandle(hDatabase, hEvent, "TEST_STRING", ref hAttr);
// WISEError.CheckCallFailedEx(result);
// result = this.Sink.GetEventAttributeValue(hDatabase, hEvent, hAttr, ref stringAttributeValue);
// WISEError.CheckCallFailedEx(result);
// #endregion
//}
#endregion
}
catch (WISEException ex)
{
result = ex.Error.ErrorCode;
}
return result;
}
internal PEEventSymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
EventHandle handle,
PEMethodSymbol addMethod,
PEMethodSymbol removeMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
Debug.Assert((object)addMethod != null);
Debug.Assert((object)removeMethod != null);
this.addMethod = addMethod;
this.removeMethod = removeMethod;
this.handle = handle;
this.containingType = containingType;
EventAttributes mdFlags = 0;
Handle eventType = default(Handle);
try
{
var module = moduleSymbol.Module;
module.GetEventDefPropsOrThrow(handle, out this.name, out mdFlags, out eventType);
}
catch (BadImageFormatException mrEx)
{
if ((object)this.name == null)
{
this.name = string.Empty;
}
lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
if (eventType.IsNil)
{
this.eventType = new UnsupportedMetadataTypeSymbol(mrEx);
}
}
if ((object)this.eventType == null)
{
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
this.eventType = metadataDecoder.GetTypeOfToken(eventType);
}
// IsWindowsRuntimeEvent checks the signatures, so we just have to check the accessors.
bool callMethodsDirectly = IsWindowsRuntimeEvent
? !DoModifiersMatch(this.addMethod, this.removeMethod)
: !DoSignaturesMatch(moduleSymbol, this.eventType, this.addMethod, this.removeMethod);
if (callMethodsDirectly)
{
flags |= Flags.CallMethodsDirectly;
}
else
{
this.addMethod.SetAssociatedEvent(this, MethodKind.EventAdd);
this.removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove);
}
if ((mdFlags & EventAttributes.SpecialName) != 0)
{
flags |= Flags.IsSpecialName;
}
if ((mdFlags & EventAttributes.RTSpecialName) != 0)
{
flags |= Flags.IsRuntimeSpecialName;
}
}
public bool TryGetEvent(string name, out EventHandle handle)
{
if (this.eventDefs == null)
{
this.eventDefs = GetEventDefs(this.reader, this.typeHandle);
}
return this.eventDefs.TryGetValue(name, out handle);
}
public static bool IsTypeOf(INETWISEDriverSink2 WISE, DatabaseHandle hDatabase, EventHandle hEvent)
{
uint result = WISEError.WISE_ERROR;
AttributeHandle hAttr = WISEConstants.WISE_INVALID_HANDLE;
string strEntityType = string.Empty;
if ((WISE == null) || (hEvent == WISEConstants.WISE_INVALID_HANDLE))
{
return false;
}
result = WISE.GetEventAttributeHandle(hDatabase, hEvent, WISEConstants.WISE_TEMPLATE_EVENT_TYPE, ref hAttr);
if (WISEError.CheckCallFailed(result))
{
return false;
}
result = WISE.GetEventAttributeValue(hDatabase, hEvent, hAttr, ref strEntityType);
return WISEError.CheckCallSucceeded(result) && IsTypeOf(strEntityType);
}
public CBRNLCDControl(INETWISEDriverSink2 WISE, DatabaseHandle databaseHandle, EventHandle eventHandle)
{
this.WISE = WISE;
this.Database = databaseHandle;
this.Handle = eventHandle;
}
internal abstract bool TryGetEventHandle(IEventDefinition def, out EventHandle handle);
public void SetNoHandle(EventHandle no)
{
eventNo = no;
}
public void SetYesHandle(EventHandle yes)
{
eventYes = yes;
}
/// <summary>
/// 移除某类事件的一个回调
/// </summary>
/// <param name="type"></param>
/// <param name="handle"></param>
public static void RemoveEvent(string eventKey, EventHandle handle)
{
if (m_stringEventDic.ContainsKey(eventKey))
{
if (m_stringEventDic[eventKey].Contains(handle))
{
m_stringEventDic[eventKey].Remove(handle);
//if (m_stringEventDic[eventKey].Count == 0)
//{
// m_stringEventDic.Remove(eventKey);
//}
}
}
if (m_stringOnceEventDic.ContainsKey(eventKey))
{
if (m_stringOnceEventDic[eventKey].Contains(handle))
{
m_stringOnceEventDic[eventKey].Remove(handle);
//if (m_stringOnceEventDic[eventKey].Count == 0)
//{
// m_stringOnceEventDic.Remove(eventKey);
//}
}
}
}
public abstract IEnumerable<CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, EventHandle eventHandle, TypeDefinitionHandle declaringTypeHandle);
/// <summary>
/// 移除某类事件的一个回调
/// </summary>
/// <param name="type"></param>
/// <param name="handle"></param>
public static void RemoveEvent(Enum type, EventHandle handle)
{
if (mUseOnceEventDic.ContainsKey(type))
{
if (mUseOnceEventDic[type].Contains(handle))
{
mUseOnceEventDic[type].Remove(handle);
if (mUseOnceEventDic[type].Count == 0)
{
mUseOnceEventDic.Remove(type);
}
}
}
if (mEventDic.ContainsKey(type))
{
if (mEventDic[type].Contains(handle))
{
mEventDic[type].Remove(handle);
if (mEventDic[type].Count == 0)
{
mEventDic.Remove(type);
}
}
}
}
/// <summary>
/// 添加事件及回调
/// </summary>
/// <param name="type">事件枚举</param>
/// <param name="handle">回调</param>
/// <param name="isUseOnce"></param>
public static void AddEvent(string eventKey, EventHandle handle, bool isUseOnce = false)
{
if (isUseOnce)
{
if (m_stringOnceEventDic.ContainsKey(eventKey))
{
if (!m_stringOnceEventDic[eventKey].Contains(handle))
m_stringOnceEventDic[eventKey].Add(handle);
else
Debug.LogWarning("already existing EventType: " + eventKey + " handle: " + handle);
}
else
{
List<EventHandle> temp = new List<EventHandle>();
temp.Add(handle);
m_stringOnceEventDic.Add(eventKey, temp);
}
}
else
{
if (m_stringEventDic.ContainsKey(eventKey))
{
if (!m_stringEventDic[eventKey].Contains(handle))
m_stringEventDic[eventKey].Add(handle);
else
Debug.LogWarning("already existing EventType: " + eventKey + " handle: " + handle);
}
else
{
List<EventHandle> temp = new List<EventHandle>();
temp.Add(handle);
m_stringEventDic.Add(eventKey, temp);
}
}
}