The default stack size for a .NET application is 1 MB (default is 256 KB for 32-bit ASP.NET apps and 512 KB for 64-bit ASP.NET apps), but you can change that. For the application you can change the default size by modifying the PE header of the executable. For threads you create, you can use the constructor overload that takes a stack size. 

But as Anton Tyjhyy points out in his answer, arrays are reference types and thus located on the heap (even if the array happens to hold a bunch of value types). 

Your array will live on the heap, stack size is irrelevant in your case.

If you want to check the value for your current .NET assembly then you can do so by using `ILDASM` command that comes in with Visual Studio command prompt. Once you have started the tool, open your assembly and then go to `View -&gt; Headers` menu. Now scroll down to `PE Optional Header (32 bit)` section in the newly opened `Headers` window. You will see two fields:

 1. Size of stack reserve - This is self-explanatory. This is default stack memory size allocated to any thread getting created in your program/application.
 2. Size of stack commit - committed stack space is - (Quoting Hans Passant from [here][1])

&gt; The said space is reserved in the operating system&#39;s paging file so
&gt; the stack can always be swapped out when necessary.

[![enter image description here][2]][2]


  [1]: https://stackoverflow.com/a/28658130/465053
  [2]: https://i.stack.imgur.com/mgUbE.png

To use stack for storing an array you have to use unsafe code with pointers and stackalloc to allocate desired memory space on the stack.

In Visual Studio when you add a new class, it always created with no modifiers and that makes class internal.

    class MyClass
    {
    }

I would prefer that my class by default is created as public one.

Why is it internal by default?

What would you prefer?

Why Visual Studio doesn&#39;t create a public class by default?

Using Sql Server 2005 Profiler, what events, columns, and filters do you trace to find your slowest queries and stored procedures?

Slow = greater than N seconds, 10 for sake of argument.

How to find slowest queries

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#

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


Are there automatic ways to sync comments between an interface and its implementation? I&#39;m currently documenting them both and wouldn&#39;t like to manually keep them in sync.

UPDATE:

Consider this code:

    interface IFoo{
        /// &lt;summary&gt;
        /// Commenting DoThis method
        /// &lt;/summary&gt;
        void DoThis();
    }

    class Foo : IFoo {
        public void DoThis();
    }

When I create class like this:

    IFoo foo=new Foo();
    foo.DoThis();//comments are shown in intellisense

Here comments are not shown:

    Foo foo=new Foo();
    foo.DoThis();//comments are not shown in intellisense

The `&lt;inheritDoc/&gt;` tag will perfectly generate the documentation in Sand Castle, but it doesn&#39;t work in intellisense tooltips.

Ways to synchronize interface and implementation comments in C#

The Entity Framework context object implements a Dispose() method which &quot;Releases the resources used by the object context&quot;. What does it do really? Could it be a bad thing to always put it into a using {} statement? I&#39;ve seen it being used both with and without the using statement.

I&#39;m specifically going to use the EF context from within a WCF service method, create the context, do some linq and return the answer.

**EDIT:** Seems that I&#39;m not the only one wondering about this. Another question is what&#39;s really happening inside the Dispose() method. Some say it closes connections, and some articles says not. What&#39;s the deal?

Should Entity Framework Context be Put into Using Statement?

I am trying to make a method that will go through a list of generic objects and replace all their properties of type `string` which is either `null` or empty with a replacement.

How is a good way to do this?

I have this kind of... shell... so far:

    public static void ReplaceEmptyStrings&lt;T&gt;(List&lt;T&gt; list, string replacement)
    {
        var properties = typeof(T).GetProperties( -- What BindingFlags? -- );

        foreach(var p in properties)
        {
            foreach(var item in list)
            {
                if(string.IsNullOrEmpty((string) p.GetValue(item, null)))
                    p.SetValue(item, replacement, null);
            }
        }
    }

So, how do I find all the properties of a type that are:

- Of type `string`
- Has public `get`
- Has public `set`

  ?

---

I made this test class:

    class TestSubject
    {
        public string Public;
        private string Private;

        public string PublicPublic { get; set; }
        public string PublicPrivate { get; private set; }
        public string PrivatePublic { private get; set; }
        private string PrivatePrivate { get; set; }
    }

