How do I use reflection to invoke a private method

Question

There are a group of private methods in my class  and I need to call one dynamically based on an input value  Both the invoking code and the target methods are in the same instance  The code looks like this   MethodInfo dynMethod   this GetType   GetMethod  Draw     itemType   dynMethod Invoke this  new object     methodParams       In this case  GetMethod   will not return private methods  What BindingFlags do I need to supply to GetMethod   so that it can locate private methods

User · Answer

BindingFlags NonPublic will not return any results by itself  As it turns out  combining it with BindingFlags Instance does the trick   MethodInfo dynMethod   this GetType   GetMethod  Draw     itemType       BindingFlags NonPublic   BindingFlags Instance

User · Answer

Read this  supplementary  answer  that is sometimes the answer  to understand where this is going and why some people in this thread complain that  it is still not working   I wrote exactly same code as one of the answers here  But I still had an issue  I placed break point on   var mi   o GetType   GetMethod methodName  BindingFlags NonPublic   BindingFlags Instance      It executed but mi    null  And it continued behavior like this until I did  re-build  on all projects involved  I was unit testing one assembly while the reflection method was sitting in third assembly  It was totally confusing but I used Immediate Window to discover methods and I found that a private method I tried to unit test had old name  I renamed it   This told me that old assembly or PDB is still out there even if unit test project builds - for some reason project it tests didn t built   rebuild  worked

User · Answer

And if you really want to get yourself in trouble  make it easier to execute by writing an extension method   static class AccessExtensions       public static object call this object o  string methodName  params object   args                var mi   o GetType    GetMethod  methodName  System Reflection BindingFlags NonPublic   System Reflection BindingFlags Instance            if  mi    null                return mi Invoke  o  args                     return null            And usage       class Counter               public int count   get  private set            void incr int value    count    value                Test      public void making questionable life choices                 Counter c   new Counter             c call   incr   2                   incr  is private           c call   incr   3           Assert AreEqual  5  c count

User · Answer

Reflection especially on private members is wrong   Reflection breaks type safety  You can try to invoke a method that doesn t exists  anymore   or with the wrong parameters  or with too much parameters  or not enough    or even in the wrong order  this one my favourite       By the way return type could change as well  Reflection is slow    Private members reflection breaks encapsulation principle and thus exposing your code to the following     Increase complexity of your code because it has to handle the inner behavior of the classes  What is hidden should remain hidden  Makes your code easy to break as it will compile but won t run if the method changed its name  Makes the private code easy to break because if it is private it is not intended to be called that way  Maybe the private method expects some inner state before being called    What if I must do it anyway    There are so cases  when you depend on a third party or you need some api not exposed  you have to do some reflection  Some also use it to test some classes they own but that they don t want to change the interface to give access to the inner members just for tests   If you do it  do it right   Mitigate the easy to break    To mitigate the easy to break issue  the best is to detect any potential break by testing in unit tests that would run in a continuous integration build or such  Of course  it means you always use the same assembly  which contains the private members   If you use a dynamic load and reflection  you like play with fire  but you can always catch the Exception that the call may produce    Mitigate the slowness of reflection    In the recent versions of  Net Framework  CreateDelegate beat by a factor 50 the MethodInfo invoke       The following should be done once since this does some reflection var method   this GetType   GetMethod  Draw     itemType     BindingFlags NonPublic   BindingFlags Instance       Here we create a Func that targets the instance of type which has the     Draw ItemType method var draw    Func lt TInput  Output   gt   method CreateDelegate                   typeof Func lt TInput  TOutput   gt    this     draw calls will be around 50x faster than MethodInfo Invoke use draw as a standard Func like that   var res   draw methodParams     Check this post of mine to see benchmark on different method invocations

User · Answer

Microsoft recently modified the reflection API rendering most of these answers obsolete  The following should work on modern platforms  including Xamarin Forms and UWP    obj GetType   GetTypeInfo   GetDeclaredMethod  MethodName   Invoke obj  yourArgsHere     Or as an extension method   public static object InvokeMethod lt T gt  this T obj  string methodName  params object   args        var type   typeof T       var method   type GetTypeInfo   GetDeclaredMethod methodName       return method Invoke obj  args       Note    If the desired method is in a superclass of obj the T generic must be explicitly set to the type of the superclass   If the method is asynchronous you can use await  Task  obj InvokeMethod

User · Answer

Invokes any method despite its protection level on object instance  Enjoy   public static object InvokeMethod object obj  string methodName  params object   methodParams        var methodParamTypes   methodParams  Select p   gt  p GetType    ToArray      new Type            var bindingFlags   BindingFlags NonPublic   BindingFlags Public   BindingFlags Instance   BindingFlags Static      MethodInfo method   null      var type   obj GetType        while  method    null  amp  amp  type    null                method   type GetMethod methodName  bindingFlags  Type DefaultBinder  methodParamTypes  null           type   type BaseType             return method  Invoke obj  methodParams

User · Answer

Could you not just have a different Draw method for each type that you want to Draw   Then call the overloaded Draw method passing in the object of type itemType to be drawn   Your question does not make it clear whether itemType genuinely refers to objects of differing types

User · Answer

I think you can pass it BindingFlags NonPublic where it is the GetMethod method

User · Answer

Are you absolutely sure this can t be done through inheritance   Reflection is the very last thing you should look at when solving a problem  it makes refactoring  understanding your code  and any automated analysis more difficult   It looks like you should just have a DrawItem1  DrawItem2  etc class that override your dynMethod

User · Answer

Simply change your code to use the overloaded version of GetMethod that accepts BindingFlags   MethodInfo dynMethod   this GetType   GetMethod  Draw     itemType       BindingFlags NonPublic   BindingFlags Instance   dynMethod Invoke this  new object     methodParams       Here s the BindingFlags enumeration documentation

[c#] How do I use reflection to invoke a private method?

Examples related to c#

Examples related to .net

Examples related to reflection

Examples related to private-methods