传值参数

1、值参数创建变量副本
2、对值参数的操作永远不影响变量的值

传值参数——值类型

class Program
    {
        static void Main(string[] args)
        {
            int i = 5;
            Function(i);
            Console.WriteLine(i);
        }
        static void Function(int a)
        {
            a++;
            Console.WriteLine(a);
        }
    }

结果

传值参数——引用类型：创建新对象

 class Program
    {
        static void Main(string[] args)
        {
            Student student1 = new Student() { Name="Tom"};
            Function(student1);
            Console.WriteLine($"{student1.Name}");
        }
        static void Function(Student stu)
        {
            stu = new Student() {Name="Tim" };
            Console.WriteLine($"{stu.Name}");
        }
    }
    class Student
    {
        public string Name;
    }

输出结果

参数传递——引用类型：只操作对象，不创建新对象

 class Program
    {
        static void Main(string[] args)
        {
            Student student1 = new Student() { Name="Tom"};
            Function(student1);
            Console.WriteLine($"{student1.Name}");
        }
        static void Function(Student stu)
        {
            stu.Name = "Tim";
            Console.WriteLine(stu.Name);
        }
    }
    class Student
    {
        public string Name;
    }

运行结果

引用参数

1、引用类型并不创建变量的副本
2、使用ref修饰符显式指出——此方法的副作用是改变实际参数的值

引用参数——值类型

 class Program
    {
        static void Main(string[] args)
        {
            int i = 5;
            Function(ref i);
            Console.WriteLine(i);
        }
        static void Function(ref int a)
        {
            a++;
            Console.WriteLine(a);
        }
    }

结果

引用参数——引用类型：创建新对象

 class Program
    {
        static void Main(string[] args)
        {
            Student student1 = new Student() { Name="Tom"};
            Console.WriteLine($"{student1.Name}");
            Function(ref student1);
            Console.WriteLine($"{student1.Name}");
        }
        static void Function(ref Student stu)
        {
            stu = new Student();
            stu.Name = "Tim";
            Console.WriteLine(stu.Name);
        }
    }
    class Student
    {
        public string Name;
    }

结果

引用参数——引用类型：不创建新对象

 class Program
    {
        static void Main(string[] args)
        {
            Student student1 = new Student() { Name="Tom"};
            Console.WriteLine($"{student1.Name}");
            Function(ref student1);
            Console.WriteLine($"{student1.Name}");
        }
        static void Function(ref Student stu)
        {
            stu.Name = "Tim";
            Console.WriteLine(stu.Name);
        }
    }
    class Student
    {
        public string Name;
    }

结果

输出参数

1、输出菜蔬并不创建变量的副本
2、方法体内必须要有对输出变量赋值的操作
3、使用out修饰符显式指出——此方法的副作用是通过参数向外输出值
4、从语义来讲——ref是为了改变，out是为了输出

输出参数——值类型

 class Program
    {
        static void Main(string[] args)
        {
            double x = 0;
            bool b = DoubleParser.TryParse("123",out x);
            if (b == true)
            {
                Console.WriteLine(x);
            }
            else {
                Console.WriteLine(x);
            }
        }
        
    }
    class DoubleParser
    {
        public static bool TryParse(string input,out double result)
        {
            try
            {
                result = double.Parse(input);
                return true;
            }
            catch 
            {
                result = 0;
                return false;                
            }
        }
    }

结果

输出参数——引用类型

 class Program
    {
        static void Main(string[] args)
        {
            Student student = null;
            bool b = StudentFactory.Creat("Tom", 20, out student);
            if (b == true)
            {
                Console.WriteLine($"student.Nmae={student.Name},student.Age={student.Age}");
            }
            
        }  
    }
    class Student
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    class StudentFactory
    {
        public static bool Creat(string name, int age, out Student student)
        {
            student = null;
            if (string.IsNullOrEmpty(name))
            {
                return false;
            }
            if (age > 100 && age < 0)
            {
                return false;
            }
           
            student = new Student() { Name = name, Age = age };
            return true;
        }
    }

结果

数组参数

必需是形参列表中的最后一个参数，有params修饰
Sting.Fromat和Sting.split方法就是用到了数组参数

具名参数

参数的位置不受约束

 class Program
    {
        static void Main(string[] args)
        {
            Function(name: "Tom",age:20);
            Function(age: 20,name: "Tom" );
        }
        static void Function(string name, int age)
        {
            Console.WriteLine($"Name={name},Age={age}");
        }
    }

可选参数

参数因为具有默认值而变得“可选”

class Program
    {
        static void Main(string[] args)
        {
            Function();
        }
        static void Function(string name="Tom", int age=20)
        {
            Console.WriteLine($"Name={name},Age={age}");
        }
    }

扩展方法（this参数）

1、扩展方法必须是共有，静态的
2、必须是参数列表中的第一个，由this修饰
3、必须由一个静态类（一般名为SomeTypeExtent）来统一收纳对Some Type类型的扩展方法

class Program
    {
        static void Main(string[] args)
        {
            double x = 3.1415926;
            double y = x.round(5);
            Console.WriteLine(y);
        }  
    }
    static class DoubleExtansion
    {
        static public double round(this double input ,int digits)
        {
            double result = Math.Round(input, digits);
            return result;
        }
    }

各种参数的使用场景

c#参数类型详解（传值参数，引用参数，输出参数，具名参数，可选参数，数组参数，扩展方法）