I want to know what exactly is the difference between CLR &amp; CLI? From whatever I have read so far, it seems to indicate that CLI is a subset of CLR. But isn&#39;t everything in the CLR mandatory? What exactly may be left out of CLR to create a CLI?

CLR and CLI - What is the difference?

Could someone tell me what the stack capacity is in C#.

I am trying to form a 3D mesh closed object using an array of 30,000 items.

Stack capacity in C#

What is the difference between the JIT compiler and CLR? If you compile your code to il and CLR runs that code then what is the JIT doing? How has JIT compilation changed with the addition of generics to the CLR?

CLR vs JIT

I&#39;m interested in investigating Clojure on the CLR. I see that there is a [port](http://github.com/richhickey/clojure-clr)--but I&#39;m always a bit leery of these second-class citizens (i.e. they don&#39;t have the stability or functionality of the original). I&#39;d less inclined to spend much time at this point if generally people find Clojure on the CLR immature--I simply don&#39;t have the time or energy to fight a bunch of problems at this point. On the other hand, if Clojure on the CLR seems well-baked, I&#39;d start diving in today!

Has anyone real-world experience with Clojure on the CLR?

Any advice and/or other help getting started with the CLR version would be appreciated too.



Clojure on the CLR

Although I know the terms I used to forget the differences sometimes...So just to maintain a place for reference...Thanks all for your answers.

.NET vs ASP.NET vs CLR vs ASP

I have the following code:

    int intNumber1 = 100;
    object intNumber2 = 100;
    bool areNumberOfTheSameType = intNumber1.GetType() == intNumber2.GetType(); // TRUE
    bool areEqual = intNumber1.Equals(intNumber2); // TRUE
            
    long longNumber1 = (long) intNumber1; // OK
    long longNumber2 = (long) intNumber2; // InvalidCastException. Why?

Why doesn&#39;t the second cast work? I realize that it might be because the object doesn’t have an explicit cast to a long, but if we look at its type on runtime it is `System.Int32`.

If I use `var` or `dynamic` instead of `object`, it works.

Any thoughts?

Strange casting behaviour. Cannot cast object (int) to long

I would like to gather as much information as possible regarding API versioning in .NET/CLR, and specifically how API changes do or do not break client applications. First, let&#39;s define some terms:

__API change__ - a change in the publicly visible definition of a type, including any of its public members. This includes changing type and member names, changing base type of a type, adding/removing interfaces from list of implemented interfaces of a type, adding/removing members (including overloads), changing member visibility, renaming method and type parameters, adding default values for method parameters, adding/removing attributes on types and members, and adding/removing generic type parameters on types and members (did I miss anything?). This does not include any changes in member bodies, or any changes to private members (i.e. we do not take into account Reflection).

__Binary-level break__ - an API change that results in client assemblies compiled against older version of the API potentially not loading with the new version. Example: changing method signature, even if it allows to be called in the same way as before (ie: void to return type / parameter default values overloads).

__Source-level break__ - an API change that results in existing code written to compile against older version of the API potentially not compiling with the new version. Already compiled client assemblies work as before, however. Example: adding a new overload that can result in ambiguity in method calls that were unambiguous previous.

__Source-level quiet semantics change__ - an API change that results in existing code written to compile against older version of the API quietly change its semantics, e.g. by calling a different method. The code should however continue to compile with no warnings/errors, and previously compiled assemblies should work as before. Example: implementing a new interface on an existing class that results in a different overload being chosen during overload resolution.

The ultimate goal is to catalogize as many breaking and quiet semantics API changes as possible, and describe exact effect of breakage, and which languages are and are not affected by it. To expand on the latter: while some changes affect all languages universally (e.g. adding a new member to an interface will break implementations of that interface in any language), some require very specific language semantics to enter into play to get a break. This most typically involves method overloading, and, in general, anything having to do with implicit type conversions. There doesn&#39;t seem to be any way to define the &quot;least common denominator&quot; here even for CLS-conformant languages (i.e. those conforming at least to rules of &quot;CLS consumer&quot; as defined in CLI spec) - though I&#39;ll appreciate if someone corrects me as being wrong here - so this will have to go language by language. Those of most interest are naturally the ones that come with .NET out of the box: C#, VB and F#; but others, such as IronPython, IronRuby, Delphi Prism etc are also relevant. The more of a corner case it is, the more interesting it will be - things like removing members are pretty self-evident, but subtle interactions between e.g. method overloading, optional/default parameters, lambda type inference, and conversion operators can be very surprising at times.

A few examples to kickstart this:

Adding new method overloads
---
Kind: source-level break

Languages affected: C#, VB, F#

API before change:

    public class Foo
    {
        public void Bar(IEnumerable x);
    }

API after change:

    public class Foo
    {
        public void Bar(IEnumerable x);
        public void Bar(ICloneable x);
    }

Sample client code working before change and broken after it:

    new Foo().Bar(new int[0]);

Adding new implicit conversion operator overloads
---
Kind: source-level break.

Languages affected: C#, VB

Languages not affected: F#

API before change:

    public class Foo
    {
        public static implicit operator int ();
    }

API after change:


    public class Foo
    {
        public static implicit operator int ();
        public static implicit operator float ();
    }

Sample client code working before change and broken after it:

    void Bar(int x);
    void Bar(float x);
    Bar(new Foo());
    
Notes: F# is not broken, because it does not have any language level support for overloaded operators, neither explicit nor implicit - both have to be called directly as `op_Explicit` and `op_Implicit` methods.

Adding new instance methods
---

Kind: source-level quiet semantics change.

Languages affected: C#, VB

Languages not affected: F#

API before change:

    public class Foo
    {
    }

API after change:

    public class Foo
    {
        public void Bar();
    }

Sample client code that suffers a quiet semantics change:

    public static class FooExtensions
    {
        public void Bar(this Foo foo);
    }

    new Foo().Bar();
    
Notes: F# is not broken, because it does not have language level support for `ExtensionMethodAttribute`, and requires CLS extension methods to be called as static methods. 

A definitive guide to API-breaking changes in .NET

I just want to clarify one thing. This is not a question on which one is better, that part I leave to someone else to discuss. I don&#39;t care about it.
I&#39;ve been asked this question on my job interview and I thought it might be useful to learn a bit more.

These are the ones I could come up with:

- Java is &quot;platform independent&quot;. Well nowadays you could say there is the [Mono][1] project so C# could be considered too but
I believe it is a bit exaggerating. Why? Well, when a new release of Java is done it is simultaneously available on all platforms it supports, on the other hand how many features of C# 3.0 are still missing in the Mono implementation? Or is it really [CLR][2] vs. [JRE][3] that we should compare here?
- Java doesn&#39;t support events and delegates. As far as I know.
- In Java all methods are virtual
- Development tools: I believe there isn&#39;t such a tool yet as Visual Studio. Especially if you&#39;ve worked with team editions you&#39;ll know what I mean.

