private static void GetProcessors() { try { ManagementObjectSearcher myProcessorObject = new ManagementObjectSearcher("select * from Win32_Processor"); foreach (ManagementObject obj in myProcessorObject.Get()) { Console.WriteLine("Name - " + obj["Name"]); Console.WriteLine("DeviceID - " + obj["DeviceID"]); Console.WriteLine("CurrentClockSpeed - " + obj["CurrentClockSpeed"]); Console.WriteLine("NumberOfCores - " + obj["NumberOfCores"]); Console.WriteLine("NumberOfEnabledCore - " + obj["NumberOfEnabledCore"]); Console.WriteLine("NumberOfLogicalProcessors - " + obj["NumberOfLogicalProcessors"]); Console.WriteLine("AddressWidth - " + obj["AddressWidth"]); var data = new ProcessorData() { Name = obj["Name"].ToString(), DeviceId = obj["DeviceID"].ToString(), CurrentClockSpeed = obj["CurrentClockSpeed"].ToString(), NumberOfCores = obj["NumberOfCores"].ToString(), NumberOfEnabledCores = obj["NumberOfEnabledCore"].ToString(), NumberOfLogicalProcessors = obj["NumberOfLogicalProcessors"].ToString(), AddressWidth = obj["AddressWidth"].ToString() }; _AssetDataService.CreateProcessorData(_MachineData.Id, data); } } catch (Exception e) { _AssetDataService.CreateError(_MachineData.Id, "GetProcessors", e); } }
public bool MoveNext(IEnumerator enumerator) { bool advance = false; switch (data.type) { case DataType.WaitForSeconds: advance = data.targetTime <= EditorApplication.timeSinceStartup; break; case DataType.EditorCoroutine: advance = (data.current as EditorCoroutine).isDone; break; case DataType.AsyncOp: advance = (data.current as AsyncOperation).isDone; break; default: advance = data.current == enumerator.Current; break; } if (advance) { data = default; return(enumerator.MoveNext()); } return(true); }
public void Set(object yield) { if (yield == data.current) { return; } var type = yield.GetType(); var dataType = DataType.None; double targetTime = -1; if (type == typeof(EditorWaitForSeconds)) { targetTime = EditorApplication.timeSinceStartup + (yield as EditorWaitForSeconds).WaitTime; dataType = DataType.WaitForSeconds; } else if (type == typeof(EditorCoroutine)) { dataType = DataType.EditorCoroutine; } else if (type == typeof(AsyncOperation) || type.IsSubclassOf(typeof(AsyncOperation))) { dataType = DataType.AsyncOp; } data = new ProcessorData { current = yield, targetTime = targetTime, type = dataType }; }
public bool MoveNext(IEnumerator enumerator) { bool advance = false; switch (data.type) { case DataType.WaitForSeconds: advance = data.targetTime <= EditorApplication.timeSinceStartup; break; case DataType.EditorCoroutine: advance = (data.current as EditorCoroutine).m_IsDone; break; case DataType.AsyncOP: advance = (data.current as AsyncOperation).isDone; break; default: advance = data.current == enumerator.Current; //a IEnumerator or a plain object was passed to the implementation break; } if (advance) { data = default(ProcessorData); return(enumerator.MoveNext()); } return(true); }
public void CreateProcessorData(int probeDataId, ProcessorData data) { data.ProbeDataId = probeDataId; data.CreatedOn = DateTime.UtcNow; _Context.ProcessorData.Add(data); _Context.SaveChanges(); }
/// <summary> /// 创建指定类型中与默认标识相关的静态方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// <typeparam name="TDelegate">使用基类型调用方法的委托。</typeparam> /// <param name="type">在其中查找静态方法的类型。</param> /// <returns><paramref name="type"/> 中与默认标识相关的静态方法切换器。</returns> /// <exception cref="ArgumentNullException"><paramref name="type"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentException"><typeparamref name="TDelegate"/> 不是委托类型。</exception> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> /// <exception cref="ArgumentException">处理器的参数不匹配。</exception> /// <exception cref="ArgumentException">没有找到唯一的关键参数。</exception> public static TDelegate Create <TDelegate>(Type type) where TDelegate : class { CommonExceptions.CheckArgumentNull(type, "type"); Contract.Ensures(Contract.Result <TDelegate>() != null); CommonExceptions.CheckDelegateType(typeof(TDelegate)); ProcessorData data = GetMethods <TDelegate>(type, ProcessorAttribute.DefaultId, true); return(CreateSwitcher <TDelegate>(data, ProcessorAttribute.DefaultId, null)); }
/// <summary> /// 创建指定对象中与默认指定相关的实例方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// <typeparam name="TDelegate">使用基类型调用方法的委托。</typeparam> /// <param name="target">在其中查找实例方法的对象。</param> /// <returns><paramref name="target"/> 中与默认标识相关的实例方法切换器。</returns> /// <exception cref="ArgumentNullException"><paramref name="target"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentException"><typeparamref name="TDelegate"/> 不是委托类型。</exception> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> /// <exception cref="ArgumentException">处理器的参数不匹配。</exception> /// <exception cref="ArgumentException">没有找到唯一的关键参数。</exception> public static TDelegate Create <TDelegate>(object target) where TDelegate : class { CommonExceptions.CheckArgumentNull(target, "target"); Contract.Ensures(Contract.Result <TDelegate>() != null); CommonExceptions.CheckDelegateType(typeof(TDelegate)); ProcessorData data = GetMethods <TDelegate>(target.GetType(), ProcessorAttribute.DefaultId, false); return(CreateSwitcher <TDelegate>(data, ProcessorAttribute.DefaultId, target)); }
/// <summary> /// 创建指定类型中与标识指定相关的静态方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// <typeparam name="TDelegate">使用基类型调用方法的委托。</typeparam> /// <param name="type">在其中查找静态方法的类型。</param> /// <param name="id">处理器的标识。</param> /// <returns><paramref name="type"/> 中与指定标识相关的静态方法切换器。</returns> /// <exception cref="ArgumentNullException"><paramref name="type"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentNullException"><paramref name="id"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentException"><paramref name="id"/> 为空字符串。</exception> /// <exception cref="ArgumentException"><typeparamref name="TDelegate"/> 不是委托类型。</exception> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> /// <exception cref="ArgumentException">处理器的参数不匹配。</exception> /// <exception cref="ArgumentException">没有找到唯一的关键参数。</exception> public static TDelegate Create <TDelegate>(Type type, string id) where TDelegate : class { CommonExceptions.CheckArgumentNull(type, "type"); CommonExceptions.CheckStringEmpty(id, "id"); Contract.Ensures(Contract.Result <TDelegate>() != null); CommonExceptions.CheckDelegateType(typeof(TDelegate)); ProcessorData data = GetMethods <TDelegate>(type, id, true); return(CreateSwitcher <TDelegate>(data, id, null)); }
public void SetProperty(ProcessorData processor, object value) { try { this.Property.Invoke(processor, new[] { value }); } catch (Exception ex) { WFLogger.NLogger.ErrorException("Invoke failed", ex); } }
/// <summary> /// 创建与指定委托列表相关的方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// <typeparam name="TDelegate">使用基类型调用方法的委托类型。</typeparam> /// <param name="delegates">使用不同子类作为参数的委托列表。</param> /// <returns>与 <paramref name="delegates"/> 相关的方法切换器。</returns> /// <exception cref="ArgumentNullException"><paramref name="delegates"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentException"><paramref name="delegates"/> 中存在为 <c>null</c> 的委托。</exception> /// <exception cref="ArgumentException"><typeparamref name="TDelegate"/> 不是委托类型。</exception> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> /// <exception cref="ArgumentException">处理器的参数不匹配。</exception> /// <exception cref="ArgumentException">没有找到唯一的关键参数。</exception> /// <overloads> /// <summary> /// 创建方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// </overloads> public static TDelegate Create <TDelegate>(params Delegate[] delegates) where TDelegate : class { CommonExceptions.CheckCollectionItemNull(delegates, nameof(delegates)); Contract.Ensures(Contract.Result <TDelegate>() != null); CommonExceptions.CheckDelegateType(typeof(TDelegate)); var data = new ProcessorData(delegates); CheckDelegateType <TDelegate>(data); return(CreateSwitcher <TDelegate>(data, null, null)); }
//- @Register -// public override void Register() { String blogGuid = ParameterMap.PeekSafely("blogGuid"); if (String.IsNullOrEmpty(blogGuid)) { throw new System.Configuration.ConfigurationErrorsException("blogPage parameter is required for the Blog component."); } //+ factory AddFactory(FactoryData.Create("Minima.Web.Processing.ProcessorFactory, Minima.Web")); //+ processor AddProcessor(ProcessorData.Create <ProcessorData>("__$Minima$InitProcessor", new Object[] { blogGuid })); }
/// <summary> /// 返回与指定类型和标识相关的处理器数据。 /// </summary> /// <typeparam name="TDelegate">调用委托的类型。</typeparam> /// <param name="type">处理器所属的类型。</param> /// <param name="id">处理器的标识。</param> /// <param name="needStatic">需要的是否是静态方法。</param> /// <returns>与指定类型和标识相关的处理器数据。</returns> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> private static ProcessorData GetMethods <TDelegate>(Type type, string id, bool needStatic) { Contract.Requires(type != null && id != null); Contract.Ensures(Contract.Result <ProcessorData>() != null); ProcessorData data = methodDict.GetOrAdd(string.Concat(type.FullName, "_", id), key => new ProcessorData(type, id)); if (data.IsStatic != needStatic) { throw CommonExceptions.ProcessorMismatch(type, id); } CheckDelegateType <TDelegate>(data); return(data); }
/// <summary> /// 创建指定对象中与默认指定相关的实例方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// <typeparam name="TDelegate">使用基类型调用方法的委托。</typeparam> /// <param name="target">在其中查找实例方法的对象。</param> /// <returns><paramref name="target"/> 中与默认标识相关的实例方法切换器。</returns> /// <exception cref="ArgumentNullException"><paramref name="target"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentException"><typeparamref name="TDelegate"/> 不是委托类型。</exception> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> /// <exception cref="ArgumentException">处理器的参数不匹配。</exception> /// <exception cref="ArgumentException">没有找到唯一的关键参数。</exception> public static TDelegate Create <TDelegate>(object target) where TDelegate : class { if (target == null) { throw CommonExceptions.ArgumentNull("target"); } Contract.Ensures(Contract.Result <TDelegate>() != null); if (!typeof(TDelegate).IsSubclassOf(typeof(Delegate))) { throw CommonExceptions.MustBeDelegate("TDelegate", typeof(TDelegate)); } ProcessorData data = GetMethods <TDelegate>(target.GetType(), ProcessorAttribute.DefaultId, false); return(CreateSwitcher <TDelegate>(data, ProcessorAttribute.DefaultId, target)); }
public void SetTargetValue(ProcessorData processor, object value) { if ((this.Src.TargetType == WFMappingTarget.TargetTypes.Value) || ((this.Src.TargetType == WFMappingTarget.TargetTypes.Property) && (this.Src.Property.ReturnType == this.Target.Property.GetParameters()[0].ParameterType))) { try { if (this.Src.TargetType == WFMappingTarget.TargetTypes.Value) { value = GenericCastClass.Cast((string)value, this.Target.Property.GetParameters()[0].ParameterType); } this.Target.SetProperty(processor, value); } catch (Exception ex) { WFLogger.NLogger.ErrorException("Cast failed", ex); } } }
/// <summary> /// 创建指定对象中与标识指定相关的实例方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// <typeparam name="TDelegate">使用基类型调用方法的委托。</typeparam> /// <param name="target">在其中查找实例方法的对象。</param> /// <param name="id">处理器的标识。</param> /// <returns><paramref name="target"/> 中与指定标识相关的实例方法切换器。</returns> /// <exception cref="ArgumentNullException"><paramref name="target"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentNullException"><paramref name="id"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentException"><paramref name="id"/> 为空字符串。</exception> /// <exception cref="ArgumentException"><typeparamref name="TDelegate"/> 不是委托类型。</exception> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> /// <exception cref="ArgumentException">处理器的参数不匹配。</exception> /// <exception cref="ArgumentException">没有找到唯一的关键参数。</exception> public static TDelegate Create <TDelegate>(object target, string id) where TDelegate : class { if (target == null) { throw CommonExceptions.ArgumentNull("target"); } if (string.IsNullOrEmpty(id)) { throw CommonExceptions.StringEmpty("id"); } Contract.Ensures(Contract.Result <TDelegate>() != null); if (!typeof(TDelegate).IsSubclassOf(typeof(Delegate))) { throw CommonExceptions.MustBeDelegate("TDelegate", typeof(TDelegate)); } ProcessorData data = GetMethods <TDelegate>(target.GetType(), id, false); return(CreateSwitcher <TDelegate>(data, id, target)); }
/// <summary> /// 检查委托类型是否与处理器兼容。 /// </summary> /// <typeparam name="TDelegate">调用委托的类型。</typeparam> /// <param name="data">处理器的数据。</param> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> private static void CheckDelegateType <TDelegate>(ProcessorData data) { Contract.Requires(data != null); Type dlgType = typeof(TDelegate); if (data.IsStatic) { if (data.DelegateType != dlgType) { // 检查静态委托参数。 ParameterInfo[] paramInfos = data.DelegateType.GetMethod("Invoke").GetParametersNoCopy(); ParameterInfo[] dlgParamInfos = dlgType.GetMethod("Invoke").GetParametersNoCopy(); if (paramInfos.Length != dlgParamInfos.Length) { throw CommonExceptions.DelegateCompatible(data.DelegateType, dlgType); } if (paramInfos.Where((param, idx) => !param.ParameterType.IsExplicitFrom(dlgParamInfos[idx].ParameterType)) .Any()) { throw CommonExceptions.DelegateCompatible(data.DelegateType, dlgType); } } } else { // 检查实例委托参数,要考虑实例对应的参数。 ParameterInfo[] paramInfos = data.DelegateType.GetMethod("Invoke").GetParametersNoCopy(); ParameterInfo[] dlgParamInfos = dlgType.GetMethod("Invoke").GetParametersNoCopy(); if (paramInfos.Length != dlgParamInfos.Length + 1) { throw CommonExceptions.DelegateCompatible(data.DelegateType, dlgType); } for (int i = 1; i < paramInfos.Length; i++) { if (!paramInfos[i].ParameterType.IsExplicitFrom(dlgParamInfos[i - 1].ParameterType)) { throw CommonExceptions.DelegateCompatible(data.DelegateType, dlgType); } } } }
/// <summary> /// 创建与指定委托列表相关的方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// <typeparam name="TDelegate">使用基类型调用方法的委托类型。</typeparam> /// <param name="delegates">使用不同子类作为参数的委托列表。</param> /// <returns>与 <paramref name="delegates"/> 相关的方法切换器。</returns> /// <exception cref="ArgumentNullException"><paramref name="delegates"/> 为 <c>null</c>。</exception> /// <exception cref="ArgumentException"><paramref name="delegates"/> 中存在为 <c>null</c> 的委托。</exception> /// <exception cref="ArgumentException"><typeparamref name="TDelegate"/> 不是委托类型。</exception> /// <exception cref="ArgumentException">委托类型与处理器不匹配。</exception> /// <exception cref="ArgumentException">处理器的参数不匹配。</exception> /// <exception cref="ArgumentException">没有找到唯一的关键参数。</exception> /// <overloads> /// <summary> /// 创建方法切换器,会自动推断关键参数(使用不同子类的参数,必须是唯一的)。 /// </summary> /// </overloads> public static TDelegate Create <TDelegate>(params Delegate[] delegates) where TDelegate : class { if (delegates == null) { throw CommonExceptions.ArgumentNull("delegates"); } if (delegates.Any(d => d == null)) { throw CommonExceptions.CollectionItemNull("delegates"); } Contract.Ensures(Contract.Result <TDelegate>() != null); if (!typeof(TDelegate).IsSubclassOf(typeof(Delegate))) { throw CommonExceptions.MustBeDelegate("TDelegate", typeof(TDelegate)); } ProcessorData data = new ProcessorData(delegates); CheckDelegateType <TDelegate>(data); return(CreateSwitcher <TDelegate>(data, null, null)); }
public Guid Execute(ProcessorData procdata) { Guid guid = Guid.Empty; if (this.Proxy != null) { // need to set property table for all properties having KRSrcWorkflow attribute foreach (PropertyInfo pi in procdata.GetType().GetProperties().Where(x => x.GetCustomAttributes(false).Count(y => y.GetType().Name == typeof(KRSrcWorkflowAttribute).Name) > 0)) { MethodInfo method = procdata.GetType().GetMethod("SetProperty"); MethodInfo generic = method.MakeGenericMethod(pi.PropertyType); generic.Invoke(procdata, new object[] { pi.Name, pi.GetValue(procdata, null) }); Console.WriteLine(pi.Name); } guid = this.Proxy.Execute((ProcessorData)procdata.Clone()); } return(guid); }
//- @Register -// public override void Register() { String blogGuid = ParameterMap.PeekSafely("blogGuid"); if (String.IsNullOrEmpty(blogGuid)) { throw new System.Configuration.ConfigurationErrorsException("blogPage parameter is required for the Blog component."); } //+ factory AddFactory(FactoryData.Create("Minima.Web.Processing.HandlerFactory, Minima.Web")); AddFactory(FactoryData.Create("Minima.Web.Processing.ProcessorFactory, Minima.Web")); //+ processor AddProcessor(ProcessorData.Create <ProcessorData>("__$Minima$InitProcessor", new Object[] { blogGuid })); //+ handler AddEndpoint(EndpointData.Create(SelectorType.EndsWith, "/rsd.xml", "__$Minima$BlogDiscovery")); AddEndpoint(EndpointData.Create(SelectorType.EndsWith, "/wlwmanifest.xml", "__$Minima$WindowsLiveWriterManifest")); AddEndpoint(EndpointData.Create(SelectorType.EndsWith, "/blogmap.xml", "__$Minima$SiteMap")); AddEndpoint(EndpointData.Create(SelectorType.Contains, "/xml-rpc", "__$Minima$MetaWeblogApi")); AddEndpoint(EndpointData.Create(SelectorType.Contains, "/xml-rpc/", "__$Minima$MetaWeblogApi")); AddEndpoint(EndpointData.Create(SelectorType.Contains, "/imagestore", "__$Minima$Image")); }
public object GetValue(ProcessorData processor) { object value = null; if (this.TargetType == WFMappingTarget.TargetTypes.Property) { try { value = this.Property.Invoke(processor, new object[0]); } catch (Exception ex) { WFLogger.NLogger.ErrorException(String.Format("Invoke failed for property: {0} on type: {1}", this.Property.Name, processor.GetType().FullName), ex); } } else if (this.TargetType == WFMappingTarget.TargetTypes.Value) { value = this.Value; } return(value); }
private static void LoadSingleProcessorData(WebDomainData data, String processorType, Object[] parameterArray, String source) { ProcessEachSettingToken(parameterArray); //+ var readerWriterLockSlim = new ReaderWriterLockSlim(); try { readerWriterLockSlim.EnterUpgradeableReadLock(); try { IProcessor processor = null; //+ if (RouteCache.ProcessorCache.ContainsKey(processorType)) { processor = RouteCache.ProcessorCache[processorType]; } else { readerWriterLockSlim.EnterWriteLock(); //+ try { if (!RouteCache.ProcessorCache.ContainsKey(processorType)) { processor = ProcessorActivator.Create<IProcessor>(processorType, RouteCache.ProcessorFactoryCache); if (processor == null) { throw new InvalidProcessorException(String.Format(Resource.Processor_Invalid, processorType)); } //+ RouteCache.ProcessorCache.Add(processorType, processor); } } finally { readerWriterLockSlim.ExitWriteLock(); } } if (processor == null) { return; } ProcessorData processorData; if (processor is InitProcessor) { processorData = new ProcessorData { ProcessorType = processorType, ParameterArray = parameterArray }; processorData.Source = String.IsNullOrEmpty(source) ? Info.System : source; data.InitProcessorDataList.Add(processorData); } else if (processor is SelectionProcessor) { processorData = new ProcessorData { ProcessorType = processorType, ParameterArray = parameterArray }; processorData.Source = String.IsNullOrEmpty(source) ? Info.System : source; data.SelectionProcessorDataList.Add(processorData); } else if (processor is OverrideProcessor) { processorData = new ProcessorData { ProcessorType = processorType, ParameterArray = parameterArray }; processorData.Source = String.IsNullOrEmpty(source) ? Info.System : source; data.OverrideProcessorDataList.Add(processorData); } else if (processor is StateProcessor) { processorData = new ProcessorData { ProcessorType = processorType, ParameterArray = parameterArray }; processorData.Source = String.IsNullOrEmpty(source) ? Info.System : source; data.StateProcessorDataList.Add(processorData); } else if (processor is PostRenderProcessor) { processorData = new ProcessorData { ProcessorType = processorType, ParameterArray = parameterArray }; processorData.Source = String.IsNullOrEmpty(source) ? Info.System : source; data.PostRenderProcessorDataList.Add(processorData); } else if (processor is ErrorProcessor) { processorData = new ErrorProcessorData { ProcessorType = processorType, ParameterArray = parameterArray }; processorData.Source = String.IsNullOrEmpty(source) ? Info.System : source; var epd = ((ErrorProcessorData)processorData); epd.Init(); data.ErrorProcessorDataList.Add(epd); } } finally { readerWriterLockSlim.ExitUpgradeableReadLock(); } } catch (Exception ex) { if (WebProcessingReportController.Reporter.Initialized) { var map = new Map(); map.Add("Section", "Processor"); map.Add("Type", processorType); map.Add("Message", ex.Message); map.Add("Exception Type", ex.GetType().FullName); //+ WebProcessingReportController.Reporter.AddMap(map); } } }
//- #AddProcessor -// protected void AddProcessor(ProcessorData processorData) { processorData.Source = Key; _processorDataList.Add(processorData); }
/// <summary> /// 返回与指定处理器数据相关的指定类型的委托。 /// </summary> /// <typeparam name="TDelegate">委托的类型。</typeparam> /// <param name="data">处理器数据。</param> /// <param name="id">处理器标识。</param> /// <param name="instance">处理器要绑定到的实例。</param> /// <returns>与 <paramref name="data"/> 相关的 <typeparamref name="TDelegate"/> 类型的委托。</returns> private static TDelegate CreateSwitcher <TDelegate>(ProcessorData data, string id, object instance) where TDelegate : class { Contract.Requires(data != null); MethodInfo invoke = typeof(TDelegate).GetInvokeMethod(); Type[] paramTypes = invoke.GetParameterTypes(); object closure; if (data.IsStatic) { closure = data.Processors; } else { closure = new Closure(new[] { instance, data.Processors }, null); } DynamicMethod method = new DynamicMethod("MethodSwitcher", invoke.ReturnType, paramTypes.Insert(0, closure.GetType()), true); ILGenerator il = method.GetILGenerator(); // 静态方法中,arg_0 用作存储处理器委托字典。 il.Emit(OpCodes.Ldarg_0); if (!data.IsStatic) { // 实例方法中,arg_0.Constants[1] 用作存储处理器委托字典。 il.Emit(OpCodes.Ldfld, Reflections.ClosureConstants); il.EmitInt(1); il.Emit(OpCodes.Ldelem_Ref); il.Emit(OpCodes.Castclass, typeof(Dictionary <Type, Delegate>)); } // 判断关键参数是否为 null。 il.EmitLoadArg(data.KeyIndex + 1); Label keyNullCase = il.DefineLabel(); il.Emit(OpCodes.Brtrue, keyNullCase); // 关键参数为 null,将 object 作为查找类型。 il.EmitConstant(typeof(object)); Label endKeyNull = il.DefineLabel(); il.Emit(OpCodes.Br, endKeyNull); // 关键参数不为 null,将参数类型作为查找类型。 il.MarkLabel(keyNullCase); il.EmitLoadArg(data.KeyIndex + 1); il.Emit(OpCodes.Call, methodGetType); il.MarkLabel(endKeyNull); // 调用 GetMethod 方法,取得方法委托。 il.EmitConstant(id); il.Emit(OpCodes.Call, methodGetMethod); il.Emit(OpCodes.Castclass, data.DelegateType); //// 载入参数,调用委托。 Type[] originParamTypes = data.DelegateParamTypes; if (!data.IsStatic) { // 载入实例。 il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, Reflections.ClosureConstants); il.EmitInt(0); il.Emit(OpCodes.Ldelem_Ref); il.EmitConversion(typeof(object), instance.GetType(), true); } int offset = data.IsStatic ? 0 : 1; for (int i = 0; i < paramTypes.Length; i++) { Type targetType = originParamTypes[i + offset]; Contract.Assume(targetType != null); il.EmitLoadArg(i + 1, paramTypes[i], targetType); } il.Emit(OpCodes.Callvirt, data.DelegateType.GetInvokeMethod()); Type returnType = originParamTypes[originParamTypes.Length - 1]; Type targetReturnType = invoke.ReturnType; // 转换返回类型。 if (returnType == typeof(void)) { if (targetReturnType != typeof(void)) { il.EmitConstant(null, targetReturnType); } } else { if (targetReturnType == typeof(void)) { il.Emit(OpCodes.Pop); } else if (returnType != targetReturnType) { il.EmitConversion(returnType, targetReturnType, true); } } il.Emit(OpCodes.Ret); return(method.CreateDelegate(typeof(TDelegate), closure) as TDelegate); }
public object GetValue(ProcessorData processor) { object value = null; if (this.TargetType == WFMappingTarget.TargetTypes.Property) { try { value = this.Property.Invoke(processor, new object[0]); } catch (Exception ex) { WFLogger.NLogger.ErrorException(String.Format("Invoke failed for property: {0} on type: {1}", this.Property.Name, processor.GetType().FullName), ex); } } else if (this.TargetType == WFMappingTarget.TargetTypes.Value) value = this.Value; return value; }
public object GetSrcValue(ProcessorData processor) { return(this.Src.GetValue(processor)); }