引用空间创建的变量将存储在哪里？ 它们将如何被引用到它们的参考空间？

Question

I read that local variables will be stored in the stack memory and the reference variables will be stored in the heap memory.

Now I have a case where a local object is being created in a reference space. So where will that object be saved, and how will that object be referenced?

I'm trying to find out what variables are stored in stack memory and heap memory.

Employee.cs

        class Employee
        {
            int EmpId;
            public int GetEmpId()
            {
                 return this.EmpId ;
            }

            public void SetEmpId(int EmpId)
            {
                this.EmpId = EmpId;
            }

            public Job j = new Job();
        }

Job.cs

    class Job
    {
        int JobId;

        public int GetJobId()
        {
             return this.JobId ;
        }

        public void SetJobId(int JobId)
        {
            this.JobId = JobId;
        }

    }

Program.cs

    class Program
    {
        static int a =1;
        static void Main(string[] args)
        {
            Employee E1 = new Employee();
            Employee E2 = new Employee();

            E1.SetEmpId(2595);
            E1.j.SetJobId(25);

            Console.WriteLine(E1.GetEmpId());
            Console.WriteLine(E1.j.GetJobId());

        }

    }

I'm using Visual Studio Code.

Can anyone please help me in finding what goes into stack memory and what goes into heap memory?

Answer 1

Stack space is used for passing arguments to a method and for local variables defined within a method. Local variables of a reference type will be stored on the heap and pointer to that objects will be stored on stack. But, local variables of a value type will be stored on stack.

By the way, stack space is owned by threads. The default stack size is 1MB. Each thread gets a stack, while there's typically only one heap for the application.

And objects are stored on the heap alongside with all their fields and properties.

Now, let's go line by line.

static int a = 1;

Static fields will be stored in the heap alongside with Type object. Because, static fields actually related to Type object which will be created automatically by CLR on first access to the instance of that Type or directly to the Type . That Type object contains all type related information.

Then:

  Employee E1 = new Employee();
  Employee E2 = new Employee();

You have two Employee objects on the heap. And addresses of that objects in the stack( E1 and E2 ). But, if Employee was a struct, then E1 and E2 will be stored on stack alongside with all information. If that struct has some field of a reference type, then data of that field will be stored on heap and address of that field will be stored on stack inside Employee .