C#.Net对象内存模型及堆/栈数据结构详解 (二)

C# Heap(ing) Vs Stack(ing) in .NET: Part II
本文转载http://www.c-sharpcorner.com

Even though with the .NET framework we don''t have to actively worry about memory management and garbage collection (GC), we still have to keep memory management and GC in mind in order to optimize the performance of our applications. Also, having a basic understanding of how memory management works will help explain the behavior of the variables we work with in every program we write. In this article I''ll cover some of the behaviors we need to be aware of when passing parameters to methods.

In Part I we covered the basics of the Heap and Stack functionality and where Variable Types and Reference Types are allocated as our program executes. We also covered the basic idea of what a Pointer is.

Parameters, the Big Picture.

Here''s the detailed view of what happens as our code executes. We covered the basics of what happens when we make a method call in Part I. Let''s get into more detail...

When we make a method call here''s what happens:

1. Space is allocated for information needed for the execution of our method on the stack (called a Stack Frame). This includes the calling address (a pointer) which is basically a GOTO instruction so when the thread finishes running our method it knows where to go back to in order to continue execution.  
2. Our method parameters are copied over. This is what we want to look at more closely.
3. Control is passed to the JIT''ted method and the thread starts executing code. Hence, we have another method represented by a stack frame on the "call stack".

As the method executes, space for "x" is placed on the stack with a value of 5.

 
Next, AddFive() is placed on the stack with space for it''s parameters and the value is copied, bit by bit from x.

 
When AddFive() has finished execution, the thread is passed back to Go() and because AddFive() has completed, pValue is essentially "removed":

 
So it makes sense that the output from our code is "5", right? The point is that any value type parameters passed into a method are carbon copies and we count on the original variable''s value to be preserved.

One thing to keep in mind is that if we have a very large value type (such as a big struct) and pass it to the stack, it can get very expensive in terms of space and processor cycles to copy it over each time. The stack does not have infinite space and just like filling a glass of water from the tap, it can overflow. A struct is a value type that can get pretty big and we have to be aware of how we are handling it.

Here''s a pretty big struct:

           }

Take a look at what happens when we execute Go() and get to the DoSomething() method below:

This can be really inefficient. Imaging if we passed the MyStruct a couple thousand times and you can understand how it could really bog things down.

So how do we get around this problem? By passing a reference to the original value type as follows: 

This way we end up with more memory efficient allocation of our objects in memory. 

 
The only thing we have to watch out for when passing our value type by reference is that we have access to the value type''s value. Whatever is changed in pValue is changed in x. Using the code below, our results are going to be "12345" because the pValue.a actually is looking at the memory space where our original x variable was declared.

          }

Passing Reference Types.

Passing parameters that are reference types is similar to passing value types by reference as in the previous example.

If we are using the value type

           }

And call the Go() method, the MyInt ends up on the heap because it is a reference type:

          }

If we execute Go() as in the following code ...

           }

Here''s what happens...

1.  Starting with the call to Go() the variable x goes on the stack.
2. Starting with the call to DoSomething() the parameter pValue goes on the stack.
3. The value of x (the address of MyInt on the stack) is copied to pValue

So it makes sense that when we change the MyValue property of the MyInt object in the heap using pValue and we later refer to the object on the heap using x, we get the value "12345".

So here''s where it gets interesting. What happens when we pass a reference type by reference?

Check it out. If we have a Thing class and Animal and Vegetables are both things:

           }

And we execute the Go() method below:

           }

Our variable x is turned into a Vegetable.

x is Animal    :   False
x is Vegetable :   True

Let''s take a look at what''s happening:

1. Starting with the Go() method call, the x pointer goes on the stack
2. The Animal goes on the hea
3. Starting with the call to Switcharoo() method, the pValue goes on the stack and points to x
   
   
4. The Vegetable goes on the heapthe heap
5. The value of x is changed through pValue to the address of the Vegetable