/// <summary>
/// 字典转换为对象
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <typeparam name="ValueT">字典值类型</typeparam>
/// <param name="dic">字典</param>
/// <returns>对象</returns>
public static T ToObject <T, ValueT>(this IDictionary <string, ValueT> dic)
{
if (dic.IsNullOrCount0())
{
return(default(T));
}
Type type = typeof(T);
PropertyInfo[] properties = type.GetProperties();
if (properties.IsNullOrLength0())
{
return(default(T));
}
T instance = (T)type.Assembly.CreateInstance(type.FullName);
foreach (KeyValuePair <string, ValueT> keyValue in dic)
{
foreach (PropertyInfo property in properties)
{
if (string.Compare(keyValue.Key, property.Name, true) != 0 || keyValue.Value == null)
{
continue;
}
ReflectExtensions.SetPropertyValue(property, instance, keyValue.Value);
break;
}
}
return(instance);
}
/// <summary>
/// 执行
/// </summary>
/// <param name="key">键</param>
/// <param name="parames">参数数组</param>
/// <returns>返回值</returns>
public virtual object Invoke(string key, params object[] parames)
{
if (dicCaches.ContainsKey(key))
{
return(Get(key).Invoke(null, parames));
}
else
{
string fullName = null;
if (dicClasses == null)
{
var tempDicClasses = readerConfig.Reader();
if (tempDicClasses != null)
{
lock (syncDicCaches)
{
dicClasses = tempDicClasses;
}
fullName = dicClasses[key];
}
}
else
{
fullName = dicClasses[key];
}
MethodInfo method;
var re = ReflectExtensions.InvokeStaticMethod(fullName, out method, parames);
Set(key, method);
return(re);
}
}
/// <summary>
/// 开始
/// </summary>
/// <param name="programStartInfos">程序启动信息集合</param>
public static void Start(ProgramStartInfo[] programStartInfos = null)
{
if (programStartInfos == null)
{
if (ProgramConfigReader == null)
{
return;
}
programStartInfos = ProgramConfigReader.Reader();
}
if (programStartInfos.IsNullOrLength0())
{
return;
}
IProgramStart[] programStarts = new IProgramStart[programStartInfos.Length];
for (int i = 0; i < programStarts.Length; i++)
{
programStarts[i] = ReflectExtensions.CreateInstance <IProgramStart>(programStartInfos[i].FullClass);
}
for (int i = 0; i < programStarts.Length; i++)
{
programStarts[i].Start(programStartInfos[i].Args);
}
}
/// <summary>
/// 执行
/// </summary>
/// <param name="fullPath">全路径</param>
/// <param name="method">方法</param>
/// <param name="parames">参数数组</param>
/// <returns>返回值</returns>
public virtual object Invoke(string fullPath, out MethodInfo method, params object[] parames)
{
string classFullPath;
string methodName = ReflectExtensions.GetMethodName(fullPath, out classFullPath);
if (dicCaches.ContainsKey(classFullPath))
{
var insMapMethod = dicCaches[classFullPath];
method = insMapMethod.GetMethodByName(methodName);
if (method == null)
{
method = insMapMethod.Instance.GetType().GetMethod(methodName);
insMapMethod.Methods.Add(method);
}
AutoEqualMethodParams(method, parames);
return(method.Invoke(insMapMethod.Instance, parames));
}
else
{
var insMapMethod = new InstanceMapMethodsInfo()
{
Instance = Instance.CreateInstance(classFullPath)
};
method = insMapMethod.Instance.GetType().GetMethod(methodName);
insMapMethod.Methods.Add(method);
Set(classFullPath, insMapMethod);
AutoEqualMethodParams(method, parames);
return(method.Invoke(insMapMethod.Instance, parames));
}
}
/// <summary>
/// 用DI批量注入批定接口类型的实现类程序集中的实现类
/// </summary>
/// <param name="service">服务收藏</param>
/// <param name="interfaceType">接口类型</param>
/// <param name="lifecycle">生命周期，默认为瞬时</param>
/// <param name="implClassAssemblys">接口程序集的名称（不包含文件扩展名）</param>
/// <returns>服务收藏</returns>
public static IServiceCollection RegisterAssemblyWithInterfaceMapImpls(this IServiceCollection service, Type interfaceType,
ServiceLifetime lifecycle = ServiceLifetime.Transient, params string[] implClassAssemblys)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (implClassAssemblys.IsNullOrLength0())
{
throw new ArgumentNullException(nameof(implClassAssemblys));
}
Assembly[] assemblies = new Assembly[implClassAssemblys.Length];
for (var i = 0; i < implClassAssemblys.Length; i++)
{
assemblies[i] = Assembly.Load(implClassAssemblys[i]);
}
var implTypes = ReflectExtensions.GetImplClassType(assemblies, interfaceType);
if (implTypes.IsNullOrLength0())
{
return(service);
}
foreach (var it in implTypes)
{
if (it.IsAbstract)
{
continue;
}
switch (lifecycle)
{
case ServiceLifetime.Transient:
service.AddTransient(interfaceType, it);
break;
case ServiceLifetime.Scoped:
service.AddScoped(interfaceType, it);
break;
case ServiceLifetime.Singleton:
service.AddSingleton(interfaceType, it);
break;
default:
throw new NotSupportedException($"不支持的生命周期:{lifecycle}");
}
}
return(service);
}
/// <summary>
/// 自动找出实现IAutoMapperConfig接口的配置
/// </summary>
/// <param name="assemblies">程序集数组</param>
public static void AutoRegisterConfig(Assembly[] assemblies)
{
var types = ReflectExtensions.GetImplClassType(assemblies, typeof(IAutoMapperConfig));
if (types.IsNullOrLength0())
{
return;
}
foreach (var t in types)
{
var config = t.Assembly.CreateInstance(t.FullName) as IAutoMapperConfig;
mapperConfigs.Add(config);
}
}
/// <summary>
/// 监听
/// </summary>
public void Listen()
{
RpcServer.Receive(inData =>
{
object result = null;
try
{
var rpcDataInfo = BytesSerialization.Deserialize <RpcDataInfo>(inData);
if (rpcDataInfo == null)
{
OnReceivingError("传过来的数据不是RpcDataInfo类型的");
}
else if (string.IsNullOrWhiteSpace(rpcDataInfo.MethodFullPath))
{
OnReceivingError("方法全路径不能为空");
}
else
{
string classFullName;
var methodName = ReflectExtensions.GetMethodName(rpcDataInfo.MethodFullPath, out classFullName);
var implClassFullName = InterfaceMapImpl.Reader(classFullName);
MethodInfo method;
var methodReturnValue = MethodCall.Invoke(string.Format("{0}.{1}", implClassFullName, methodName), out method, rpcDataInfo.MethodParams);
// 如果方法返回是Void，则直接返回null
if (method.IsMethodReturnVoid())
{
return(null);
} // 如果方法是异步方法，则转换为Task并等待执行结束后返回Result给客户端
else if (method.ReturnType.IsTypeTask())
{
// 如果带泛型，则返回任务的Result给客户端
if (method.ReturnType.IsTypeGenericityTask())
{
var resultProperty = method.ReturnType.GetProperty("Result");
result = resultProperty.GetValue(methodReturnValue);
}
else
{
var methodReturnTask = methodReturnValue as Task;
methodReturnTask.Wait();
}
}
else
{
result = methodReturnValue;
}
}
if (result == null)
{
return(null);
}
return(BytesSerialization.Serialize(result));
}
catch (Exception ex)
{
try
{
OnReceivingError(ex.Message, ex);
}
catch { }
return(null);
}
});
}
/// <summary>
/// 创建实例对象
/// </summary>
/// <param name="classFullPath">类全路径</param>
/// <returns>实例</returns>
private object CreateInstanceObj(string classFullPath)
{
return(AutofacTool.Resolve(ReflectExtensions.GetClassType(classFullPath)));
}
/// <summary>
/// 将列表转换为数据表
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="dataTable">数据表</param>
/// <param name="eachRowFun">循环每一行的回调</param>
/// <returns>列表</returns>
public static IList <T> ToList <T>(this DataTable dataTable, Func <T, DataRow, int, bool> eachRowFun = null)
{
if (dataTable == null)
{
return(null);
}
IList <T> list = new List <T>(dataTable.Rows.Count);
if (dataTable.Rows.Count == 0)
{
return(list);
}
Type type = typeof(T);
PropertyInfo[] propertys = type.GetProperties();
if (propertys == null || propertys.Length == 0)
{
return(list);
}
int rowNumber = 1;
foreach (DataRow row in dataTable.Rows)
{
T instance = (T)type.Assembly.CreateInstance(type.FullName);
// 取出每个属性的特性
foreach (PropertyInfo property in propertys)
{
if (property.CanWrite)
{
DisplayAttribute displayAttribute = property.GetCustomAttribute <DisplayAttribute>();
IConvertable convert = null;
DisplayValueConvertAttribute displayValueConvertAttribute = property.GetCustomAttribute <DisplayValueConvertAttribute>();
if (displayValueConvertAttribute != null)
{
convert = displayValueConvertAttribute.TextToValueConvert;
}
string name = displayAttribute == null || string.IsNullOrWhiteSpace(displayAttribute.Name) ? property.Name : displayAttribute.Name;
if (dataTable.Columns.Contains(name))
{
object tableValue = row[name];
object value = convert == null ? tableValue : convert.To(tableValue);
if (value == null)
{
continue;
}
ReflectExtensions.SetPropertyValue(property, instance, value);
}
}
}
if (eachRowFun != null && !eachRowFun(instance, row, rowNumber))
{
return(null);
}
list.Add(instance);
rowNumber++;
}
return(list);
}
/// <summary>
/// 统一注册服务程序集
/// </summary>
/// <param name="containerBuilder">容器生成器</param>
/// <param name="param">参数</param>
/// <param name="isExecBuilderContainer">是否执行生成容器，如果为false，则返回值为null</param>
/// <returns>容器</returns>
public static IContainer UnifiedRegisterAssemblys(this ContainerBuilder containerBuilder, BuilderParam param, bool isExecBuilderContainer = true)
{
var assemblyList = new List <Assembly>();
foreach (var assembly in param.AssemblyServices)
{
Assembly[] assemblies = ReflectExtensions.Load(assembly.Names);
if (assemblies.IsNullOrLength0())
{
return(null);
}
assemblyList.AddRange(assemblies);
var registerBuilder = containerBuilder.RegisterAssemblyTypes(assemblies)
.PropertiesAutowired()
.AsImplementedInterfaces()
.Where(AutofacUtil.CanInject)
.AsSelf();
if (!assembly.InterceptedTypes.IsNullOrLength0())
{
foreach (Type type in assembly.InterceptedTypes)
{
containerBuilder.RegisterType(type);
}
registerBuilder.InterceptedBy(assembly.InterceptedTypes).EnableClassInterceptors();
}
switch (assembly.Lifecycle)
{
case LifecycleType.DEPENDENCY:
registerBuilder.InstancePerDependency();
break;
case LifecycleType.LIFETIME_SCOPE:
registerBuilder.InstancePerLifetimeScope();
break;
case LifecycleType.MATCH_LIFETIME_SCOPE:
registerBuilder.InstancePerMatchingLifetimeScope(assembly.MatchTagNames);
break;
case LifecycleType.REQUEST:
registerBuilder.InstancePerRequest();
break;
case LifecycleType.SIGNLETON:
registerBuilder.SingleInstance();
break;
}
}
if (param.RegisteringServiceAction != null)
{
param.RegisteringServiceAction();
}
if (isExecBuilderContainer)
{
AutofacTool.Container = containerBuilder.Build();
}
else
{
containerBuilder.RegisterBuildCallback(scope =>
{
AutofacTool.LifetimeScope = scope;
});
}
if (param.IsLoadAutoMapperConfig)
{
AutoMapperUtil.AutoRegisterConfig(assemblyList.ToArray());
}
return(AutofacTool.Container);
}
/// <summary>
/// 创建实例
/// </summary>
/// <typeparam name="T">实例类型</typeparam>
/// <param name="classFullPath">类全路径</param>
/// <returns>实例</returns>
public T CreateInstance <T>(string classFullPath)
where T : class
{
return(ReflectExtensions.CreateInstance <T>(classFullPath));
}
/// <summary>
/// 创建实例
/// </summary>
/// <param name="classFullPath">类全路径</param>
/// <returns>实例</returns>
public object CreateInstance(string classFullPath)
{
return(ReflectExtensions.CreateInstance(classFullPath));
}
/// <summary>
/// 读取
/// </summary>
/// <param name="key">键，接口全路径，包含接口的程序集名，比如：Hzdtf.Contract,Hzdtf.Contract.ITestable</param>
/// <returns>值，接口对应的实现类名，比如：Hzdtf.Impl,Hzdtf.Impl.Test</returns>
public string Reader(string key)
{
if (dicCaches.ContainsKey(key))
{
return(dicCaches[key]);
}
else
{
var dicMap = readerConfig.Reader();
if (dicMap.IsNullOrCount0())
{
throw new Exception("找不到任何程序集的配置");
}
// 获取接口程序集
string interfaceAssemblyName;
var interfaceClassFullName = ReflectExtensions.GetClassAndAssemblyFullName(key, out interfaceAssemblyName);
if (string.IsNullOrWhiteSpace(interfaceAssemblyName))
{
throw new Exception($"[{key}]的接口程序集不能为空");
}
var interfaceAssembly = ReflectExtensions.GetAssembly(interfaceAssemblyName);
if (interfaceAssembly == null)
{
throw new Exception($"找不到[{interfaceAssemblyName}]的接口程序集");
}
Type interfaceType = interfaceAssembly.GetType(interfaceClassFullName);
if (interfaceType == null)
{
throw new Exception($"找不到[{interfaceClassFullName}]的接口类型");
}
// 找到对应的实现程序集
if (dicMap.ContainsKey(interfaceAssemblyName))
{
var implAssemblyName = dicMap[interfaceAssemblyName];
var implAssembly = ReflectExtensions.GetAssembly(implAssemblyName);
if (implAssembly == null)
{
throw new Exception($"[{interfaceAssemblyName}]的对应的实现程序集");
}
var implType = implAssembly.GetTypes().Where(t => t.IsClass && t.IsPublic && interfaceType.IsAssignableFrom(t)).FirstOrDefault();
if (implType == null)
{
throw new Exception($"[{interfaceClassFullName}]的对应的实现类");
}
var implFullName = $"{implAssemblyName},{implType.FullName}";
Set(key, implFullName);
return(implFullName);
}
else
{
throw new Exception($"找不到[{interfaceAssemblyName}]的接口程序集的配置");
}
}
throw new Exception($"找不到[{key}]对应的实现类");
}
