{"id":3115,"date":"2010-07-27T18:15:00","date_gmt":"2010-07-27T18:15:00","guid":{"rendered":"https:\/\/test.simple-talk.com\/uncategorized\/introduction-to-open-instance-delegates\/"},"modified":"2016-07-28T10:50:06","modified_gmt":"2016-07-28T10:50:06","slug":"introduction-to-open-instance-delegates","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/blogs\/introduction-to-open-instance-delegates\/","title":{"rendered":"Introduction to open instance delegates"},"content":{"rendered":"

Creating a delegate to a method is normally quite a cheap operation. However, there are some reflection-based situations where you have to create a delegate dynamically using Delegate.CreateDelegate<\/code><\/a>. As you can expect, such a method is many times slower than using the type-safe delegate constructor. Using open instance delegates can help alleviate this performance penalty.<\/p>\n

For this post, I’ll be using these classes in the examples: <\/p>\n

delegate void AddDelegate(int value);\n\nclass Adder {\n\n    public Adder(int value) {\n        Value = value;\n    }\n    \n    public int Value { get; private set; }\n\n    public void Add(int valueToAdd) {\n        int result = Value + valueToAdd;\n        Console.WriteLine(\"{0}+{1}={2}\", Value, valueToAdd, result);\n    }\n}<\/pre>\n<\/p>\n
Creating a delegate<\/b><\/p>\n
The standard way of creating a delegate to an instance method is the following (I’ve expanded out the syntax for clarity): <\/p>\n
Adder add5 = new Adder(5);\nAddDelegate d = new AddDelegate(add5.Add);<\/pre>\n
  This simply calls the compiler-created constructor on the AddDelegate<\/code> type. In situations where you need to create the delegate dynamically, you need to use the Delegate.CreateDelegate<\/code> methods instead: <\/p>\n
Adder add5 = new Adder(5);\n\nMethodInfo addMethodInfo = typeof(Adder).GetMethod(\"Add\");\nAddDelegate d = (AddDelegate)\n    Delegate.CreateDelegate(typeof(AddDelegate), add5, addMethodInfo);<\/pre>\n
  In this example, in the arguments to CreateDelegate<\/code>, we’re specifying the type of delegate to create, the instance of Adder<\/code> the method is to be run on, and the MethodInfo<\/code> of the method to run as the delegate.<\/p>\n
The hidden ‘this’ pointer<\/b><\/p>\n
The reason we need to specify the firstArgument<\/code> parameter to CreateDelegate<\/code> is that every instance method invocation requires a reference to the object we’re calling the method on (the ‘this’ pointer) to be the first argument it is called with, before all the declared method arguments (for Add<\/code>, the value<\/code> parameter). What happens if we don’t<\/i> specify this argument when creating the delegate?  <\/p>\n
AddDelegate d = (AddDelegate)\n    Delegate.CreateDelegate(typeof(AddDelegate), null, addMethodInfo);<\/pre>\n
  Not a lot it would seem; trying to invoke such a delegate throws a NullReferenceException<\/code> if it’s a virtual method or accesses the ‘this’ instance (which most instance methods do). However, things get a lot more interesting if we change the delegate signature slightly:  <\/p>\n
delegate void OpenAddDelegate(Adder explicitThis, int value);\n\nOpenAddDelegate add = (OpenAddDelegate)\n    Delegate.CreateDelegate(typeof(OpenAddDelegate), null, addMethodInfo);<\/pre>\n
 Here, we’re explicitly specifying the hidden ‘this’ pointer of the Add<\/code> method as part of the delegate signature. A delegate to an instance method created in this way is called an open instance delegate<\/i>, and by specifying the ‘this’ argument explicitly we can use this delegate instance to call the same method on multiple instances:  <\/p>\n
Adder add3 = new Adder(3);\nAdder add4 = new Adder(4);\n\nMethodInfo addMethodInfo = typeof(Adder).GetMethod(\"Add\");\nOpenAddDelegate d = (OpenAddDelegate)\n    Delegate.CreateDelegate(typeof(OpenAddDelegate), null, addMethodInfo);\n\nd(add3, 2);\nd(add3, 3);\nd(add4, 5);\nd(add4, 6);<\/pre>\n<\/p>\n
So?<\/b><\/p>\n
Such a delegate may not seem immediately useful, but this can be crucial when performance is critical. Creating a delegate with CreateDelegate<\/code> is an expensive operation, and if you have to call the same delegated method on many thousands of objects it can be a killer to create a new delegate instance for each object. To demonstrate this, I ran 3 tests that called a delegate of the Add<\/code> method on 1,000,000 Adder<\/code> objects, creating the using the normal delegate constructor, a closed CreateDelegate<\/code> call for each object, and a single open instance delegate:<\/p>\n
Delegate constructor:     0.1115875s\nClosed instance delegate: 4.6705494s\nOpen instance delegate:   0.0621132s<\/pre>\n
Such results speak for themselves. Although rather a niche feature, when calling the same method on many thousands of separate instances, open instance delegates can improve the performance of such code many times over.<\/p>\n
Note: This also works as expected for delegates to virtual and interface methods. You can also use the generic Func<\/code> and Action<\/code> delegates if you wish, rather than defining your own delegate type, as long as the type of the first argument of the delegate is compatible with the type containing the instance method you’re calling.<\/p>\n","protected":false},"excerpt":{"rendered":"
Creating a delegate to a method is normally quite a cheap operation. However, there are some reflection-based situations where you have to create a delegate dynamically using Delegate.CreateDelegate. As you can expect, such a method is many times slower than using the type-safe delegate constructor. Using open instance delegates can help alleviate this performance penalty….…<\/p>\n","protected":false},"author":186659,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[2],"tags":[],"coauthors":[],"class_list":["post-3115","post","type-post","status-publish","format-standard","hentry","category-blogs"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/3115","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/186659"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=3115"}],"version-history":[{"count":1,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/3115\/revisions"}],"predecessor-version":[{"id":25082,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/3115\/revisions\/25082"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=3115"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=3115"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=3115"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=3115"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}