C# 关于获取控件事件委托列表的一点总结

-- 反射获取控件事件委托FieldInfo的几种情况总结
1、通过 ("Event" + EventInfo.Name) 来获取 FieldInfo
例如： GetField("EventClick") 即可获取控件Click事件委托字段
2、通过 ("Event" + EventInfo.Name.Replace("Changed","")) 来获取 FieldInfo
例如： GetField("EventText") 即可获取控件的TextChanged事件委托字段
3、通过 ("Event" + EventInfo.Name).ToUpper() 来获取 FieldInfo
例如： GetField("EVENT_SELECTEDINDEXCHANGED") 即可获取控件的SelectedIndexChanged事件委托字段
4、通过 ("Event" + EventInfo.Name.Replace("Changed","")).ToUpper() 来获取 FieldInfo
例如： GetField("EVENT_DROPDOWNSTYLE") 即可获取控件的DropDownStyleChanged事件委托字段
-- CheckBox Event Fields:
EVENT_DROPDOWN
EVENT_DRAWITEM
EVENT_MEASUREITEM
EVENT_SELECTEDINDEXCHANGED
EVENT_SELECTIONCHANGECOMMITTED
EVENT_SELECTEDITEMCHANGED
EVENT_DROPDOWNSTYLE
EVENT_TEXTUPDATE
EVENT_DROPDOWNCLOSED
-- Control Event Fields:
EventAutoSizeChanged
EventKeyDown
EventKeyPress
EventKeyUp
EventMouseDown
EventMouseEnter
EventMouseLeave
EventDpiChangedBeforeParent
EventDpiChangedAfterParent
EventMouseHover
EventMouseMove
EventMouseUp
EventMouseWheel
EventClick
EventClientSize
EventDoubleClick
EventMouseClick
EventMouseDoubleClick
EventMouseCaptureChanged
EventMove
EventResize
EventLayout
EventGotFocus
EventLostFocus
EventEnabledChanged
EventEnter
EventLeave
EventHandleCreated
EventHandleDestroyed
EventVisibleChanged
EventControlAdded
EventControlRemoved
EventChangeUICues
EventSystemColorsChanged
EventValidating
EventValidated
EventStyleChanged
EventImeModeChanged
EventHelpRequested
EventPaint
EventInvalidated
EventQueryContinueDrag
EventGiveFeedback
EventDragEnter
EventDragLeave
EventDragOver
EventDragDrop
EventQueryAccessibilityHelp
EventBackgroundImage
EventBackgroundImageLayout
EventBindingContext
EventBackColor
EventParent
EventVisible
EventText
EventTabStop
EventTabIndex
EventSize
EventRightToLeft
EventLocation
EventForeColor
EventFont
EventEnabled
EventDock
EventCursor
EventContextMenu
EventContextMenuStrip
EventCausesValidation
EventRegionChanged
EventMarginChanged
EventPaddingChanged
EventPreviewKeyDown

/// <summary>
/// 默认反射搜索方式标记
/// </summary>
internal const BindingFlags BindingFlagsDef =
    BindingFlags.Instance
    | BindingFlags.Static
    | BindingFlags.Public
    | BindingFlags.NonPublic
    | BindingFlags.GetField
    | BindingFlags.SetField
    | BindingFlags.GetProperty
    | BindingFlags.SetProperty
    ;
    
