Method parameter transfer mechanism of C ＃

C#  And   Method parameter passing mechanism

According to the different parameter transfer mechanism ,C# There are four formal parameters of methods ：

Value parameter 、 Reference parameter 、 Output parameters and parameter arrays

, By adding different parameter descriptors when defining formal parameters .

One 、 Value parameter :(

Value type formal parameter

)

A parameter declared without a modifier is a value parameter .

A value parameter corresponds to a local variable of the method , Only its initial value comes from the corresponding argument provided by the method call .

When the parameter is a value parameter , It is required that the corresponding argument in the method call must be implicitly convertible to the type of formal parameter .

Look at an example of commutative numbers , When executed Exchange Method ,Main Medium a and b Not affected :

 class Program
 {
 static void Main(string[] args)
 {
 int a = 3, b = 5;
 Console.WriteLine("Main.. a:" + a + "...b:" + b);
 Exchange(a, b);
 Console.WriteLine("Main.. a:" + a + "...b:" + b);
 }

 static void Exchange(int a, int b)
 {
 Console.WriteLine("Exchange.. a:" + a + "...b:" + b);
 int temp = a;
 a = b;
 b = temp;
 Console.WriteLine("Exchange.. a:" + a + "...b:" + b);
 }
 }


Two 、 Reference parameter (

ref keyword

)

use ref  The formal parameter declared by the modifier is a reference parameter .

The storage location represented by the reference parameter is the storage location of the argument given during the method call .

When the parameter is a reference parameter , The corresponding argument in a method call must be defined by the keyword ref And followed by a variable of the same type as the formal parameter . Variables can be passed as reference parameters , Must be explicitly assigned first .

Also in the code in the above example, I use method parameters ref modification , See the result : At this time Main Methods a and b The value of is also converted .

 class Program
 {
 static void Main(string[] args)
 {
 int a = 3, b = 5;
 Console.WriteLine("Main.. a:" + a + "...b:" + b);
 Exchange(ref a,ref b);
 Console.WriteLine("Main.. a:" + a + "...b:" + b);

 Console.ReadKey();
 }

 static void Exchange(ref int a,ref int b)
 {
 Console.WriteLine("Exchange.. a:" + a + "...b:" + b);
 int temp = a;
 a = b;
 b = temp;
 Console.WriteLine("Exchange.. a:" + a + "...b:" + b);
 }
 }


in other words , When we use reference parameters , Multiple names represent the same storage location .

3、 ... and 、 Output parameter  (

out keyword

)

use out The output modifier is a formal parameter declaration .

The storage location represented by the output formal parameter is the storage location represented by the variable given as an argument in the method call .

It is used in the same way as the reference parameter ref Keyword modification , A use out Keyword modification , The difference is that the reference parameter needs to be assigned before the method call , The output parameter is after the method call , Return to previous assignment

Take a chestnut :

 class Program
 {
 static void Main(string[] args)
 {
 int[] arr = new int[5] { 1, 2, 3, 4, 5 };
 float average;
 int sum = Calculation(arr, out average);
 Console.WriteLine(" The sum of these numbers is :" + sum + ".. The average is :" + average);
 Console.ReadKey();
 }

 static int Calculation(int[] arr,out float average)
 {
 int sum = 0;
 for (int i = 0; i < arr.Length; i++)
 {
 sum += arr[i];
 }
 average = sum / arr.Length;
 return sum;
 }
 }


Output parameters can be used to pass data from the method to the caller .

Four 、 Parameter array  (

Reference type formal parameter

)

When the type passed by a method parameter is a reference type , Modify the value in the parameter , Is to modify the original variable , That is, when a reference type passes parameters , What passes in is the address .

Take a chestnut : Modify the value in the parameter array , The original array will also be modified , Look at the code :

 class Program
 {
 static void Main(string[] args)
 {
 int[] arr = new int[5] { 1, 2, 3, 4, 5 }; 
 Console.WriteLine("Main  Before calling the method :");
 for (int i = 0; i < arr.Length; i++)
 {
 Console.Write(arr[i] + &quot; &quot;);
 }
 Console.WriteLine();
 Reference(arr);
 Console.WriteLine();
 Console.WriteLine(&quot;Main  After calling method :&quot;);
 for (int i = 0; i < arr.Length; i++)
 {
 Console.Write(arr[i] + &quot; &quot;);
 }

 Console.ReadKey();
 }

 static void Reference(int[] arr)
 {
 Console.WriteLine(&quot;Reference  Come in :&quot;);
 for (int i = 0; i < arr.Length; i++)
 {
 Console.Write(arr[i] + &quot; &quot;);
 } 
 for (int i = 0; i < arr.Length; i++)
 {
 arr[i] = 0;
 }
 Console.WriteLine();
 Console.WriteLine(&quot;Reference  After modification :&quot;);
 for (int i = 0; i < arr.Length; i++)
 {
 Console.Write(arr[i] + &quot; &quot;);
 }
 }
 }


C# Positional and named parameters in

Positional arguments : When making a method call , The position of each argument must correspond to the position of the corresponding formal parameter one by one , This parameter is called position parameter , All the position parameters we used in the above example .

from C#4.0 Start , The naming parameter mechanism is supported when calling methods , Just explicitly specify the name of the parameter , You can list arguments in method calls in any order .

I will 1 Example code changes the form of the call , Something like that :

 class Program
 {
 static void Main(string[] args)
 {
 int a = 3, b = 5;
 Console.WriteLine("Main.. a:" + a + "...b:" + b);
 //Exchange(a, b);
 Exchange(b: b, a: a);
 Console.WriteLine("Main.. a:" + a + "...b:" + b);

 Console.ReadKey();
 }

 static void Exchange(int a,int b)
 {
 Console.WriteLine("Exchange.. a:" + a + "...b:" + b);
 int temp = a;
 a = b;
 b = temp;
 Console.WriteLine("Exchange.. a:" + a + "...b:" + b);
 }
 }


Maybe this example is not well written , Formal parameters should not have duplicate names with actual variable names , However, this does not affect the function , As can be seen from the figure below, when I select a when , Methods a Will be marked , Represents the same variable , here Main Methods

a

:a It is also marked , Then it means that he and this formal parameter are also the same variable

PS: Named parameters , You can clearly know which variable assigned the parameter , This makes the method call less error prone with more parameters , Increase the readability of the code .