The following does not work:

    var properties = typeof(TestSubject)
            .GetProperties(BindingFlags.Instance|BindingFlags.Public)
            .Where(&#248; =&gt; &#248;.CanRead &amp;&amp; &#248;.CanWrite)
            .Where(&#248; =&gt; &#248;.PropertyType == typeof(string));

If I print out the Name of those properties I get there, I get:
&gt;PublicPublic
PublicPrivate
PrivatePublic

In other words, I get two properties too much. 

---
***Note**: This could probably be done in a better way... using nested foreach and reflection and all here... but if you have any great alternative ideas, please let me know cause I want to learn!*

C#: How to get all public (both get and set) string properties of a type

I would like to show some C# source code in a PowerPoint presentation. But how can I copy the code ***including the syntax highlighting*** onto the slides? I could make screenshots, but that has some drawbacks (ugly, font size, unmaintainable). Do you have some ideas?

How to: C# source with syntax highlighting on PowerPoint slides

Could anyone explain me why the generics `List.Contains()` function is so slow?  

I have a `List&lt;long&gt;` with about a million numbers, and the code that is constantly checking if there&#39;s a specific number within these numbers.

I tried doing the same thing using `Dictionary&lt;long, byte&gt;` and the `Dictionary.ContainsKey()` function, and it was about 10-20 times faster than with the List.

Of course, I don&#39;t really want to use Dictionary for that purpose, because it wasn&#39;t meant to be used that way.

So, the real question here is, is there any alternative to the `List&lt;T&gt;.Contains()`, but not as whacky as `Dictionary&lt;K,V&gt;.ContainsKey()` ?  

List&lt;T&gt;.Contains() is very slow?

A common task when calling web resources from a code is building a query string to including all the necessary parameters. While by all means no rocket science, there are some nifty details you need to take care of like, appending an `&amp;` if not the first parameter, encoding the parameters etc.

The code to do it is very simple, but a bit tedious:

    StringBuilder SB = new StringBuilder();
    if (NeedsToAddParameter A) 
    { 
      SB.Append(&quot;A=&quot;); SB.Append(HttpUtility.UrlEncode(&quot;TheValueOfA&quot;)); 
    }
    
    if (NeedsToAddParameter B) 
    {
      if (SB.Length&gt;0) SB.Append(&quot;&amp;&quot;); 
      SB.Append(&quot;B=&quot;); SB.Append(HttpUtility.UrlEncode(&quot;TheValueOfB&quot;)); }
    }

This is such a common task one would expect a utility class to exist that makes it more elegant and readable. Scanning MSDN, I failed to find one&amp;mdash;which brings me to the following question:

What is the most elegant clean way you know of doing the above?

How to build a query string for a URL in C#?

I got a job offer today for a position as a SharePoint developer. One of my friends is telling me that sharepoint is a big mess and not something I would want to be doing.

What are some of your experiences/thoughts in working with SharePoint?

How good/bad is sharepoint programming?

The Managed Extensibility Framework (MEF) and Managed AddIn Framework (MAF, aka System.AddIn) seem to accomplish very similar tasks. According to this Stack Overflow question, [Is MEF a replacement for System.Addin?][1], you can even use both at the same time. 

When would you choose to use one vs. the other? Under what circumstances would you choose to use both together?


  [1]: https://stackoverflow.com/questions/124040/is-mef-a-replacement-for-system-addin

Choosing between MEF and MAF (System.AddIn)

I have a procedure in SQL that I am trying to turn into Linq:

    SELECT O.Id, O.Name as Organization
    FROM Organizations O
    JOIN OrganizationsHierarchy OH ON O.Id=OH.OrganizationsId
    where OH.Hierarchy like &#39;%/12/%&#39;

The line I am most concerned with is:

    where OH.Hierarchy like &#39;%/12/%&#39;

I have a column that stores the hierarchy like /1/3/12/ for example so I just use %/12/% to search for it.

My question is, what is the Linq or .NET equivalent to using the percent sign?


How to do SQL Like % in Linq?

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 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

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?


Force x86 CLR on an &#39;Any CPU&#39; .NET assembly

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?

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

After some experience with functional languages, I&#39;m starting to use recursion more in Java - But the language seems to have a relatively shallow call stack of about 1000.

Is there a way to make the call stack bigger? Like can I make functions that are millions of calls deep, like in Erlang?

I&#39;m noticing this more and more when I do Project Euler problems.

Thanks.

Stack overflows from deep recursion in Java?

I&#39;ve heard of stackless languages. However I don&#39;t have any idea how such a language would be implemented. Can someone explain?

How does a stackless language work?

`alloca()` allocates memory on the stack rather than on the heap, as in the case of `malloc()`. So, when I return from the routine the memory is freed. So, actually this solves my problem of freeing up dynamically allocated memory. Freeing of memory allocated through `malloc()` is a major headache and if somehow missed leads to all sorts of memory problems.

Why is the use of `alloca()` discouraged in spite of the above features?

Why is the use of alloca() not considered good practice?

I&#39;ve been trying to gain a deeper understanding of how compilers generate machine code, and more specifically how GCC deals with the stack. In doing so I&#39;ve been writing simple C programs, compiling them into assembly and trying my best to understand the outcome. Here&#39;s a simple program and the output it generates:

`asmtest.c`:

    void main() {
        char buffer[5];
    }


`asmtest.s`:

    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
    leave
    ret

What&#39;s puzzling to me is why 24 bytes are being allocated for the stack. I know that because of how the processor addresses memory, the stack has to be allocated in increments of 4, but if this were the case, we should only move the stack pointer by 8 bytes, not 24. For reference, a buffer of 17 bytes produces a stack pointer moved 40 bytes and no buffer at all moves the stack pointer 8. A buffer between 1 and 16 bytes inclusive moves `ESP` 24 bytes.

Now assuming the 8 bytes is a necessary constant (what is it needed for?), this means that we&#39;re allocating in chunks of 16 bytes. Why would the compiler be aligning in such a way? I&#39;m using an x86_64 processor, but even a 64bit word should only require an 8 byte alignment. Why the discrepancy?

For reference I&#39;m compiling this on a Mac running 10.5 with gcc 4.0.1 and no optimizations enabled.

Stack allocation, padding, and alignment

If I declare a data structure globally in a C++ application , does it consume stack memory or heap memory ?

For eg

    struct AAA
    {
    
    .../.../.
    ../../..
    }arr[59652323];

Content Type	Original Author	Original Content on Stackoverflow
Question	George ARKIN	View Question on Stackoverflow
Solution 1 - C#	Brian Rasmussen	View Answer on Stackoverflow
Solution 2 - C#	Anton Tykhyy	View Answer on Stackoverflow
Solution 3 - C#	RBT	View Answer on Stackoverflow
Solution 4 - C#	Jan Prokes	View Answer on Stackoverflow

Stack capacity in C#

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

Solution 4 - C#

How to find slowest queries

Why Visual Studio doesn't create a public class by default?

Attributions