{"id":3957,"date":"2012-07-23T12:23:23","date_gmt":"2012-07-23T12:23:23","guid":{"rendered":"https:\/\/test.simple-talk.com\/uncategorized\/1841\/"},"modified":"2016-07-28T10:51:16","modified_gmt":"2016-07-28T10:51:16","slug":"1841","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/blogs\/1841\/","title":{"rendered":"Inside the DLR – Callsites"},"content":{"rendered":"

The DLR was introduced in .NET 4 to allow dynamic languages, like Python or Ruby, to run on the CLR. The DLR is also used by C# 4, released at the same time, to implement dynamic binding via the dynamic<\/code> keyword. In this post, I’ll be looking at what exactly happens when you issue a dynamically-bound call in C#.<\/p>\n

What is the DLR?<\/h4>\n

The Dynamic Language Runtime isn’t a runtime. At least, not in the same way as the Common Language Runtime. The DLR is a library that runs on the CLR, just like any other arbitary assembly. The library itself is a large and complex beast, with hooks at all levels for various interoperability and extensibility scenarios. In this post, I’ll only be looking at the core functionality – dynamically binding to methods and executing what is found quickly and efficiently.<\/p>\n

Callsites<\/h4>\n

What happens when you compile a dynamically-bound statement in C#? Take the following example. This method contains a single dynamic invocation of something that looks like an instance method called Func<\/code>, that takes two integer arguments: <\/p>\n

public void DynamicCall(dynamic d, int i)\n{\n    d.Func(10, i);\n}<\/pre>\n
  When the C# compiler sees this, and notices that it’s a dynamically bound call, it doesn’t generate a normal method call using call<\/code> or callvirt<\/code> IL instructions. What is actually generates is this:  <\/p>\n
private static class SiteContainer\n{\n    public static CallSite<Action<CallSite, object, int, int>> Site;\n}\n\npublic void DynamicCall(dynamic d, int i)\n{\n    if (SiteContainer.Site == null)\n    {\n        SiteContainer.Site = CallSite<Action<CallSite, object, int, int>>.Create(\n            Microsoft.CSharp.RuntimeBinder.Binder.InvokeMember(\n                CSharpBinderFlags.ResultDiscarded,\n                \"Func\",\n                null,\n                typeof(Program),\n                new CSharpArgumentInfo[] {\n                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),\n                    CSharpArgumentInfo.Create(\n                        CSharpArgumentInfoFlags.Constant\n                            | CSharpArgumentInfoFlags.UseCompileTimeType,\n                        null),\n                    CSharpArgumentInfo.Create(\n                        CSharpArgumentInfoFlags.UseCompileTimeType,\n                        null)\n                }));\n    }\n    \n    SiteContainer.Site.Target(SiteContainer.Site, d, 10, i);\n}<\/pre>\n
Woah. What on earth is going on here?<\/p>\n
Creating callsites<\/h4>\n
The core of the DLR is built around the CallSite<\/code> and CallSite<T><\/code> types. These types provide the bulk of the infrastructure used to implement C# and VB dynamic<\/code>, by providing a sophisticated cache for reflection lookups.<\/p>\n
All the information required to resolve a dynamic call can be split into what is known at compile time, and what is known at runtime. Compile-time information includes the input and output types of the call (as represented by the Action<\/code> or Func<\/code> type argument to CallSite<T><\/code>), the name of what is being invoked, type arguments, argument names, etc. This information is encapsulated in a CallSiteBinder<\/code> that is created the first time a dynamic call is invoked, and stored in the CallSite<\/code>, inside a static site container.<\/p>\n
Since this is compiled and invoked from C#, the C# runtime binder, in the Microsoft.CSharp.dll<\/code> assembly, is used to create and populate a subclass of CallSiteBinder<\/code>. As this particular dynamic call is something that looks like a method invocation, an instance of the CSharpInvokeBinder<\/code> type is passed to Create<\/code>, using the Binder.InvokeMember<\/code> helper method.<\/p>\n
This binder is created using everything it needs to resolve the call at runtime. What exactly is required varies from binder to binder, but the CSharpInvokeBinder<\/code> that is used in this example requires information on: <\/p>\n
    \n
  1. What happens to the return type (in this example, it gets discarded, if there is one)<\/li>\n
  2. The name of the thing being invoked<\/li>\n
  3. Any generic arguments to the method call (in this example, none)<\/li>\n
  4. The type this call is made from (to resolve overloads based on accessibility)<\/li>\n
  5. Information on the arguments (for example, where the value comes from, argument names, whether it’s ref<\/code> or out<\/code>, etc)<\/li>\n<\/ol>\n
    Then, to actually invoke the dynamic call, the actual values used to invoke the callsite each time are passed into the callsite’s Target<\/code> delegate. This delegate handles resolving the right method to call at runtime, using the information stored in the CallSiteBinder<\/code>. How this works is the subject of my next post.<\/p>\n","protected":false},"excerpt":{"rendered":"
    The DLR was introduced in .NET 4 to allow dynamic languages, like Python or Ruby, to run on the CLR. The DLR is also used by C# 4, released at the same time, to implement dynamic binding via the dynamic keyword. In this post, I’ll be looking at what exactly happens when you issue a……<\/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-3957","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\/3957","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=3957"}],"version-history":[{"count":7,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/3957\/revisions"}],"predecessor-version":[{"id":42193,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/3957\/revisions\/42193"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=3957"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=3957"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=3957"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=3957"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}