Please add others you think are relevant.

Update:
Just popped up my mind, Java doesn&#39;t have something like custom attributes on classes, methods etc. Or does it?

  [1]: http://en.wikipedia.org/wiki/Mono_%28software%29
  [2]: http://en.wikipedia.org/wiki/Common_Language_Runtime
  [3]: http://en.wikipedia.org/wiki/JRE


What are major differences between C# and Java?

All code written in .NET languages compiles to MSIL, but are there specific tasks / operations that you can do only using MSIL directly?

Let us also have things done easier in MSIL than C#, VB.NET, F#, j# or any other .NET language.

So far we have this:

1. Tail recursion
2. Generic Co/Contravariance (allowed in C# 4 and VB 10)
3. Overloads which differ only in return types
4. Override access modifiers
5. Have a class which cannot inherit from System.Object
6. Filtered exceptions (allowed in VB, and C# 6)
7. Calling a virtual method of the current static class type.
8. Get a handle on the boxed version of a value type.
9. Do a try/fault.
10. Usage of forbidden names.
11. [Define your own parameterless constructors for value types][1].
12. Define events with a `raise` element.
13. Some conversions allowed by the CLR but not by C#.
14. Make a non `main()` method as the `.entrypoint`.
15. work with the native `int` and native `unsigned int` types directly.
16. Play with transient pointers
17. emitbyte directive in  MethodBodyItem
18. Throw and catch non System.Exception types
19. Inherit Enums (Unverified)
20. You can treat an array of bytes as a (4x smaller) array of ints.
21. You can have a field/method/property/event all have the same name(Unverified).
22. You can branch back into a try block from its own catch block.
23. You have access to the famandassem access specifier (`protected internal` is fam&lt;strong&gt;or&lt;/strong&gt;assem, but now allowed in C# 7.2 and VB 15.5)
24. Direct access to the `&lt;Module&gt;` class for defining global functions, or a module initializer.
25. Create and use non-zero-bound 1-based arrays
26. Create open-instance and closed-static delegates, and delegates of getters/setters
27. Swap two values without using a temp variable
28. Explicit interface implementation with any name, and implementing two interface functions in one (can be done in VB)
29. [Declaring `vtfixup` (the equivalent of `extern` in C)][2]
30. Specifying arbitrary `modopt` or `modreq`


  [1]: http://msmvps.com/blogs/jon_skeet/archive/2008/12/10/value-types-and-parameterless-constructors.aspx
  [2]: https://stackoverflow.com/questions/4818850/is-is-possible-to-export-functions-from-a-c-sharp-dll-like-in-vs-c

What can you do in MSIL that you cannot do in C# or VB.NET?

The sample code below occurred naturally. Suddenly my code thew a very nasty-sounding `FatalExecutionEngineError` exception. I spent a good 30 minutes trying to isolate and minimize the culprit sample. Compile this using Visual Studio 2012 as a console app:

    class A&lt;T&gt;
    {
        static A() { }

        public A() { string.Format(&quot;{0}&quot;, string.Empty); }
    }

    class B
    {
        static void Main() { new A&lt;object&gt;(); }
    }

Should produce this error on .NET framework 4 and 4.5:

![FatalExecutionException screenshot][1]

Is this a known bug, what is the cause and what can I do to mitigate it? My current work around is to not use `string.Empty`, but am I barking up the wrong tree? Changing anything about that code makes it function as you would expect - for example removing the empty static constructor of `A`, or changing the type paramter from `object` to `int`.

I tried this code on my laptop and it didn&#39;t complain. However, I did try my main app and it crashed on the laptop as well. I must have mangled away something when reducing the problem, I&#39;ll see if I can figure out what that was.

My laptop crashed with the same code as above, with framework 4.0, but main crashes even with 4.5. Both systems are using VS&#39;12 with latest updates (July?).

**More information**:

- IL Code (compiled Debug/Any CPU/4.0/VS2010 (not that IDE should matter?)): http://codepad.org/boZDd98E
- Not seen VS 2010 with 4.0. Not crashing with/without optimizations, different target CPU, debugger attached/not attached, etc. - [Tim Medora][2]
- Crashes in 2010 if I use AnyCPU, is fine in x86. Crashes in Visual Studio 2010 SP1, using Platform Target = AnyCPU, but fine with Platform Target=x86. This machine has VS2012RC installed as well so 4.5 possibly doing an in-place replacement.  Use AnyCPU and TargetPlatform = 3.5 then it doesn&#39;t crash so looks like a regression in the Framework.- [colinsmith][3]
- Cannot reproduce on x86, x64 or AnyCPU in VS2010 with 4.0. – [Fuji][4]
- Only happens for x64, (2012rc, Fx4.5) - [Henk Holterman][5]
- VS2012 RC on Win8 RP. Initially Not seeing this MDA when targeting .NET 4.5. When switched to targeting .NET 4.0 the MDA appeared. Then after switching back to .NET 4.5 the MDA remains. - [Wayne][6]


  [1]: http://i.stack.imgur.com/8NxRZ.gif
  [2]: https://stackoverflow.com/users/453277/tim-medora
  [3]: https://stackoverflow.com/users/473194/colinsmith
  [4]: https://stackoverflow.com/users/408182/fuji
  [5]: https://stackoverflow.com/users/60761/henk-holterman
  [6]: https://stackoverflow.com/users/18482/wayne

What&#39;s the cause of this FatalExecutionEngineError in .NET 4.5 beta?

Firstly, I apologize for the length of this question. 

I am the author of [IronScheme][1]. Recently I have been working hard on emitting decent debug info, so that I can use the &#39;native&#39; .NET debugger. 

While this has been partly successful, I am running into some teething problems.

The first problem is related to stepping.

Due to Scheme being an expression language, everything tends to be wrapped in parenthesis, unlike the major .NET languages which seems to be statement (or line) based.

The original code (Scheme) looks like:

    (define (baz x)
      (cond
        [(null? x) 
          x]
        [(pair? x) 
          (car x)]
        [else
          (assertion-violation #f &quot;nooo&quot; x)]))

I have on purpose laid out each expression on a newline.

The emitted code transforms to C# (via ILSpy) looks like:

    public static object ::baz(object x)
    {
      if (x == null)
      {
        return x;
      }
      if (x is Cons)
      {
        return Builtins.Car(x);
      }
      return #.ironscheme.exceptions::assertion-violation+(
         RuntimeHelpers.False, &quot;nooo&quot;, Builtins.List(x));
    }

As you can see, pretty simple. 

Note: If the code was transformed into a conditional expression (?:) in C#, the whole thing would just be one debug step, keep that in mind.

Here is IL output with source and line numbers:

      .method public static object  &#39;::baz&#39;(object x) cil managed
      {
        // Code size       56 (0x38)
        .maxstack  6
        .line 15,15 : 1,2 &#39;&#39;
    //000014: 
    //000015: (define (baz x)
        IL_0000:  nop
        .line 17,17 : 6,15 &#39;&#39;
    //000016:   (cond
    //000017:     [(null? x) 
        IL_0001:  ldarg.0
        IL_0002:  brtrue     IL_0009
    
        .line 18,18 : 7,8 &#39;&#39;
    //000018:       x]
        IL_0007:  ldarg.0
        IL_0008:  ret
    
        .line 19,19 : 6,15 &#39;&#39;
    //000019:     [(pair? x) 
        .line 19,19 : 6,15 &#39;&#39;
        IL_0009:  ldarg.0
        IL_000a:  isinst [IronScheme]IronScheme.Runtime.Cons
        IL_000f:  ldnull
        IL_0010:  cgt.un
        IL_0012:  brfalse    IL_0020
    
        IL_0017:  ldarg.0
        .line 20,20 : 7,14 &#39;&#39;
    //000020:       (car x)]
        IL_0018:  tail.
        IL_001a:  call object [IronScheme]IronScheme.Runtime.Builtins::Car(object)
        IL_001f:  ret
    
        IL_0020:  ldsfld object 
             [Microsoft.Scripting]Microsoft.Scripting.RuntimeHelpers::False
        IL_0025:  ldstr      &quot;nooo&quot;
        IL_002a:  ldarg.0
        IL_002b:  call object [IronScheme]IronScheme.Runtime.Builtins::List(object)
        .line 22,22 : 7,40 &#39;&#39;
    //000021:     [else
    //000022:       (assertion-violation #f &quot;nooo&quot; x)]))
        IL_0030:  tail.
        IL_0032:  call object [ironscheme.boot]#::
           &#39;ironscheme.exceptions::assertion-violation+&#39;(object,object,object)
        IL_0037:  ret
      } // end of method &#39;eval-core(033)&#39;::&#39;::baz&#39;

*Note:* To prevent the debugger from simply highlighting the entire method, I make the method entry point just 1 column wide.

As you can see, each expression maps correctly to a line.

Now the problem with stepping (tested on VS2010, but same/similar issue on VS2008):

These are with `IgnoreSymbolStoreSequencePoints` not applied.

1. Call baz with null arg, it works correctly. (null? x) followed by x.
2. Call baz with Cons arg, it works correctly. (null? x) then (pair? x) then (car x).
3. Call baz with other arg, it fails. (null? x) then (pair? x) then (car x) then (assertion-violation ...).

When applying `IgnoreSymbolStoreSequencePoints` (as recommended):

1. Call baz with null arg, it works correctly. (null? x) followed by x.
2. Call baz with Cons arg, it fails. (null? x) then (pair? x).
3. Call baz with other arg, it fails. (null? x) then (pair? x) then (car x) then (assertion-violation ...).

I also find in this mode that some lines (not shown here) are incorrectly highlighted, they are off by 1.

Here are some ideas what could be the causes:

- Tailcalls confuses the debugger
- Overlapping locations (not shown here) confuses the debugger (it does so very well when setting a breakpoint)
- ????

The second, but also serious, issue is the debugger failing to break/hit breakpoints in some cases.

The only place where I can get the debugger to break correctly (and consistantly), is at the method entry point. 

The situation gets a bit better when `IgnoreSymbolStoreSequencePoints` is not applied.


**Conclusion**

It might be that the VS debugger is just plain buggy  :(


**References:**

1. https://stackoverflow.com/questions/4357420/making-a-clr-net-language-debuggable


**Update 1:**

Mdbg does not work for 64-bit assemblies. So that is out. I have no more 32-bit machines to test it on. *Update:* I am sure this is no big problem, does anyone have a fix? *Edit:* Yes, silly me, just start mdbg under the x64 command prompt :)

**Update 2:**

I have created a C# app, and tried to dissect the line info. 

My findings:

- After any `brXXX` instruction you need to have a sequence point (if not valid aka &#39;#line hidden&#39;, emit a `nop`).
- Before any `brXXX` instruction,  emit a &#39;#line hidden&#39; and a `nop`.

Applying this, does not however fix the issues (alone?). 

But adding the following, gives the desired result  :)

- After `ret`, emit a &#39;#line hidden&#39; and a `nop`.

This is using the mode where `IgnoreSymbolStoreSequencePoints` is not applied. When applied, some steps are still skipped :(

Here is the IL output when above has been applied:

      .method public static object  &#39;::baz&#39;(object x) cil managed
      {
        // Code size       63 (0x3f)
        .maxstack  6
        .line 15,15 : 1,2 &#39;&#39;
        IL_0000:  nop
        .line 17,17 : 6,15 &#39;&#39;
        IL_0001:  ldarg.0
        .line 16707566,16707566 : 0,0 &#39;&#39;
        IL_0002:  nop
        IL_0003:  brtrue     IL_000c
    
        .line 16707566,16707566 : 0,0 &#39;&#39;
        IL_0008:  nop
        .line 18,18 : 7,8 &#39;&#39;
        IL_0009:  ldarg.0
        IL_000a:  ret
    
        .line 16707566,16707566 : 0,0 &#39;&#39;
        IL_000b:  nop
        .line 19,19 : 6,15 &#39;&#39;
        .line 19,19 : 6,15 &#39;&#39;
        IL_000c:  ldarg.0
        IL_000d:  isinst     [IronScheme]IronScheme.Runtime.Cons
        IL_0012:  ldnull
        IL_0013:  cgt.un
        .line 16707566,16707566 : 0,0 &#39;&#39;
        IL_0015:  nop
        IL_0016:  brfalse    IL_0026
    
        .line 16707566,16707566 : 0,0 &#39;&#39;
        IL_001b:  nop
        IL_001c:  ldarg.0
        .line 20,20 : 7,14 &#39;&#39;
        IL_001d:  tail.
        IL_001f:  call object [IronScheme]IronScheme.Runtime.Builtins::Car(object)
        IL_0024:  ret
    
        .line 16707566,16707566 : 0,0 &#39;&#39;
        IL_0025:  nop
        IL_0026:  ldsfld object 
          [Microsoft.Scripting]Microsoft.Scripting.RuntimeHelpers::False
        IL_002b:  ldstr      &quot;nooo&quot;
        IL_0030:  ldarg.0
        IL_0031:  call object [IronScheme]IronScheme.Runtime.Builtins::List(object)
        .line 22,22 : 7,40 &#39;&#39;
        IL_0036:  tail.
        IL_0038:  call object [ironscheme.boot]#::
          &#39;ironscheme.exceptions::assertion-violation+&#39;(object,object,object)
        IL_003d:  ret
    
        .line 16707566,16707566 : 0,0 &#39;&#39;
        IL_003e:  nop
      } // end of method &#39;eval-core(033)&#39;::&#39;::baz&#39;

**Update 3:**

Problem with above &#39;semi-fix&#39;. Peverify reports errors on all methods due to the `nop` after `ret`. I dont understand the problem really. How can a `nop` break verification after a `ret`. It is like dead code (except that it is NOT even code) ... Oh well, experimentation continues.

**Update 4:**

Back at home now, removed the &#39;unverifiable&#39; code, running on VS2008 and things are a lot worse. Perhaps running unverifiable code for the sake of proper debugging might be the answer. In &#39;release&#39; mode, all output would still be verifiable.

**Update 5:**

I have now decided my above idea is the only viable option for now. Although the generated code is unverifiable, I have yet to find any `VerificationException`&#39;s. I dont know what the impact will be on the end user with this scenario. 

As a bonus, my second issue has also be solved. :)

Here is a little [screencast][2] of what I ended up with. It hits breakpoints, does proper stepping (in/out/over), etc. All in all, the desired effect.

I, however, am still not accepting this as the way to do it. It feel overly-hacky to me. Having a confirmation on the real issue would be nice.

**Update 6:**

Just had the change to test the code on VS2010, there seems to be some problems:

1. &lt;strike&gt;The first call now does not step correctly. (assertion-violation ...) is hit. Other cases works fine.&lt;/strike&gt; Some old code emitted unnecessary positions. Removed the code, works as expected. :)
2. More seriously, breakpoints fail on the second invocation of the program (using in-memory compilation, dumping assembly to file seems to make breakpoints happy again).

Both these cases work correctly under VS2008. The main difference is that under VS2010, the entire application is compiled for .NET 4 and under VS2008, compiles to .NET 2. Both running 64-bit.

**Update 7:**

Like mentioned, I got mdbg running under 64-bit. Unfortunately, it also have the breakpoint issue where it fails to break if I rerun the program (this implies it gets recompiled, so not using the same assembly, but still using the same source).

**Update 8:**

I have [filed a bug][3] at the MS Connect site regarding the breakpoint issue. 

Update: Fixed

**Update 9:**

After some long thinking, the only way to make the debugger happy seems to be doing SSA, so every step can be isolated and sequential. I am yet to prove this notion though. But it seems logical. Obviously, cleaning up temps from SSA will break debugging, but that is easy to toggle, and leaving them does not have much overhead.


  [1]: http://ironscheme.codeplex.com/
  [2]: http://www.screencast.com/t/Tjrkjl7By
  [3]: https://connect.microsoft.com/VisualStudio/feedback/details/684089/
  [4]: https://connect.microsoft.com/VisualStudio/feedback/details/551765

Making your .NET language step correctly in the debugger

In [Noda Time][1] v2, we&#39;re moving to nanosecond resolution. That means we can no longer use an 8-byte integer to represent the whole range of time we&#39;re interested in. That has prompted me to investigate the memory usage of the (many) structs of Noda Time, which has in turn led me to uncover a slight oddity in the CLR&#39;s alignment decision.

Firstly, I realize that this *is* an implementation decision, and that the default behaviour could change at any time. I realize that I *can* modify it using [`[StructLayout]`][2] and [`[FieldOffset]`][3], but I&#39;d rather come up with a solution which didn&#39;t require that if possible.

My core scenario is that I have a `struct` which contains a reference-type field and two other value-type fields, where those fields are simple wrappers for `int`. I had *hoped* that that would be represented as 16 bytes on the 64-bit CLR (8 for the reference and 4 for each of the others), but for some reason it&#39;s using 24 bytes. I&#39;m measuring the space using arrays, by the way - I understand that the layout may be different in different situations, but this felt like a reasonable starting point.

Here&#39;s a sample program demonstrating the issue:

    using System;
    using System.Runtime.InteropServices;
    
    #pragma warning disable 0169
    
    struct Int32Wrapper
    {
        int x;
    }
    
    struct TwoInt32s
    {
        int x, y;
    }
    
    struct TwoInt32Wrappers
    {
        Int32Wrapper x, y;
    }
    
    struct RefAndTwoInt32s
    {
        string text;
        int x, y;
    }
    
    struct RefAndTwoInt32Wrappers
    {
        string text;
        Int32Wrapper x, y;
    }    
    
    class Test
    {
        static void Main()
        {
            Console.WriteLine(&quot;Environment: CLR {0} on {1} ({2})&quot;,
                Environment.Version,
                Environment.OSVersion,
                Environment.Is64BitProcess ? &quot;64 bit&quot; : &quot;32 bit&quot;);
            ShowSize&lt;Int32Wrapper&gt;();
            ShowSize&lt;TwoInt32s&gt;();
            ShowSize&lt;TwoInt32Wrappers&gt;();
            ShowSize&lt;RefAndTwoInt32s&gt;();
            ShowSize&lt;RefAndTwoInt32Wrappers&gt;();
        }
        
        static void ShowSize&lt;T&gt;()
        {
            long before = GC.GetTotalMemory(true);
            T[] array = new T[100000];
            long after  = GC.GetTotalMemory(true);        
            Console.WriteLine(&quot;{0}: {1}&quot;, typeof(T),
                              (after - before) / array.Length);
        }
    }

And the compilation and output on my laptop:

    c:\Users\Jon\Test&gt;csc /debug- /o+ ShowMemory.cs
    Microsoft (R) Visual C# Compiler version 12.0.30501.0
    for C# 5
    Copyright (C) Microsoft Corporation. All rights reserved.
    
    
    c:\Users\Jon\Test&gt;ShowMemory.exe
    Environment: CLR 4.0.30319.34014 on Microsoft Windows NT 6.2.9200.0 (64 bit)
    Int32Wrapper: 4
    TwoInt32s: 8
    TwoInt32Wrappers: 8
    RefAndTwoInt32s: 16
    RefAndTwoInt32Wrappers: 24

So:

- If you don&#39;t have a reference type field, the CLR is happy to pack `Int32Wrapper` fields together (`TwoInt32Wrappers` has a size of 8)
- Even with a reference type field, the CLR is still happy to pack `int` fields together (`RefAndTwoInt32s` has a size of 16)
- Combining the two, each `Int32Wrapper` field appears to be padded/aligned to 8 bytes. (`RefAndTwoInt32Wrappers` has a size of 24.)
- Running the same code in the debugger (but still a release build) shows a size of 12.

A few other experiments have yielded similar results:

- Putting the reference type field after the value type fields doesn&#39;t help
- Using `object` instead of `string` doesn&#39;t help (I expect it&#39;s &quot;any reference type&quot;)
- Using another struct as a &quot;wrapper&quot; around the reference doesn&#39;t help
- Using a generic struct as a wrapper around the reference doesn&#39;t help
- If I keep adding fields (in pairs for simplicity), `int` fields still count for 4 bytes, and `Int32Wrapper` fields count for 8 bytes
- Adding `[StructLayout(LayoutKind.Sequential, Pack = 4)]` to every struct in sight doesn&#39;t change the results

Does anyone have any explanation for this (ideally with reference documentation) or a suggestion of how I can get hint to the CLR that I&#39;d like the fields to be packed *without* specifying a constant field offset?

  [1]: http://nodatime.org
  [2]: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.structlayoutattribute
  [3]: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.fieldoffsetattribute


Why does struct alignment depend on whether a field type is primitive or user-defined?

Today&#39;s PCs have a large amount of physical RAM but still, the stack size of C# is only 1 MB for 32-bit processes and 4 MB for 64-bit processes (https://stackoverflow.com/questions/823724/stack-capacity-in-c-sharp).

Why the stack size in CLR is still so limited?

And why is it exactly 1 MB (4 MB) (and not 2 MB or 512 KB)? Why was it decided to use these amounts?

I am interested in **considerations and reasons behind that decision**.

Why is stack size in C# exactly 1 MB?

How many String objects will be created when using a plus sign in the below code?

    String result = &quot;1&quot; + &quot;2&quot; + &quot;3&quot; + &quot;4&quot;;

If it was as below, I would have said three String objects: &quot;1&quot;, &quot;2&quot;, &quot;12&quot;.

    String result = &quot;1&quot; + &quot;2&quot;;

I also know that String objects are cached in the String Intern Pool/Table for performance improvement, but that&#39;s not the question.


How many String objects will be created when using a plus sign?

I have a program that requires fast performance.  Within one of its inner loops, I need to test the type of an object to see whether it inherits from a certain interface.

One way to do this would be with the CLR&#39;s built-in type-checking functionality.  The most elegant method there probably being the &#39;is&#39; keyword:

    if (obj is ISpecialType)

Another approach would be to give the base class my own virtual GetType() function which returns a pre-defined enum value (in my case, actually, i only need a bool).  That method would be fast, but less elegant.

I have heard that there is an IL instruction specifically for the &#39;is&#39; keyword, but that doesn&#39;t mean it executes fast when translated into native assembly.  Can anyone share some insight into the performance of &#39;is&#39; versus the other method?

**UPDATE:**  Thanks for all the informed answers!  It seem a couple helpful points are spread out among the answers:  Andrew&#39;s point about &#39;is&#39; automatically performing a cast is essential, but the performance data gathered by Binary Worrier and Ian is also extremely useful.  It would be great if one of the answers were edited to include *all* of this information.

C# &#39;is&#39; operator performance

I have read about Generations and Large object heap. But I still fail to understand what is the significance (or benefit) of having Large object heap?

What could have went wrong (in terms of performance or memory) if CLR would have just relied on Generation 2 (Considering that threshold for Gen0 and Gen1 is small to handle Large objects) for storing large objects? 

Why Large Object Heap and why do we care?

Is anyone attempting to implement C# for the JVM? As a Java developer, I&#39;ve been eyeing C# with envy, but am unwilling to give up the portability and maturity of the JVM, not to mention the diverse range of tools for it.

I know there are some important differences between the JVM and CLR but is there anything that is a showstopper? 



Implementing C# for the JVM

Is there a strong reason why Microsoft chose not to support AppDomains in .NET Core?

AppDomains are particularly useful when building long running server apps, where we may want to update the assemblies loaded by the server is a graceful manner, without shutting down the server.

Without AppDomains, how are we going to replace our assemblies in a long running server process?

AppDomains also provide us a way to isolate different parts of server code. Like, a custom websocket server can have socket code in primary appdomain, while our services run in secondary appdomain.

Without AppDomains, the above scenario is not possible.

I can see an argument that may talk about using VMs concept of Cloud for handling assembly changes and not having to incur the overhead of AppDomains. But is this what Microsoft thinks or says? or they have a specific reason and alternatives for the above scenarios?

No AppDomains in .NET Core! Why?

SQL Server 2008 - What is an easy way to check if clr is enabled?

SQL Server: How to check if CLR is enabled?

I did some timing tests and also read some articles like [this one][1] (last comment), and it looks like in Release build, float and double values take the same amount of processing time.

How is this possible? When float is less precise and smaller compared to double values, how can the CLR get doubles into the same processing time?

  [1]: http://www.cincomsmalltalk.com/userblogs/buck/blogView?showComments=true&amp;title=Smalltalk+performance+vs.+C%23&amp;entry=3354595110#3354595110



Float vs Double Performance

C# doesn&#39;t allow structs to derive from classes, but all ValueTypes derive from Object. Where is this distinction made?

How does the CLR handle this?

How do ValueTypes derive from Object (ReferenceType) and still be ValueTypes?

I am getting the following error on my new installation of ASP.Net and SQL Server when I run my app:

     Execution of user code in the .NET Framework is disabled. Enable &quot;clr enabled&quot; configuration option


I have tried to fix it by running this:

     use dasolPSDev;

     sp_configure &#39;clr enabled&#39;, 1
     go
     RECONFIGURE
     go
     sp_configure &#39;clr enabled&#39;
     go

But then I get:

     Msg 102, Level 15, State 1, Line 3
     Incorrect syntax near &#39;sp_config


ASP.NET CLR Not Enabled

A .NET 3.5 solution ended up with this warning when compiling with msbuild.

Sometimes NDepend might help out but in this case it didn&#39;t give any further details. [Like Bob](https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=336818) I ended up having to resort to opening each assembly in ILDASM until I found the one that was referencing an older version of the dependant assembly.

I did try using MSBUILD from VS 2010 Beta 2 (as the Connect article indicated this was fixed in the next version of the CLR) but that didn&#39;t provide any more detail either (maybe fixed post Beta 2)

Is there a better (more automated) approach?

Resolving MSB3247 - Found conflicts between different versions of the same dependent assembly

A String is a reference type even though it has most of the characteristics of a value type such as being immutable and having == overloaded to compare the text rather than making sure they reference the same object.

Why isn&#39;t string just a value type then?

In C#, why is String a reference type that behaves like a value type?

I&#39;m trying to decipher the meaning on the P1...P10 parameters associated with a `clr20r3` that is written to the event log when my application experiences an exception.

The best I&#39;ve [been able to find][1] is:

- **P1**: the hosting process (*e.g.* `w3wp.exe`)
- **P2**: the hosting process version (*e.g.* `6.0.3790.1830`)
- **P3**: ??? (*e.g.* `42435be1`)
- **P4**: the assembly from which the exception was raised (*e.g.* `mrtables.webservice`)
- **P5**: the assembly version (*e.g.* `2.1.2.0`)
- **P6**: ??? (*e.g.* `4682617f`)
- **P7**: ??? (*e.g.* `129`)
- **P8**: ??? (*e.g.* `50`)
- **P9**: the exception type raised (*e.g.* `system.argumentexception`)
- **P10**: ??? (*e.g.* `NIL`)

[Googling for clr20r3][2] provides thousands of sample parameter values, from which someone can try to derive a pattern.

But I&#39;m hoping for documentation on the parameter meanings, as opposed to educated guesses.

----------

**Edit:** While I can hope for canonical documentation, really I&#39;d be happy to see the exception being thrown, at what line, complete with a stack trace.

Bonus Reading
-------------

- https://stackoverflow.com/questions/1937931/unhandled-exception-that-caused-the-application-to-crash-with-eventtype-clr20r3 *(asking for help with a problem, while we&#39;re asking for a canonical explanation of what the parameters mean)*

  [1]: http://www.dimensionsusers.com/forum/viewtopic.php?f=29&amp;t=148
  [2]: http://google.com/?q=clr20r3+

Deciphering the .NET clr20r3 exception parameters P1..P10

I have been asked this question by a colleague that should we always include a default constructor in a class? If so, why? If no, why not?

_**Example**_

    public class Foo {

        Foo() { }

        Foo(int x, int y) {
            ...
        } 

    }

I am also interested to get some lights on this from experts.

Should we always include a default constructor in the class?

When programming interfaces, I&#39;ve found I&#39;m doing a lot of casting or object type conversion.

Is there a difference between these two methods of conversion?  If so, is there a cost difference or how does this affect my program?

    public interface IMyInterface
    {
        void AMethod();
    }

    public class MyClass : IMyInterface
    {
        public void AMethod()
        {
           //Do work
        }

        // Other helper methods....
    }

    public class Implementation
    {
        IMyInterface _MyObj;
        MyClass _myCls1;
        MyClass _myCls2;

        public Implementation()
        {
            _MyObj = new MyClass();

            // What is the difference here:
            _myCls1 = (MyClass)_MyObj;
            _myCls2 = (_MyObj as MyClass);
        }
    }

Also, what is &quot;in general&quot; the preferred method?


Casting vs using the &#39;as&#39; keyword in the CLR

I&#39;m just starting my first C++ project. I&#39;m using [Visual Studio 2008][1]. It&#39;s a single-form Windows application that accesses a couple of databases and initiates a WebSphere MQ transaction. I basically understand the differences among ATL, MFC, Win32 (I&#39;m a little hazy on that one actually) and CLR, but I&#39;m at a loss as to how I should choose. 

Is one or more of these just there for backward-compatibility? 

Is CLR [a bad idea][2]?

Any suggestions appreciated.

**Edit:**
I&#39;ve chosen C++ for this project for reasons I didn&#39;t go into in the post, which are not entirely technical. So, *assuming* C++ is the only/best option, which should I choose?

  [1]: https://stackoverflow.com/questions/820213/new-to-c-should-i-use-visual-studio
  [2]: https://stackoverflow.com/questions/819191/is-c-net-dying

How do I decide whether to use ATL, MFC, Win32 or CLR for a new C++ project?

I am trying to figure out what the maximum number of parameters a method in C# can have. I&#39;ve checked everywhere for an answer, including the C# official documentation, MSDN, and a couple of CLR references and I can&#39;t find an answer. Does anyone have an answer to this question?

What is the maximum number of parameters that a C# method can be defined as taking?

It is not possible to fire an event in C# that has no handlers attached to it. So before each call it is necessary to check if the event is null.

    if ( MyEvent != null ) {
      MyEvent( param1, param2 );
    }

I would like to keep my code as clean as possible and get rid of those null checks. I don&#39;t think it will affect performance very much, at least not in my case.

    MyEvent( param1, param2 );

Right now I solve this by adding an empty inline handler to each event manually. This is error prone, since I need to remember to do that etc.

    void Initialize() {
      MyEvent += new MyEvent( (p1,p2) =&gt; { } );
    }

Is there a way to generate empty handlers for all events of a given class automatically using reflection and some CLR magic?

Create empty C# event handlers automatically

Occasionally I like to spend some time looking at the .NET code just to see how things are implemented behind the scenes. I stumbled upon this gem while looking at the `String.Equals` method via Reflector.

**C#**

    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
    public override bool Equals(object obj)
    {
        string strB = obj as string;
        if ((strB == null) &amp;&amp; (this != null))
        {
            return false;
        }
        return EqualsHelper(this, strB);
    }

**IL**

    .method public hidebysig virtual instance bool Equals(object obj) cil managed
    {
        .custom instance void System.Runtime.ConstrainedExecution.ReliabilityContractAttribute::.ctor(valuetype System.Runtime.ConstrainedExecution.Consistency, valuetype System.Runtime.ConstrainedExecution.Cer) = { int32(3) int32(1) }
        .maxstack 2
        .locals init (
            [0] string str)
        L_0000: ldarg.1 
        L_0001: isinst string
        L_0006: stloc.0 
        L_0007: ldloc.0 
        L_0008: brtrue.s L_000f
        L_000a: ldarg.0 
        L_000b: brfalse.s L_000f
        L_000d: ldc.i4.0 
        L_000e: ret 
        L_000f: ldarg.0 
        L_0010: ldloc.0 
        L_0011: call bool System.String::EqualsHelper(string, string)
        L_0016: ret 
    }

What is the reasoning for checking `this` against `null`? I have to assume there is purpose otherwise this probably would have been caught and removed by now.





Why check this != null?

Is there a function in win API which can be used to extract the string representation of HRESULT value?

The problem is that not all return values are documented in MSDN, for example [ExecuteInDefaultAppDomain()](http://msdn.microsoft.com/en-us/library/ms164411.aspx) function is not documented to return &quot;0x80070002 - The system cannot find the file specified.&quot;, however, it does! Therefore, I was wondering whether there is a function to be used in common case.


Is there a way to get the string representation of HRESULT value using win API?

C# will not allow to write non-member functions and every method should be part of a class. I was thinking this as a restriction in all CLI languages. But I was wrong and I found that C++/CLI supports non-member functions. When  it is compiled, compiler will make the method as member of some unnamed class.

Here is what C++/CLI standard says,

&gt; [Note: Non-member functions are treated by the CLI as members of some unnamed class; however, in C++/CLI source code, such functions cannot be qualified explicitly with that class name. end note]
&gt;
&gt;The encoding of non-member functions in metadata is unspecified. [Note: This does not cause interop problems because such functions cannot have public visibility. end note]

So my question is why don&#39;t C# implement something like this? Or do you think there should not be non-member functions and every method should belong to some class? 

My opinion is to have non-member function support and it helps to avoid polluting class&#39;s interface. 

Any thoughts..?



Why C# is not allowing non-member functions like C++

I wrote some code for testing the impact of try-catch, but seeing some surprising results.

    static void Main(string[] args)
    {
        Thread.CurrentThread.Priority = ThreadPriority.Highest;
        Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime;

        long start = 0, stop = 0, elapsed = 0;
        double avg = 0.0;

        long temp = Fibo(1);

        for (int i = 1; i &lt; 100000000; i++)
        {
            start = Stopwatch.GetTimestamp();
            temp = Fibo(100);
            stop = Stopwatch.GetTimestamp();

            elapsed = stop - start;
            avg = avg + ((double)elapsed - avg) / i;
        }

        Console.WriteLine(&quot;Elapsed: &quot; + avg);
        Console.ReadKey();
    }

    static long Fibo(int n)
    {
        long n1 = 0, n2 = 1, fibo = 0;
        n++;

        for (int i = 1; i &lt; n; i++)
        {
            n1 = n2;
            n2 = fibo;
            fibo = n1 + n2;
        }

        return fibo;
    }

On my computer, this consistently prints out a value around 0.96..

When I wrap the for loop inside Fibo() with a try-catch block like this:

    static long Fibo(int n)
    {
        long n1 = 0, n2 = 1, fibo = 0;
        n++;

        try
        {
            for (int i = 1; i &lt; n; i++)
            {
                n1 = n2;
                n2 = fibo;
                fibo = n1 + n2;
            }
        }
        catch {}

        return fibo;
    }

Now it consistently prints out 0.69... -- it actually runs faster! But why?

Note: I compiled this using the Release configuration and directly ran the EXE file (outside Visual Studio).

EDIT: [Jon Skeet&#39;s *excellent* analysis][1] shows that try-catch is somehow causing the x86 CLR to use the CPU registers in a more favorable way in this specific case (and I think we&#39;re yet to understand why). I confirmed Jon&#39;s finding that x64 CLR doesn&#39;t have this difference, and that it was faster than the x86 CLR. I also tested using `int` types inside the Fibo method instead of `long` types, and then the x86 CLR was as equally fast as the x64 CLR.


----------


**UPDATE:** It looks like this issue has been fixed by Roslyn. Same machine, same CLR version -- the issue remains as above when compiled with VS 2013, but the problem goes away when compiled with VS 2015. 


  [1]: https://stackoverflow.com/a/8928476/282110

Try-catch speeding up my code?

What are the roots in garbage collection?

I have read the definition of root as &quot;any reference that you program can access to&quot; and definition of live is that an object that is being used, which can be a local variable, static variable.

I m little confused with discriminating the difference between root and live objects.

What is path to root? How does root and live objects work?

Can someone elaborate ? 



What are the roots?

I am trying to determine the size in bytes of the contents in a `VARBINARY(MAX)` field in SQL Server 2005, using SQL. As I doubt there is native support for this, could it be done using CLR integration? Any ideas would be greatly appreciated. 

Size of VARBINARY field in SQL Server 2005

I&#39;m just revising chapter 4 of C# in Depth which deals with nullable types, and I&#39;m adding a section about using the &quot;as&quot; operator, which allows you to write:

    object o = ...;
    int? x = o as int?;
    if (x.HasValue)
    {
        ... // Use x.Value in here
    }

I thought this was really neat, and that it could improve performance over the C# 1 equivalent, using &quot;is&quot; followed by a cast - after all, this way we only need to ask for dynamic type checking once, and then a simple value check.

This appears not to be the case, however. I&#39;ve included a sample test app below, which basically sums all the integers within an object array - but the array contains a lot of null references and string references as well as boxed integers. The benchmark measures the code you&#39;d have to use in C# 1, the code using the &quot;as&quot; operator, and just for kicks a LINQ solution. To my astonishment, the C# 1 code is 20 times faster in this case - and even the LINQ code (which I&#39;d have expected to be slower, given the iterators involved) beats the &quot;as&quot; code.

Is the .NET implementation of `isinst` for nullable types just really slow? Is it the additional `unbox.any` that causes the problem? Is there another explanation for this? At the moment it feels like I&#39;m going to have to include a warning against using this in performance sensitive situations...

Results:

&gt; Cast: 10000000 : 121  
&gt; As: 10000000 : 2211  
&gt; LINQ: 10000000 : 2143  

Code:

    using System;
    using System.Diagnostics;
    using System.Linq;
    
    class Test
    {
        const int Size = 30000000;
        
        static void Main()
        {
            object[] values = new object[Size];
            for (int i = 0; i &lt; Size - 2; i += 3)
            {
                values[i] = null;
                values[i+1] = &quot;&quot;;
                values[i+2] = 1;
            }
            
            FindSumWithCast(values);
            FindSumWithAs(values);
            FindSumWithLinq(values);
        }
        
        static void FindSumWithCast(object[] values)
        {
            Stopwatch sw = Stopwatch.StartNew();
            int sum = 0;
            foreach (object o in values)
            {
                if (o is int)
                {
                    int x = (int) o;
                    sum += x;
                }
            }
            sw.Stop();
            Console.WriteLine(&quot;Cast: {0} : {1}&quot;, sum, 
                              (long) sw.ElapsedMilliseconds);
        }
    
        static void FindSumWithAs(object[] values)
        {
            Stopwatch sw = Stopwatch.StartNew();
            int sum = 0;
            foreach (object o in values)
            {
                int? x = o as int?;
                if (x.HasValue)
                {
                    sum += x.Value;
                }
            }
            sw.Stop();
            Console.WriteLine(&quot;As: {0} : {1}&quot;, sum, 
                              (long) sw.ElapsedMilliseconds);
        }
    
        static void FindSumWithLinq(object[] values)
        {
            Stopwatch sw = Stopwatch.StartNew();
            int sum = values.OfType&lt;int&gt;().Sum();
            sw.Stop();
            Console.WriteLine(&quot;LINQ: {0} : {1}&quot;, sum, 
                              (long) sw.ElapsedMilliseconds);
        }
    }


Performance surprise with &quot;as&quot; and nullable types

I&#39;ve encountered with one performance problem that I can&#39;t quite understand. I know how to fix it but I don&#39;t understand Why that happens. It&#39;s just for fun!  
Let&#39;s talk code. I simplified the code as much as I could to reproduce the issue.  
Suppose we have a generic class. It has an empty list inside and does something with `T` in constructor. It has `Run` method that calls an `IEnumerable&lt;T&gt;` method on the list, e.g. `Any()`.

    public class BaseClass&lt;T&gt;
    {
        private List&lt;T&gt; _list = new List&lt;T&gt;();
 
        public BaseClass()
        {
            Enumerable.Empty&lt;T&gt;();
            // or Enumerable.Repeat(new T(), 10);
            // or even new T();
            // or foreach (var item in _list) {}
        }
 
        public void Run()
        {
            for (var i = 0; i &lt; 8000000; i++)
            {
                if (_list.Any())
                // or if (_list.Count() &gt; 0)
                // or if (_list.FirstOrDefault() != null)
                // or if (_list.SingleOrDefault() != null)
                // or other IEnumerable&lt;T&gt; method
                {
                    return;
                }
            }
        }
    }
Then we have a derived class which is empty:

    public class DerivedClass : BaseClass&lt;object&gt;
    {
    }

Let&#39;s measure the performance of running `ClassBase&lt;T&gt;.Run` method from both classes. Accessing from derived type is 4 times slower that from base class. And I can&#39;t understand why that happens. Compiled in Release mode, result is the same with warm up. It happens on .NET 4.5 only.

    public class Program
    {
        public static void Main()
        {
            Measure(new DerivedClass());
            Measure(new BaseClass&lt;object&gt;());
        }

        private static void Measure(BaseClass&lt;object&gt; baseClass)
        {
            var sw = Stopwatch.StartNew();
            baseClass.Run();
            sw.Stop();
            Console.WriteLine(sw.ElapsedMilliseconds);
        }
    }

Full listing [on gist](https://gist.github.com/alexandrnikitin/98cbb5b8caa07b0e038a)

Performance: type derived from generic

Can a LINQ enabled app run on a machine that only has the .NET 2.0 runtime installed?

In theory, LINQ is nothing more than syntactic sugar, and the resulting IL code should look the same as it would have in .NET 2.0.

How can I write LINQ without using the .NET 3.5 libraries? Will it run on .NET 2.0?

LINQ on the .NET 2.0 Runtime

I installed .NET 4.5 Developer preview from http://www.microsoft.com/download/en/details.aspx?displaylang=en&amp;id=27541, which &#39;replaces&#39; .NET 4.0 version.

However, the old way to detect the .NET framework version seems to return 4.0 (more precisely 4.0.30319.17020 on my PC), instead of 4.5 (sure probably for backward compatibility, or?):

    using System;

    namespace ConsoleApplication
    {
        class Program
        {
            static void Main(string[] args)
            {
                var version = Environment.Version;
                Console.WriteLine(version.ToString());
                Console.ReadKey();
            }
        }
    }

How do I detect that my code is really executed by .NET 4.5?


How do I detect at runtime that .NET version 4.5 is currently running your code?

I read a book which referred to the .net **CLR as a virtual machine**? Can anyone justify this? What is the reason we need the concept of virtual machines on some development platforms?

Isn&#39;t it possible to develop a native framework [one without virtual machine] that is fully object oriented and as powerful as .net?

The book which refers to CLR as virtual machine is &quot;**Professional .Net Framework 2.0**&quot;.

Is the CLR a virtual machine?

With the recent announcement of .NET 4.0 and Visual Studio 2010, it is becoming ever more difficult to keep track of what .NET Framework versions build on what version of the CLR and belong with which version(s) of Visual Studio.

Is there a definitive table that shows these relationships?


How do the .NET Framework, CLR and Visual Studio version numbers relate to each other?

Suppose there is the following code:

    private static int DoSwitch(string arg)
    {
        switch (arg)
        {
            case &quot;a&quot;: return 0;
            case &quot;b&quot;: return 1;
            case &quot;c&quot;: return 2;
            case &quot;d&quot;: return 3;
        }
        return -1;
    }

    private static Dictionary&lt;string, Func&lt;int&gt;&gt; dict = new Dictionary&lt;string, Func&lt;int&gt;&gt;
        {
            {&quot;a&quot;, () =&gt; 0 },
            {&quot;b&quot;, () =&gt; 1 },
            {&quot;c&quot;, () =&gt; 2 },
            {&quot;d&quot;, () =&gt; 3 },
        };

    private static int DoDictionary(string arg)
    {
        return dict[arg]();
    }

By iterating over both methods and comparing, I am getting that the dictionary is slightly faster, even when &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot; is expanded to include more keys. Why is this so?

Does this have to do with cyclomatic complexity? Is is because the jitter compiles the return statements in the dictionary to native code only once? Is it because the lookup of the dictionary is O(1), which [may not be the case for a switch statement][1]? (These are just guesses)


  [1]: https://stackoverflow.com/questions/44905/c-sharp-switch-statement-limitations-why

In a switch vs dictionary for a value of Func, which is faster and why?

In .NET, the &#39;Platform Target: Any CPU&#39; compiler option allows a .NET assembly to run as 64&amp;nbsp;bit on a x64 machine, and 32&amp;nbsp;bit on an x86 machine. It is also possible to force an assembly to run as x86 on an x64 machine using the &#39;Platform Target: x86&#39; compiler option.

Is it possible to run an assembly with the &#39;Any CPU&#39; flag, but determine whether it should be run in the x86 or x64 CLR? Normally this decision is made by the CLR/OS Loader (as is my understanding) based on the bitness of the underlying system.

I am trying to write a C# .NET application that can interact with (read: inject code into) other running processes. x64 processes can only inject into other x64 processes, and the same with x86. Ideally, I would like to take advantage of JIT compilation and the *Any CPU* option to allow a single application to be used to inject into either x64 or x86 processes (on an x64 machine).

The idea is that the application would be compiled as *Any CPU*. On an x64 machine, it would run as x64. If the target process is x86, it should relaunch itself, forcing the CLR to run it as x86. Is this possible?


All Clr Solutions on Gang of Coders

Total of 44 Clr Solutions