csharp: InvokeHelper

悠悠 2021-12-13 00:53 211阅读 0赞

Entity Framework

[https://entityframework.codeplex.com/][https_entityframework.codeplex.com]

Enterprise Library

[https://entlib.codeplex.com/][https_entlib.codeplex.com]

<?xml version="1.0"?>
    <configuration>
      
        <startup>         
        <supportedRuntime version="v2.0.50727"/></startup>
    </configuration>

App.config

using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Reflection;
    
    
    namespace InvokerHelperDemo
    {
        /// <summary>
        /// http://www.getcodesamples.com/src/E6947A0/4F02A4B8
        /// 
        /// </summary>
        public class Helpers
        {
            static private System.Collections.Generic.SortedDictionary<object, DuInvokeHelper> m_List = new SortedDictionary<object, DuInvokeHelper>();
            /// <summary>
            /// 
            /// </summary>
            /// <param name="Instance"></param>
            /// <param name="helper"></param>
            public static void AddHelper(object Instance, DuInvokeHelper helper)
            {
                m_List.Add(Instance, helper);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="Instance"></param>
            /// <returns></returns>
            public static DuInvokeHelper find(object Instance)
            {
                if (m_List.ContainsKey(Instance))
                    return m_List[Instance];
                else
                    return null;
            }
    
        }
        /// <summary>
        /// 
        /// </summary>
        public class DuInvokeHelper
        {
            static System.Collections.Generic.Dictionary<string, Type> Types = new Dictionary<string, Type>();
            protected object m_Instance;
            Type m_Type;
            /// <summary>
            /// 
            /// </summary>
            public object Instance
            {
                get
                {
                    return m_Instance;
                }
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="Instance"></param>
            public DuInvokeHelper(object Instance)
            {
                m_Instance = Instance;
                m_Type = Instance.GetType();
                //            Helpers.AddHelper(Instance, this);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="Instance"></param>
            /// <param name="type"></param>
            public DuInvokeHelper(object Instance, Type type)
            {
                m_Instance = Instance;
                m_Type = type;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="FieldName"></param>
            /// <returns></returns>
            public bool HasField(string FieldName)
            {
                foreach (FieldInfo field in m_Type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance))
                {
                    if (field.Name == FieldName)
                        return true;
                }
                return false;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="FieldName"></param>
            /// <returns></returns>
            public object GetProperty(string FieldName)
            {
                return m_Type.InvokeMember(FieldName,
                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty,
                    null, this.m_Instance, null);
    
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="FieldName"></param>
            /// <param name="Value"></param>
            /// <returns></returns>
            public object SetProperty(string FieldName, object Value)
            {
                return m_Type.InvokeMember(FieldName,
                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty,
                    null, this.m_Instance, new object[] { Value });
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="FieldName"></param>
            /// <param name="args"></param>
            /// <returns></returns>
            public object GetField(string FieldName, object[] args)
            {
                return m_Type.InvokeMember(FieldName,
                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetField,
                    null, this.m_Instance, args);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="FieldName"></param>
            /// <param name="args"></param>
            /// <returns></returns>
            public object SetField(string FieldName, object[] args)
            {
                return m_Type.InvokeMember(FieldName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetField, null, this.m_Instance, args);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="FieldName"></param>
            /// <param name="Value"></param>
            /// <returns></returns>
            public object SetField(string FieldName, object Value)
            {
                return SetField(FieldName, new object[] { Value });
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="PropertyName"></param>
            /// <returns></returns>
            public object StaticGetProperty(string PropertyName)
            {
                return m_Type.InvokeMember(PropertyName,
                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.GetProperty,
                    null, null, null);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="args"></param>
            /// <returns></returns>
            public object CreateInstance(object[] args)
            {
                return null;
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="FieldName"></param>
            /// <returns></returns>
            public object GetField(string FieldName)
            {
                return GetField(FieldName, null);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="args"></param>
            /// <param name="modifiers"></param>
            /// <returns></returns>
            public object InvokeByRef(string MethodName, ref object[] args, ParameterModifier modifiers)
            {
                ParameterModifier[] mod = { modifiers };
    
                return m_Type.InvokeMember(MethodName,
                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod,
                    null, m_Instance, args, mod, null, null);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="args"></param>
            /// <param name="modifiers"></param>
            /// <returns></returns>
            public object InvokeByOut(string MethodName, object[] args, ParameterModifier modifiers)
            {
                ParameterModifier[] mod = { modifiers };
    
                return m_Type.InvokeMember(MethodName,
                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod,
                    null, m_Instance, args, mod, null, null);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="args"></param>
            /// <returns></returns>
            public object Invoke(string MethodName, object[] args)
            {
                return m_Type.InvokeMember(MethodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, m_Instance, args);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="args"></param>
            /// <returns></returns>
            public object InvokeStatic(string MethodName, object[] args)
            {
                return m_Type.InvokeMember(MethodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, args);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="arg1"></param>
            /// <param name="arg2"></param>
            /// <returns></returns>
            public object InvokeStatic(string MethodName, object arg1, object arg2)
            {
                return InvokeStatic(MethodName, new object[] { arg1, arg2 });
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="arg1"></param>
            /// <returns></returns>
            public object InvokeStatic(string MethodName, object arg1)
            {
                return InvokeStatic(MethodName, new object[] { arg1 });
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <returns></returns>
            public object InvokeStatic(string MethodName)
            {
                return InvokeStatic(MethodName, null);
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <returns></returns>
            public object Invoke(string MethodName)
            {
                return Invoke(MethodName, null);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="arg1"></param>
            /// <returns></returns>
            public object Invoke(string MethodName, object arg1)
            {
                return Invoke(MethodName, new object[] { arg1 });
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="arg1"></param>
            /// <returns></returns>
            public object Invoke(string MethodName, int arg1)
            {
                return Invoke(MethodName, new object[] { arg1 });
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="obj1"></param>
            /// <param name="obj2"></param>
            /// <returns></returns>
            public object Invoke(string MethodName, object obj1, object obj2)
            {
                return Invoke(MethodName, new object[] { obj1, obj2 });
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="MethodName"></param>
            /// <param name="obj1"></param>
            /// <param name="obj2"></param>
            /// <param name="obj3"></param>
            /// <returns></returns>
            public object Invoke(string MethodName, object obj1, object obj2, object obj3)
            {
                return Invoke(MethodName, new object[] { obj1, obj2, obj3 });
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="TypeName"></param>
            /// <returns></returns>
            public static Type FindType(string TypeName)
            {
                if (Types.ContainsKey(TypeName))
                    return Types[TypeName];
                Type ret = null;
                foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
                {
                    foreach (Module module in assembly.GetModules())
                    {
                        foreach (Type type in module.GetTypes())
                        {
                            if (type.FullName == TypeName)
                            {
                                ret = type;
                                Types.Add(TypeName, ret);
                                return ret;
                            }
                        }
                    }
    
                }
                Types.Add(TypeName, ret);
    
                return ret;
    
    
            }
    
    
    
        }
      
    }

/*******************************************************************************
     * InvokeHelper.cs
     * A thread-safe control invoker helper class.
     * -----------------------------------------------------------------------------
     * Project:Conmajia.Controls
     * Author:Conmajia
     * Url:conmajia@gmail.com
     * History:
     *      4th Aug., 2012
     *      Added support for "Non-control" controls (such as ToolStripItem).
     *      
     *      4th Aug., 2012
     *      Initiated.
     ******************************************************************************/
    using System;
    using System.Collections.Generic;
    using System.Reflection;
    using System.Text;
    using System.Windows.Forms;
    
    namespace InvokerHelperDemo
    {
        /// <summary>
        /// A thread-safe control invoker helper class.
        /// 善用IAsyncResult
        /// 利用BeginInvoke与EndInvoke完成异步委托方法
        /// 线程Thread有一个属性IsBackground，通过把此属性设置为true，就可以把线程设置为后台线程
        /// </summary>
        public class InvokeHelper
        {
            #region delegates
            private delegate object MethodInvoker(Control control, string methodName, params object[] args);
    
            private delegate object PropertyGetInvoker(Control control, object noncontrol, string propertyName);
            private delegate void PropertySetInvoker(Control control, object noncontrol, string propertyName, object value);
            #endregion
    
            #region static methods
            /// <summary>
            ///  helpers
            /// </summary>
            /// <param name="control"></param>
            /// <param name="noncontrol"></param>
            /// <param name="propertyName"></param>
            /// <returns></returns>
            private static PropertyInfo GetPropertyInfo(Control control, object noncontrol, string propertyName)
            {
                if (control != null && !string.IsNullOrEmpty(propertyName))
                {
                    PropertyInfo pi = null;
                    Type t = null;
    
                    if (noncontrol != null)
                        t = noncontrol.GetType();
                    else
                        t = control.GetType();
    
                    pi = t.GetProperty(propertyName);
    
                    if (pi == null)
                        throw new InvalidOperationException(
                            string.Format(
                            "Can't find property {0} in {1}.",
                            propertyName,
                            t.ToString()
                            ));
    
                    return pi;
                }
                else
                    throw new ArgumentNullException("Invalid argument.");
            }
    
            /// <summary>
            ///  outlines
            /// </summary>
            /// <param name="control"></param>
            /// <param name="methodName"></param>
            /// <param name="args"></param>
            /// <returns></returns>
            public static object Invoke(Control control, string methodName, params object[] args)
            {
                if (control != null && !string.IsNullOrEmpty(methodName))
                    if (control.InvokeRequired)
                        return control.Invoke(
                            new MethodInvoker(Invoke),
                            control,
                            methodName,
                            args
                            );
                    else
                    {
                        MethodInfo mi = null;
    
                        if (args != null && args.Length > 0)
                        {
                            Type[] types = new Type[args.Length];
                            for (int i = 0; i < args.Length; i++)
                            {
                                if (args[i] != null)
                                    types[i] = args[i].GetType();
                            }
    
                            mi = control.GetType().GetMethod(methodName, types);
                        }
                        else
                            mi = control.GetType().GetMethod(methodName);
    
                        // check method info you get
                        if (mi != null)
                            return mi.Invoke(control, args);
                        else
                            throw new InvalidOperationException("Invalid method.");
                    }
                else
                    throw new ArgumentNullException("Invalid argument.");
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="control"></param>
            /// <param name="propertyName"></param>
            /// <returns></returns>
            public static object Get(Control control, string propertyName)
            {
                return Get(control, null, propertyName);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="control"></param>
            /// <param name="noncontrol"></param>
            /// <param name="propertyName"></param>
            /// <returns></returns>
            public static object Get(Control control, object noncontrol, string propertyName)
            {
                if (control != null && !string.IsNullOrEmpty(propertyName))
                    if (control.InvokeRequired)
                        return control.Invoke(new PropertyGetInvoker(Get),
                            control,
                            noncontrol,
                            propertyName
                            );
                    else
                    {
                        PropertyInfo pi = GetPropertyInfo(control, noncontrol, propertyName);
                        object invokee = (noncontrol == null) ? control : noncontrol;
    
                        if (pi != null)
                            if (pi.CanRead)
                                return pi.GetValue(invokee, null);
                            else
                                throw new FieldAccessException(
                                    string.Format(
                                    "{0}.{1} is a write-only property.",
                                    invokee.GetType().ToString(),
                                    propertyName
                                    ));
    
                        return null;
                    }
                else
                    throw new ArgumentNullException("Invalid argument.");
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="control"></param>
            /// <param name="propertyName"></param>
            /// <param name="value"></param>
            public static void Set(Control control, string propertyName, object value)
            {
                Set(control, null, propertyName, value);
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="control"></param>
            /// <param name="noncontrol"></param>
            /// <param name="propertyName"></param>
            /// <param name="value"></param>
            public static void Set(Control control, object noncontrol, string propertyName, object value)
            {
                if (control != null && !string.IsNullOrEmpty(propertyName))
                    if (control.InvokeRequired)
                        control.Invoke(new PropertySetInvoker(Set),
                            control,
                            noncontrol,
                            propertyName,
    
                            value
                            );
                    else
                    {
                        PropertyInfo pi = GetPropertyInfo(control, noncontrol, propertyName);
                        object invokee = (noncontrol == null) ? control : noncontrol;
    
                        if (pi != null)
                            if (pi.CanWrite)
                                pi.SetValue(invokee, value, null);
                            else
                                throw new FieldAccessException(
                                    string.Format(
                                    "{0}.{1} is a read-only property.",
                                    invokee.GetType().ToString(),
                                    propertyName
                                    ));
                    }
                else
                    throw new ArgumentNullException("Invalid argument.");
            }
            #endregion
        }
    }

用例：

using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Text;
    using System.Threading;
    using System.Windows.Forms;
    
    namespace InvokerHelperDemo
    {
        /// <summary>
        /// 
        /// </summary>
        public partial class Form1 : Form
        {
    
            /// <summary>
            /// 
            /// </summary>
            /// <returns></returns>
            DataTable setData()
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("id", typeof(int));
                dt.Columns.Add("name", typeof(string));
                dt.Columns.Add("date", typeof(DateTime));
                dt.Rows.Add(1,"ds","2015-01-02");
                dt.Rows.Add(2, "sb", "2015-01-02");
                dt.Rows.Add(3, "sg", "2015-01-02");
                return dt;
    
            }
    
    
            /// <summary>
            /// 
            /// </summary>
            public Form1()
            {
                InitializeComponent();
            }
    
            Thread t;
            /// <summary>
            /// 
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void button1_Click(object sender, EventArgs e)
            {
                if (t == null)
                {
                    t = new Thread(multithread);
                    t.Start();
                    label4.Text = string.Format(
                        "Thread state:\n{0}",
                        t.ThreadState.ToString()
                        );
                }
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="msg"></param>
            public void DoWork(string msg)
            {
                this.label3.Text = string.Format("Invoke method: {0}", msg);
            }
            //
            int count = 0;
            /// <summary>
            /// 
            /// </summary>
            void multithread()
            {
                //while (true)
                //{
                    
                    InvokeHelper.Set(this.label1, "Text", string.Format("Set value: {0}", count));
                    InvokeHelper.Set(this.label1, "Tag", count);
                    InvokeHelper.Set(this.dataGridView1, "DataSource", setData());
                    string value = InvokeHelper.Get(this.label1, "Tag").ToString();
                    InvokeHelper.Set(this.label2, "Text",
                       string.Format("Get value: {0}", value));
    
                    InvokeHelper.Invoke(this, "DoWork", value);
    
                    Thread.Sleep(500);
                    count++;
                //}
    
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void Form1_FormClosed(object sender, FormClosedEventArgs e)
            {
                if (t != null && t.IsAlive)
                    t.Abort();
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void Form1_Load(object sender, EventArgs e)
            {
    
            }
        }
    }

http://www.codeproject.com/Articles/29680/Towards-Cleaner-Code-A-C-Asynchronous-Helper

http://www.codeproject.com/Articles/29829/Towards-Cleaner-Code-II-a-C-GUI-Invoke-Async-Helpe

http://www.codeproject.com/Articles/10346/Remoting-with-GUIs

转载于:https://www.cnblogs.com/geovindu/p/4914082.html

[https_entityframework.codeplex.com]: http://www.cnblogs.com/Entity%20Framework%20%20%20https:/entityframework.codeplex.com/
[https_entlib.codeplex.com]: https://entlib.codeplex.com/