/// <summary>
/// 获取对象名称为 name 的 事件
/// </summary>
/// <param name="obj">对象</param>
/// <param name="name">名称</param>
/// <param name="bindingFlags">反射搜索方式标记</param>
/// <returns></returns>
public static EventInfo GetEvent(object obj, string name, BindingFlags bindingFlags = BindingFlagsDef)
{
    Type type = GetObjType(obj);
    try
    {
        EventInfo Event = bindingFlags.Equals(BindingFlagsDef) ? type.GetEvent(name) : type.GetEvent(name, bindingFlags);
        return Event;
    }
    catch(Exception ex)
    {
        ConsDebug.WriteErrorLog(ex,$"TypeProp.GetEvent({obj},{name},{bindingFlags})");
        return null;
    }
}    
/// <summary>
/// 获取事件的字段信息FieldInfo
/// </summary>
/// <param name="obj"></param>
/// <param name="name"></param>
/// <param name="bindingFlags"></param>
/// <returns></returns>
public static List<FieldInfo> GetEventFields(object obj, string name = "", BindingFlags bindingFlags = BindingFlagsDef)
{
    List<FieldInfo> fieldInfos = new List<FieldInfo>();
    if (GetEvent(obj, name) is EventInfo eventInfo)
    {
        string eventName = eventInfo.Name; 
        List<string> fields = new List<string>();
        foreach (string eName in new string[] {
            eventName,
            eventName.Replace("Changed","")
        })
        {
            fields.AddRange(new string[] {
                eName,
                $"Event{eName}",
                $"Event_{eName}",
                $"Event_{eName}".ToUpper()
            });
        }
        switch (eventName) 
        {
            case "TextChanged":
                fields.AddItem("EventText");
                break;
            case "SizeChanged":
                fields.AddItem("EventSize");
                break;
        }
        foreach (string field in fields)
        {
            //Console.WriteLine($"GetEventField-field:{field}");
            foreach (Type type in GetBaseTypes(obj))            // 遍历对象类型 以及 对象父类类型
            {
                if (type.GetField(field, bindingFlags) is FieldInfo fieldInfo)
                {
                    //Console.WriteLine($"GetEventField-fieldInfo:{fieldInfo.Name}");
                    fieldInfos.AddItem(fieldInfo);
                }
            }
        }
    }
    return fieldInfos;
}
/// <summary>
/// 读取对象指定名称对应的（事件）委托字典集合
/// </summary>
/// <param name="obj">对象</param>
/// <param name="name">名称</param>
/// <param name="bindingFlags">反射搜索方式标记</param>
/// <returns></returns>
public static Dictionary<string, Delegate> GetEventDelegate(object obj, string name = "", BindingFlags bindingFlags = BindingFlagsDef)
{
    if (obj is null)
        return null;
    Dictionary<string, Delegate> delegates = new Dictionary<string, Delegate>();
    Type type = GetObjType(obj);
    try
    {
        if (GetEvent(obj, name) is EventInfo eventInfo)
        {
            PropertyInfo eventPropInfo = type.GetProperty("Events", bindingFlags);          // 获取type类定义的所有事件的信息
            if (eventPropInfo?.GetValue(obj) is EventHandlerList eventHandlerList)          // 获取对象的事件处理程序列表
            {
                int addCount = 0;
                foreach (FieldInfo fieldInfo in GetEventFields(obj, name, bindingFlags) )   // 获取事件的字段信息
                {
                    object fieldVal = fieldInfo.GetValue(obj);
                    if (fieldVal != null && eventHandlerList[fieldVal] is Delegate deleg)
                    {
                        foreach (Delegate dele in deleg.GetInvocationList())
                        {
                            delegates.AddItem(eventInfo.Name, dele, AddMode.KeyIncrement);
                            addCount++;
                        }
                    }
                }
                if(addCount == 0)
                {
                    delegates.AddItem(eventInfo.Name, null, AddMode.KeyIncrement);
                }
            }
        }
    }
    catch(Exception ex)
    {
        ConsDebug.WriteErrorLog(ex, $"TypeProp.GetEventDelegate({obj},{name},{bindingFlags})");
    }
    if (name.IsNullOrEmpty())
    {
        foreach (EventInfo eventInfo in type.GetEvents())
        {
            delegates.AddRange(GetEventDelegate(obj, eventInfo.Name));
        }
    }
    return delegates;
}

/// <summary>
/// Dictionary扩展
/// </summary>
public static class DictionaryExtension
{
    /// <summary>
    /// 集合项添加模式枚举
    /// </summary>
    [Description("集合项添加模式枚举")]
    [Flags]
    public enum AddMode
    {
        /// <summary>
        /// 常规
        /// </summary>
        [Description("常规")]
        Normal = 0,
        /// <summary>
        /// 唯一（如果键值存在，则不添加）
        /// </summary>
        [Description("唯一（如果键值存在，则不添加）")]
        Unique = 2,
        /// <summary>
        /// 不为空（如果键值为空，则不添加）
        /// </summary>
        [Description("不为空（如果键值为空，则不添加）")]
        NonNull = 4,
        /// <summary>
        /// 不为空或空字符串（如果键值为空或空字符串，则不添加）
        /// </summary>
        [Description("不为空或空字符串（如果键值为空或空字符串，则不添加）")]
        NonNullOrEmpty = 8,
        /// <summary>
        /// 如果键值存在，则自动添加自增索引
        /// </summary>
        [Description("如果键值存在，则自动添加自增索引")]
        KeyIncrement = 16
    }
    internal static string AddModeKeyIncrementDelim = "-";
    /// <summary>
    /// 扩展：Dictionary AddItem 
    /// </summary>
    /// <param name="dictTarget">目标字典</param>
    /// <param name="key"></param>
    /// <param name="val"></param>
    /// <param name="addMode"></param>
    /// <param name="mode"></param>
    public static void AddItem<TKey,TValue>(this Dictionary<TKey, TValue> dictTarget, TKey key, TValue val, AddMode addMode = AddMode.Unique, int mode = 0)
    {
        try
        {
            if (dictTarget is null || key.IsNullOrEmpty() || key.IsNull())
                return;
            if (val.IsNull() && (addMode & AddMode.NonNull) is AddMode.NonNull)
                return;
            if (val.IsNullOrEmpty(true) && (addMode & AddMode.NonNullOrEmpty) is AddMode.NonNullOrEmpty)
                return;
            if (dictTarget.ContainsKey(key) && (addMode & AddMode.Unique) is AddMode.Unique)
                return;
            if (key is string && (addMode & AddMode.KeyIncrement) is AddMode.KeyIncrement)
            {
                int startsWithKey = 0;
                foreach (KeyValuePair<TKey, TValue> kvp in dictTarget)
                    if (kvp.Key.ToString().StartsWith(key.ToString()))
                        startsWithKey++;
                if (startsWithKey > 0)
                    key = $"{key}{AddModeKeyIncrementDelim}{startsWithKey}".ConvertTo<TKey>();
            }
            if (mode == 0)
            {
                //Console.WriteLine($"AddItem{mode} = ({key},{val})");
            }
            dictTarget.Add(key, val);
        }
        catch (Exception ex)
        {
            ConsDebug.WriteErrorLog(ex,$"DictionaryExtension.AddItem<{typeof(TKey)},{typeof(TValue)}>({dictTarget},{key},{val},{addMode})");
        }
    }
}