C # Fundamentals: Value types, reference types, and ref keywords

In C #, the meaning of ref is passed by reference. You can refer to C + +:

1. int a = ten, B = 20;
2. void swap (int x, int y)
3. {
4. int temp = x;
5. x = y;
6. y = temp;
7. }

If you simply call this swap, such as swap (A, b), then you simply cannot exchange the values of the two variables, because both x and Y are formal parameters, and X and Y are freed when the swap returns. But if this is the definition of swap:

1. void Swap (int& x, int& y)
2. {
3. int temp = x;
4. x = y;
5. y = temp;
6. }

The same as x and A,y and B point to the same memory address, then the operation of X is equivalent to the operation of A. So in C #, this effect is obvious for value types.

2. Class Program
4. {
6. static void Test (ref int b)
8. {
10. b = 2;
12. }
16. static void Main (string[] args)
18. {
20. int b = 1;
22. Test (ref B);
24. Console.WriteLine (b);
26. }
28. }

The output at this point is 2, that is, b in the test method points to the same memory address as B in main, then the operation on TEST.B is the main.b operation. If you change the program to:

2. Class Program
4. {
6. static void Test (int b)
8. {
10. b = 2;
12. }
16. static void Main (string[] args)
18. {
20. int b = 1;
22. Test (b);
24. Console.WriteLine (b);
26. }
28. }

Then the output is still 1, because test.b is not a main.b reference, that is, a single parameter. Now look at the effect of the reference type:

2. Class TestClass
4. {
6. public int B;
8. }
12. Class Program
14. {
16. static void Test (TestClass b)
18. {
20. B.B = 2;
22. }
26. static void Main (string[] args)
28. {
30. TestClass B = new TestClass ();
32. b.b = 1;
34. Test (b);
36. Console.WriteLine (B.B);
38. }
40. }

The above code, the output is 2, because B is a reference type, when you only need to modify the members of B, add the same as the REF keyword. The reference type itself does not contain data, and it only maintains a reference to the data.

Therefore, using the ref parameter, the effect on a value type object is obvious, and for reference types, you do not need to use the REF keyword if you want to modify the data inside the reference type, otherwise, you need to use the REF keyword when you need to change the reference itself inside the called function, such as to reposition the reference to the object inside the function.

C # Fundamentals: Value types, reference types, and ref keywords