{"id":62,"date":"2009-11-14T19:52:26","date_gmt":"2009-11-14T19:52:26","guid":{"rendered":"http:\/\/www.thewiredguy.com\/wordpress\/?p=62"},"modified":"2009-11-14T19:52:26","modified_gmt":"2009-11-14T19:52:26","slug":"just-another-way-to-analyse-code-behaviour-in-my-humble-opinion","status":"publish","type":"post","link":"https:\/\/inullable.in\/blog\/?p=62","title":{"rendered":"Just another way to analyse code behaviour – In my humble opinion"},"content":{"rendered":"

Last week, a good friend<\/a> of mine posted a question on his blog<\/a>, which track backs to Eric Lippert’s<\/a> blog post Simple names are not so simple<\/a>. <\/p>\n

Side Note<\/u>: I am big fan of that blog, its awesome and enlightening<\/p>\n

Well, here is an excerpt of that post:<\/p>\n

\n

Check out the code below:<\/p>\n

using System.Linq;
class Program
{
  static void Main()
  { 
      int[] data = { 1, 2, 3, 1, 2, 1 };
      foreach (var m in from m in data orderby m select m<\/strong>)
            System.Console.Write(m);
  }
}<\/p>\n

\"frustration3\"<\/a><\/p>\n

Now, the question is:<\/p>\n

  Is this code valid or not?? <\/p>\n

  If valid, how? <\/p>\n

  If not valid, why? <\/p>\n

(Source: Eric Lippert’s Blog)<\/strong>  <\/p>\n<\/blockquote>\n

So, I worked on that problem posted some comments there, and presenting it again here in the form of a post. <\/p>\n

The moment I read the problem, things started running in my mind around <\/p>\n

var m in from m in data orderby m select m<\/strong> <\/p>\n

as you can perceive, m is being used in two different contexts, first as a enumerator in LINQ query: " from m in data orderby m select m " <\/p>\n

and the "var m " part in foreach. The question here: Can that possibly work?<\/strong> <\/p>\n

Luckily, I was honing my skills in Reflection (System.Reflection) at that time, I get across a phrase in this book about foreach block (it says Cs compiler adds some temp. variable to smooth out operations like <\/p>\n

\n

a += 2; <\/p>\n

or <\/p>\n

foreach(var m in M){}<\/p>\n<\/blockquote>\n

along with that there was also a prenotion that something "magical" happens when you encounter such situation, and whole code behaves like it is working in scopes (The blocks of { }). <\/p>\n

So, the possible explanation, that came to my mind about this problem was : <\/p>\n

the thing "var m in from m in data orderby m select m<\/strong>" <\/p>\n

breaks up into two scopes : { var m } in { from m in data orderby m select m } <\/p>\n

or in other terms var m in {from m in data orderby m select m} <\/p>\n

We can proceed to further abstractions <\/p>\n

var m = {from m’ in data order by m’ select m’} <\/p>\n

that would eventually looks like <\/p>\n

var m in m’ \/\/ where m’ is enumerable <\/p>\n

[ \ud83d\ude2e Oops, m’ is not a valid name for a variable, but good for human beings] <\/p>\n

  <\/p>\n

OK! I have a possible explanation, now how to confirm that its right and not a conjecture. <\/p>\n

I fired RSS Bandit<\/a> and rushed to Eric Lippert’s blog… <\/p>\n

\n

<digression> <\/p>\n

x-( <\/p>\n

Though I like reading blogs, but Internet, blogs and twitter (a.k.a Knowledge Supernova) provide so much information to absorb, I occasionally procrastinate reading RSS and let them aggregate scheduled to be read on weekends, after I am exhausted  from celebrating TGIF and TGIS, so I missed the Eric Lipperts blog post that mentioned this problem \ud83d\ude41 <\/p>\n

<\/digression> <\/p>\n<\/blockquote>\n

I fired RSS Bandit<\/a> and rushed to Eric Lippert’s blog and tried to find out where this problem is being discussed, and I failed to figure its occurrence since it was phrased at the end of blog post and I was flipping over top. <\/p>\n

This made me more curious to find the real answer, so I fired VS, hit Ctrl + C, Ctrl+ V and some tabs, ran it and yes it was running fine, just like you would expect. <\/p>\n

\"image\"<\/a><\/p>\n

But, that doesn’t answer actually what concerns me: Is my explanation is completely right?<\/p>\n

Suddenly, an idea struck me: Utilize Reflection<\/p>\n

Advantage was that, it will cause extra practice much needed to get comfortable with reflection<\/p>\n

So, I started writing code:<\/p>\n

First, I wrote <\/p>\n

using<\/span> System.Linq;\nusing<\/span> System.Reflection;\nusing<\/span> System.Reflection.Emit;\nusing<\/span> System.Collections.Generic;\n    class<\/span> Program \n    { \n      static<\/span> void<\/span> Main() \n      {  \n         int<\/span>[] data = { 1, 2, 3, 1, 2, 1 }; \n\n          foreach<\/span> (var m in<\/span> from m in<\/span> data orderby m select m)\n             System.Console.Write(m); \n\n          new<\/span> Analyse().Run(); \n\n          System.Console.ReadKey();\n      } \n    } \n\n    class<\/span> Analyse\n    {\n        public<\/span> void<\/span> Run()\n        {\n            Assembly asm = Assembly.GetAssembly(typeof<\/span>(Program));\n            MethodBody mb = asm.EntryPoint.GetMethodBody();\n            System.Console.WriteLine("nMethod Name: "<\/span>+asm.EntryPoint.Name);\n            foreach<\/span> (var locals in<\/span> mb.LocalVariables)\n            {\n                System.Console.WriteLine("n {0}"<\/span>, locals.LocalType.FullName);\n            }\n            System.Console.ReadKey();\n        }\n    }<\/pre>\n
The Run method would actually list all the variables that are present after actual compilation, this will include the variables we have declared explicitly or implicitly as well as other variables introduced by compiler to store temporary results and perform calculations.<\/p>\n
If you run it you will get output:<\/p>\n
\n
  <\/p>\n
111223 <\/p>\n
Method Name: Main <\/p>\n
System.Int32[] <\/p>\n
System.Int32 <\/p>\n
System.Collections.Generic.IEnumerator`1[[System.Int32, mscorlib, Version=2.0.0.
\n    
0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] <\/p>\n
System.Boolean<\/p>\n<\/blockquote>\n
Ok! Let me set a context, before I go for explaining things here <\/p>\n
change the body of main() method inside program class to<\/p>\n
using<\/span> System.Linq;\nusing<\/span> System.Reflection;\nusing<\/span> System.Reflection.Emit;\nusing<\/span> System.Collections.Generic;\n    \n    class<\/span> Program \n    { \n      static<\/span> void<\/span> Main() \n      {  \n         int<\/span>[] data = { 1, 2, 3, 1, 2, 1 };\n        \n          foreach<\/span> (var num in<\/span> data)\n          {\n              System.Console.Write(num);\n          }\n\n          new<\/span> Analyse().Run();\n\n          System.Console.ReadKey();\n      } \n    }\n... contd.<\/pre>\n