自定义工厂类

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
namespace LYZB.ApiConfig
{
    /// <summary>
    /// 自定义工厂类
    /// </summary>
    /// <typeparam name="T">泛型</typeparam>
    public abstract class AssesUtil<T> where T : class,new()
    {
        /// <summary>
        /// 缓存集合
        /// </summary>
        private static Hashtable hash = Hashtable.Synchronized(new Hashtable());
        /// <summary>
        /// 执行实例方法
        /// </summary>
        /// <param name="FunName">方法名</param>
        /// <param name="type">参数类型</param>
        /// <param name="arg">参数实体</param>
        /// <returns></returns>
        public static object Invoke(string FunName, Type[] type, params object[] arg)
        {
            object result = null;
            try
            {
                Type types = typeof(T);
                var classname = types.Namespace + "." + types.Name;
                MethodInfo method = types.GetMethod(FunName, type);
                if (hash[classname] != null)
                {
                    result = method.Invoke(hash[classname], arg);
                }
                else
                {
                    var func = Activator.CreateInstance(types);
                    result = method.Invoke(func, arg);
                    hash[classname] = func;
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            return result;
        }
        /// <summary>
        /// 高并发执行方法
        /// </summary>
        /// <param name="FunName">方法名</param>
        /// <param name="type">参数类型</param>
        /// <param name="arg">参数</param>
        /// <returns>OBJECT</returns>
        public static object InvokeConcurrent(string FunName, Type[] type, params object[] arg)
        {
            object result = null;
            Type types = typeof(T);
            String Key = types.Namespace + "." + types.Name + "." + FunName;
            String parm_key = "";
            try
            {
                for (int i = 0; i < type.Length; i++)
                {
                    parm_key += type[i].Name + "_" + arg[i] + "_";
                }
                Key = Key +":"+ parm_key.TrimEnd('_');
                //二级缓存处理
                if (Cache.GetData(Key) != null)
                {
                    result = Cache.GetData(Key);
                }
                else
                {
                    Object Odata = Invoke(FunName, type, arg);
                    if (Odata != null)
                    {
                        Cache.Add(Key, Odata, TimeSpan.FromSeconds(1));
                    }
                    result = Odata;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return result;
        }
        /// <summary>
        /// 获取单个类实列
        /// </summary>
        /// <returns></returns>
        public static T GetInstance()
        {
            T result = default(T);
            try
            {
                //获得泛型类的对象类型
                Type type = typeof(T);
                var classname = type.Namespace + "." + type.Name;
                if (hash[classname] != null)
                {
                    result = hash[classname] as T;
                }
                else
                {   //根据对象的类型创建对象的实例
                    result = Activator.CreateInstance(type) as T;
                    hash[classname] = result;
                }
            }
            catch (Exception error)
            {
                throw error;
            }
            return result;
        }
    }
}