public static Func <object[], object> RegisterDelegate <T>(string id, Expression <T> expression) where T : Delegate { if (string.IsNullOrEmpty(id)) { throw new ArgumentException(nameof(id)); } if (expression == null) { throw new ArgumentNullException(nameof(expression)); } var methodInfo = MethodUtil.GetMethodInfo(expression); Func <object[], object> func; if (methodInfo.ReturnType != typeof(void)) { func = DelegateFactory.CreateValueDelegate(expression, methodInfo); } else { var dge = DelegateFactory.CreateVoidDelegate(expression, methodInfo); func = (args) => { dge.Invoke(args); return(null); }; } RegisterMethod(id, func); return(func); }
// =============================================================================== // ConditionBean Override // ====================== protected override void SetupSelectMethodByAuto(MethodInfo methodInfo) { if (SetupInternalSelectMethodSequenceNextVal(methodInfo)) { return; } // Assert unsupported String query = _annotationReader.GetQuery(methodInfo.Name); AssertQueryAnnotationUnsupported(methodInfo, query); IDataReaderHandler handler = CreateDataReaderHandler(methodInfo); String[] argNames = MethodUtil.GetParameterNames(methodInfo); Type[] argTypes = MethodUtil.GetParameterTypes(methodInfo); SelectDynamicCommand cmd = CreateSelectDynamicCommand(handler); if (argTypes.Length == 1 && ValueTypes.GetValueType(argTypes[0]) == ValueTypes.OBJECT) { argNames = new String[] { "pmb" }; AssertAutoQueryByDtoUnsupported(methodInfo, argTypes); S2DaoSelectDynamicCommand dynamicCommand = CreateCustomizeSelectDynamicCommand(handler); cmd = dynamicCommand; } else { HandleAutoQueryByArgsAnnotationUnsupported(methodInfo, argNames); } cmd.ArgNames = argNames; cmd.ArgTypes = argTypes; _sqlCommands[methodInfo.Name] = cmd; }
/// <summary> /// senderに指定のプロパティが存在するか調べます。 /// </summary> private void VerifyProperty(object sender, PropertyChangedEventArgs e) { if (sender == null) { throw new ArgumentNullException("sender"); } if (e == null || string.IsNullOrEmpty(e.PropertyName)) { throw new ArgumentException( "プロパティ名がありません。", "e"); } #if !RGN_DYNAMICVIEWMODEL // 変更通知の対象となるプロパティを取得します。 var propertyDic = MethodUtil.GetPropertyDic(sender.GetType()); if (propertyDic == null) { throw new RagnarokException( "プロパティリストが取得できませんでした。"); } if (!propertyDic.ContainsKey(e.PropertyName)) { throw new InvalidOperationException( string.Format( "型'{0}'にプロパティ'{1}'は存在しません。", sender.GetType(), e.PropertyName)); } #endif }
public static Method Register( string methodId, Expression<Action> implementExpression){ if (implementExpression == null) { throw new ArgumentNullException(nameof(implementExpression)); } var method = MethodUtil.GetMethodInfo(implementExpression); if (typeof(Delegate).IsAssignableFrom(method.DeclaringType)) { throw new ArgumentException($"{nameof(implementExpression)}不能为Delegate!"); } Func<object[], object> func = null; if (method.IsStatic) { if (method.ReturnType == typeof(void)) { func = RpcRegister.RegisterStaticVoidMethod(methodId, method); } else { func = RpcRegister.RegisterStaticValueMethod(methodId, method); } } else { if (method.ReturnType == typeof(void)) { func = RpcRegister.RegisterVoidMethod(methodId, GetObject(implementExpression), method); } else { func = RpcRegister.RegisterValueMethod(methodId, GetObject(implementExpression), method); } } return new Method { Id = methodId, Function = func }; }
private static void InstanceTests() { MethodBase[] methods = { typeof(InstanceClassA).GetMethod("A", BindingFlags.Instance | BindingFlags.Public), typeof(InstanceClassA).GetMethod("B", BindingFlags.Instance | BindingFlags.Public), typeof(InstanceClassB).GetMethod("A", BindingFlags.Instance | BindingFlags.Public), typeof(InstanceClassB).GetMethod("B", BindingFlags.Instance | BindingFlags.Public) }; // Jit TestStaticReplaceJited RuntimeHelpers.PrepareMethod( typeof(Program).GetMethod("TestInstanceReplaceJited", BindingFlags.Static | BindingFlags.NonPublic).MethodHandle); // Replace StaticClassA.A() with StaticClassB.A() Console.WriteLine("Replacing InstanceClassA.A() with InstanceClassB.A()"); MethodUtil.ReplaceMethod(methods[2], methods[0]); // Call StaticClassA.A() from a method that has already been jited Console.WriteLine("Call InstanceClassA.A() from a method that has already been jited"); TestInstanceReplaceJited(); // Call StaticClassA.A() from a method that has not been jited Console.WriteLine("Call InstanceClassA.A() from a method that has not been jited"); TestInstanceReplace(); }
// =============================================================================== // OutsideSql Override // =================== // ------------------------------------------------- // Traditional OutsideSql // ---------------------- protected override void SetupSelectMethodByManual(MethodInfo mi, string sql) { string[] parameterNames = MethodUtil.GetParameterNames(mi); Type[] parameterTypes = MethodUtil.GetParameterTypes(mi); string[] filteredParameterNames = null; Type[] filteredParameterTypes = null; if (parameterTypes != null && parameterTypes.Length > 0 && typeof(CursorHandler).IsAssignableFrom(parameterTypes[parameterTypes.Length - 1])) { filteredParameterNames = new string[parameterTypes.Length - 1]; filteredParameterTypes = new Type[parameterTypes.Length - 1]; for (int i = 0; i < parameterTypes.Length - 1; i++) { filteredParameterNames[i] = parameterNames[i]; filteredParameterTypes[i] = parameterTypes[i]; } } else { filteredParameterNames = parameterNames; filteredParameterTypes = parameterTypes; } IBeanMetaData myMetaData = GetOutsideSqlBeanMetaData(mi, _dbMetaData, _dbms); IDataReaderHandler myDataReaderHandler = CreateDataReaderHandler(mi, myMetaData); RegisterSqlCommand(mi.Name, mi, sql, filteredParameterNames, filteredParameterTypes, myDataReaderHandler); }
public void MoveBlackTest1() { var board = MakeBoard1(BWType.Black); var move = BoardMove.CreateMove( BWType.Black, new Square(8, 3), new Square(8, 2), new Piece(PieceType.Kyo, false), true); Assert.True(board.CanMove(move)); // 駒が設定されてないと動けません。 MethodUtil.SetPropertyValue(move, "MovePiece", new Piece()); Assert.False(board.CanMove(move)); MethodUtil.SetPropertyValue(move, "MovePiece", new Piece(PieceType.Kyo, false)); // 84の駒は移動できません。 MethodUtil.SetPropertyValue(move, "SrcSquare", new Square(8, 4)); Assert.False(board.CanMove(move)); MethodUtil.SetPropertyValue(move, "SrcSquare", new Square(8, 3)); CanMoveTo(board, move, new List <Tuple <Square, bool> > { Tuple.Create(new Square(8, 2), false), Tuple.Create(new Square(8, 1), true), }); }
/// <summary> /// ViewModelの状態を元に戻します。 /// </summary> public void RollbackViewModel() { lock (this.oldPropertyValueDic) { this.oldPropertyValueDic.ForEach(_ => MethodUtil.SetPropertyValue(ViewModel, _.Key, _.Value)); } }
private void KillProfiler() { var keenStart = typeof(MySimpleProfiler).GetMethod("Begin"); var keenEnd = typeof(MySimpleProfiler).GetMethod("End"); var ourStart = typeof(Server).GetMethod("Begin"); var ourEnd = typeof(Server).GetMethod("End"); MethodUtil.ReplaceMethod(ourStart, keenStart); MethodUtil.ReplaceMethod(ourEnd, keenEnd); }
/// <summary> /// 他プロパティに依存しているプロパティを計算します。 /// </summary> private MultiMap <TypeProperty, string> MakeDependPropertyMap( Type targetType) { const BindingFlags flags = BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.NonPublic; var propertyList = MethodUtil.GetThisAndInheritClasses(targetType) .SelectMany(klass => klass.GetProperties(flags)); var result = new MultiMap <TypeProperty, string>( new TypePropertyComparer()); // このクラスのプロパティから、DependOnPropertyAttributeを持つ // ものを抜き出します。 // // 作成するものがMultiMapなので、Linqは使いにくいです。 foreach (var property in propertyList) { var attrList = property.GetCustomAttributes( typeof(DependOnPropertyAttribute), true); foreach (var attr in attrList) { var dependAttr = attr as DependOnPropertyAttribute; if (dependAttr == null) { continue; } // 依存先の型がないときは自分の型と同じになります。 var dependType = (dependAttr.DependType ?? targetType); // 依存先プロパティの名前がないときは、 // 依存先のプロパティ名は依存元と同じになります。 var dependName = (!string.IsNullOrEmpty(dependAttr.DependName) ? dependAttr.DependName : property.Name); // 依存元のプロパティに依存先のプロパティを紐つけます。 result.Add( new TypeProperty(dependType, dependName), property.Name); } } return(result); }
public static void Run() { // I think at a lower level this call uses the one below so may not be necessary MethodBase checkMethod = typeof(GraphicsAdapter).GetMethod("IsProfileSupported", BindingFlags.Instance | BindingFlags.Public); MethodBase replaceCheckMethod = typeof(GraphicsAdapterReplacement).GetMethod("IsProfileSupported", BindingFlags.Instance | BindingFlags.Public); MethodUtil.ReplaceMethod(replaceCheckMethod, checkMethod); // Disable the profile capabilities check MethodBase profileMethod = typeof(GraphicsAdapter).GetMethod("IsProfileSupported", BindingFlags.Instance | BindingFlags.NonPublic); MethodBase replaceProfileMethod = typeof(GraphicsAdapterReplacement).GetMethod("IsProfileSupported", BindingFlags.Instance | BindingFlags.NonPublic); MethodUtil.ReplaceMethod(replaceProfileMethod, profileMethod); }
private void MyPropertyChanging(object sender, PropertyChangingEventArgs e) { lock (this.oldPropertyValueDic) { // ViewModelの状態を元すため、プロパティの元の値を保存します。 if (!this.oldPropertyValueDic.ContainsKey(e.PropertyName)) { this.oldPropertyValueDic[e.PropertyName] = MethodUtil.GetPropertyValue(sender, e.PropertyName); } } base.OnPropertyChanging(e); }
/// <summary> /// オブジェクトが持つ全プロパティの変更を通知します。 /// </summary> /// <remarks> /// 重複したプロパティに対して通知が出されることがあります。 /// </remarks> public void RaiseAllPropertyChanged(object target) { var properties = MethodUtil.GetPropertyDic(target.GetType()); foreach (var property in properties) { if (target == this) { this.RaisePropertyChanged(property.Key); } else { this.DependModel_PropertyChanged( target, new PropertyChangedEventArgs(property.Key)); } } }
public static string GetId <T>(Expression <T> expression) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } var method = MethodUtil.GetMethodInfo(expression); var response = method.GetCustomAttribute <RpcResponseAttribute>(); if (response == null) { throw new MissingAttributeException($"{method.Name}缺少{nameof(RpcResponseAttribute)}属性"); } return(response.GetId()); }
/// <summary> /// プロパティ名から依存プロパティを検索します。 /// </summary> private static DependencyProperty GetDepPropertyImpl(Type sourceType, string propertyName) { const BindingFlags flags = BindingFlags.Static | BindingFlags.GetField | BindingFlags.Public; var classes = MethodUtil.GetThisAndInheritClasses(sourceType); var propertyList = classes .SelectMany(_ => _.GetFields(flags)) .Select(_ => _.GetValue(null) as DependencyProperty) .Where(_ => _ != null); return(propertyList.FirstOrDefault(_ => _.Name == propertyName)); }
public static Method Register<TDelegate>( string methodId, Expression<TDelegate> implementExpression) where TDelegate : Delegate { if (implementExpression == null) { throw new ArgumentNullException(nameof(implementExpression)); } var method = MethodUtil.GetMethodInfo(implementExpression); if (!typeof(Delegate).IsAssignableFrom(method.DeclaringType)) { throw new ArgumentException($"{nameof(implementExpression)}不是delegate类型!"); } var func = RpcRegister.RegisterDelegate(methodId, implementExpression); return new Method { Id = methodId, Function = func }; }
/// <summary> /// 駒の各移動先に対して、その手が指せるのかどうかをチェックします。 /// </summary> private void CanMoveTo(Board board, BoardMove move, List <Tuple <Square, bool> > availables) { for (var file = 1; file <= Board.BoardSize; ++file) { for (var rank = 1; rank <= Board.BoardSize; ++rank) { var sq = new Square(file, rank); var avail = availables.FirstOrDefault(_ => _.Item1 == sq); MethodUtil.SetPropertyValue(move, "DstSquare", sq); if (avail != null) { if (avail.Item2) { // 成りが必須の場合 move.IsPromote = false; Assert.False(board.CanMove(move)); move.IsPromote = true; Assert.True(board.CanMove(move)); } else { // 成りが必須でない場合 move.IsPromote = false; Assert.True(board.CanMove(move)); move.IsPromote = true; Assert.AreEqual(Board.CanPromote(move), board.CanMove(move)); } } else { // そもそも移動できる場所ではない move.IsPromote = false; Assert.False(board.CanMove(move)); move.IsPromote = true; Assert.False(board.CanMove(move)); } } } }
public static void Init() { //ApplicationLog.BaseLog.Warn("Skipping profiler init"); //return; var entType = typeof(MyEntities); m_entitiesForUpdate = (MyDistributedUpdater <CachingList <MyEntity>, MyEntity>)entType.GetField("m_entitiesForUpdate", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null); m_entitiesForUpdate10 = (MyDistributedUpdater <CachingList <MyEntity>, MyEntity>)entType.GetField("m_entitiesForUpdate10", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null); m_entitiesForUpdate100 = (MyDistributedUpdater <CachingList <MyEntity>, MyEntity>)entType.GetField("m_entitiesForUpdate100", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null); m_creationThread = (MyEntityCreationThread)entType.GetField("m_creationThread", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null); var keenBefore = entType.GetMethod("UpdateBeforeSimulation"); var ourBefore = typeof(ProfilerInjection).GetMethod("UpdateBeforeSimulation"); var keenAfter = entType.GetMethod("UpdateAfterSimulation"); var ourAfter = typeof(ProfilerInjection).GetMethod("UpdateAfterSimulation"); //using (var md5 = MD5.Create()) //{ // var body = keenBefore.GetMethodBody().GetILAsByteArray(); // var hash = md5.ComputeHash(body); // string compStr = Convert.ToBase64String(hash).ToUpper(); // if (compStr!= "YXXKWK+W+OHP+LNOGGM32A==" || body.Length != 238) // { // BaseLog.Warn("UpdateBeforeSimulation signature has changed! Cannot load profiler injector!"); // BaseLog.Error($"{compStr}:{body.Length}"); // return; // } // body = keenAfter.GetMethodBody().GetILAsByteArray(); // hash = md5.ComputeHash(body); // compStr = Convert.ToBase64String(hash).ToUpper(); // if (compStr!= "7ZKFYWZRON9U3G43AV4QRA==" || body.Length != 220) // { // BaseLog.Warn("UpdateAfterSimulation signature has changed! Cannot load profiler injector!"); // BaseLog.Error($"{compStr}:{body.Length}"); // return; // } //} BaseLog.Info("Replacing UpdateBeforeSimulation"); MethodUtil.ReplaceMethod(ourBefore, keenBefore); BaseLog.Info("Replacing UpdateAfterSimulation"); MethodUtil.ReplaceMethod(ourAfter, keenAfter); }
public void Set(Func <T, TResult> func) { if (victim.IsStatic && !func.Method.IsStatic) { func = Clone(func); } curFunc = func; Action curUnhook; if (!MethodUtil.HookMethod(victim, func.Method, out curUnhook)) { throw new InvalidOperationException(String.Format("Unable to hook method '{0}'", Formatter.Format(victim))); } if (unhook == null) { unhook = curUnhook; } }
private Object ApplyGetters(Object target, String getters) { if (getters == null || getters.Equals("")) { return(target); } int firstDot = getters.IndexOf('.'); if (firstDot == -1) { firstDot = getters.Length(); } String first = getters.Substring(0, firstDot); String rest = getters.Substring(System.Math.Min(firstDot + 1, getters.Length())); try { Method getter = null; if (target != null) { getter = Statement.GetMethod(target.GetType(), "get" + NameGenerator.Capitalize(first), new Class[] {}); if (getter == null) { getter = Statement.GetMethod(target.GetType(), "is" + NameGenerator.Capitalize(first), new Class[] {}); } if (getter == null) { getter = Statement.GetMethod(target.GetType(), first, new Class[] {}); } } if (getter == null) { throw new RuntimeException("No method called: " + first + " defined on " + target); } Object newTarget = MethodUtil.invoke(getter, target, new Object[] {}); return(ApplyGetters(newTarget, rest)); } catch (Exception e) { throw new RuntimeException("Failed to call method: " + first + " on " + target, e); } }
/// <summary> /// This default implementation of the <code>instantiate</code> method returns /// an expression containing the predefined method name "new" which denotes a /// call to a constructor with the arguments as specified in /// the <code>DefaultPersistenceDelegate</code>'s constructor. /// </summary> /// <param name="oldInstance"> The instance to be instantiated. </param> /// <param name="out"> The code output stream. </param> /// <returns> An expression whose value is <code>oldInstance</code>. /// </returns> /// <exception cref="NullPointerException"> if {@code out} is {@code null} /// and this value is used in the method /// </exception> /// <seealso cref= #DefaultPersistenceDelegate(String[]) </seealso> protected internal override Expression Instantiate(Object oldInstance, Encoder @out) { int nArgs = Constructor.Length; Class type = oldInstance.GetType(); Object[] constructorArgs = new Object[nArgs]; for (int i = 0; i < nArgs; i++) { try { Method method = FindMethod(type, this.Constructor[i]); constructorArgs[i] = MethodUtil.invoke(method, oldInstance, new Object[0]); } catch (Exception e) { @out.ExceptionListener.ExceptionThrown(e); } } return(new Expression(oldInstance, oldInstance.GetType(), "new", constructorArgs)); }
/// <summary> /// コンストラクタ /// </summary> public BindingData(Binding binding) { Binding = binding; this.targetPropertyObject = MethodUtil.GetPropertyObject( Binding.BindableTarget.GetType(), Binding.BindingPropertyName); if (this.targetPropertyObject == null) { throw new ArgumentException( Binding.BindingPropertyName + ": 指定のプロパティが存在しません。"); } this.sourcePropertyObject = MethodUtil.GetPropertyObject( Binding.DataSource.GetType(), Binding.DataSourcePropertyName); if (this.sourcePropertyObject == null) { throw new ArgumentException( Binding.DataSourcePropertyName + ": 指定のプロパティが存在しません。"); } }
public void MoveWhiteTest1() { var board = MakeBoard1(BWType.White); var move = BoardMove.CreateMove( BWType.White, new Square(9, 7), new Square(9, 8), new Piece(PieceType.Hu, false), true); Assert.True(board.CanMove(move)); // 84の駒は移動できません。 MethodUtil.SetPropertyValue(move, "SrcSquare", new Square(8, 4)); Assert.False(board.CanMove(move)); MethodUtil.SetPropertyValue(move, "SrcSquare", new Square(9, 7)); CanMoveTo(board, move, new List <Tuple <Square, bool> > { Tuple.Create(new Square(9, 8), false), }); }
public override IMessage Invoke(IMessage msg) { IMethodCallMessage methodMessage = new MethodCallMessageWrapper((IMethodCallMessage)msg); var args = methodMessage.Args; Type[] argumentTypes = MethodUtil.GetArgTypes(args); MethodInfo targetMethod = GetMethodInfoForMethodBase(methodMessage, argumentTypes); object objReturnValue = null; if (targetMethod != null) { if (targetMethod.Name.Equals("Equals") && argumentTypes != null && argumentTypes.Length == 1 && argumentTypes[0].IsAssignableFrom((typeof(Object)))) { objReturnValue = false; } else if (targetMethod.Name.Equals("GetHashCode") && argumentTypes.Length == 0) { objReturnValue = _proxyType.GetHashCode(); } else if (targetMethod.Name.Equals("ToString") && argumentTypes.Length == 0) { objReturnValue = "[Proxy " + _proxyType.Name + "]"; } else if (targetMethod.Name.Equals("GetType") && argumentTypes.Length == 0) { objReturnValue = _proxyType; } else { objReturnValue = DoMethodCall(args, argumentTypes, targetMethod); } } else { if (targetMethod.Name.Equals("GetType") && (args.Length == 0)) { objReturnValue = _proxyType; } } return(new ReturnMessage(objReturnValue, methodMessage.Args, methodMessage.ArgCount, methodMessage.LogicalCallContext, methodMessage)); }
/// <summary> /// プロパティ値の取得・設定用オブジェクトを取得します。 /// </summary> private IPropertyObject GetPropertyObject(object target) { var pobj = MethodUtil.GetPropertyObject( target.GetType(), TargetProperty); if (pobj == null) { throw new InvalidOperationException( string.Format( "{0}.{1}: プロパティ名が正しくありません。", target.GetType(), TargetProperty)); } if (!pobj.PropertyType.Equals(TargetPropertyType)) { throw new InvalidOperationException( string.Format( "{0}.{1}: プロパティの型が正しくありません。", target.GetType(), TargetProperty)); } if (!pobj.CanRead) { throw new InvalidOperationException( string.Format( "{0}.{1}: このプロパティは読み込みできません。", target.GetType(), TargetProperty)); } if (!pobj.CanWrite) { throw new InvalidOperationException( string.Format( "{0}.{1}: このプロパティには書き込みできません。", target.GetType(), TargetProperty)); } return(pobj); }
protected override object Invoke(MethodInfo targetMethod, object[] args) { Type[] argumentTypes = MethodUtil.GetArgTypes(args); object objReturnValue = null; if (targetMethod != null) { if (targetMethod.Name.Equals("Equals") && argumentTypes != null && argumentTypes.Length == 1 && argumentTypes[0].IsAssignableFrom((typeof(Object)))) { objReturnValue = false; } else if (targetMethod.Name.Equals("GetHashCode") && argumentTypes.Length == 0) { objReturnValue = _proxyType.GetHashCode(); } else if (targetMethod.Name.Equals("ToString") && argumentTypes.Length == 0) { objReturnValue = "[Proxy " + _proxyType.Name + "]"; } else if (targetMethod.Name.Equals("GetType") && argumentTypes.Length == 0) { objReturnValue = _proxyType; } else { objReturnValue = DoMethodCall(args, argumentTypes, targetMethod); } } else { if (targetMethod.Name.Equals("GetType") && (args.Length == 0)) { objReturnValue = _proxyType; } } return(objReturnValue); }
public static void Main(string[] args) { var method = typeof(FileStream).GetMethod("Init", BindingFlags.Instance | BindingFlags.NonPublic); var body = MethodBody.Read(method, true); body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldarg_1)); var debugWriteLineMethod = typeof(Debug).GetMethod("WriteLine", BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string) }, null); body.Instructions.Insert(1, Instruction.Create(OpCodes.Call, debugWriteLineMethod)); Console.WriteLine(body); var parameterTypes = new [] { method.DeclaringType }.Concat(method.GetParameters().Select(p => p.ParameterType)).ToArray(); var del = body.CreateDelegate(method.ReturnType, parameterTypes); Action unhook; if (!MethodUtil.HookMethod(method, del.Method, out unhook)) { throw new InvalidOperationException("Unable to hook method"); } File.WriteAllText(@"c:\temp\test.txt", "test"); using (var mock = new Mock <int, int[]>(x => DataReader.Read(x))) { //mock.Set(MockedMethod); mock.Set(x => { if (x == 42) { return new[] { 1, 4, 7, 8 } } ; throw new InvalidOperationException(); }); var dataProcessor = new DataProcessor(); Assert.AreEqual(5, dataProcessor.FindAverage(42)); } }
public static MethodTuple CreateMethodTuple <T>(Expression <T> expression) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } var method = MethodUtil.GetMethodInfo(expression); var response = method.GetCustomAttribute <RpcRequestAttribute>(); if (response == null) { throw new MissingAttributeException($"{method.Name}缺少{nameof(RpcRequestAttribute)}属性"); } var dge = CreateDelegate(expression); var methodTupe = new MethodTuple() { RpcMethod = response, Action = dge }; return(methodTupe); }
private static void DynamicTests() { // Create dynamic method C in StaticClassA var dynamicMethod = CreateTestMethod(typeof(StaticClassA), "C"); // Get methodbase for class MethodBase method = typeof(StaticClassA).GetMethod("B", BindingFlags.Static | BindingFlags.Public); // Jit TestStaticReplaceJited RuntimeHelpers.PrepareMethod(typeof(Program) .GetMethod("TestDynamicReplaceJited", BindingFlags.Static | BindingFlags.NonPublic).MethodHandle); // Replace StaticClassA.B() with dynamic StaticClassA.C() Console.WriteLine("Replacing StaticClassA.B() with dynamic StaticClassA.C()"); MethodUtil.ReplaceMethod(dynamicMethod, method); // Call StaticClassA.B() from a method that has already been jited Console.WriteLine("Call StaticClassA.B() from a method that has already been jited"); TestDynamicReplaceJited(); // Call StaticClassA.B() from a method that has not been jited Console.WriteLine("Call StaticClassA.B() from a method that has not been jited"); TestDynamicReplace(); }
public static void HookDevenv() { var method = typeof(FileStream).GetMethod("Init", BindingFlags.Instance | BindingFlags.NonPublic); var body = MethodBody.Read(method, true); body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldstr, "TRACING: ")); body.Instructions.Insert(1, Instruction.Create(OpCodes.Ldarg_1)); var stringConcatMethod = typeof(string).GetMethod("Concat", BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string), typeof(string) }, null); body.Instructions.Insert(2, Instruction.Create(OpCodes.Call, stringConcatMethod)); var debugWriteLineMethod = typeof(Debug).GetMethod("WriteLine", BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string) }, null); body.Instructions.Insert(3, Instruction.Create(OpCodes.Call, debugWriteLineMethod)); var parameterTypes = new[] { method.DeclaringType }.Concat(method.GetParameters().Select(p => p.ParameterType)).ToArray(); del = body.CreateDelegate(method.ReturnType, parameterTypes); Action unhook; if (!MethodUtil.HookMethod(method, del.Method, out unhook)) { Debug.WriteLine("Unable to hook method"); } }