parâmetros do método c#
parâmetro de valor
Parâmetros de valor são os parâmetros mais comumente usados.
Os parâmetros formais no momento da declaração 不带任何修饰符são parâmetros de valor (parâmetros formais). O parâmetro value corresponde a uma variável local cujo valor de inicialização vem do parâmetro real (parâmetro real) fornecido ao chamar o método . Mudanças nos parâmetros formais dentro do método não afetarão os parâmetros reais fora do método.形参是方法内的一个局部变量，方法调用时形参拷贝了传入的实参的值，此后，形参和实参再无半分瓜葛。
class Program
{
static void Main(string[] args)
{
int y = 100;
Program.PrintAdd(y); // 输出 101
Console.WriteLine(y); // 输出100
}
static void PrintAdd(int x)
{
x = x + 1;
Console.WriteLine(x);
}
}
O parâmetro de valor é引用数据类型
Quando o parâmetro de valor é um tipo de dados de referência , o parâmetro formal copia a referência do parâmetro real, mas em essência o parâmetro real e o parâmetro formal ainda são duas variáveis diferentes. A diferença é:
基本数据类型O que é armazenado diretamente é o valor dos dados básicos. Por exemplo, o tipo int armazena números inteiros.引用数据类型O que é armazenado é o endereço do objeto referenciado.Por exemplo, a variável de um objeto de classe armazena o endereço do objeto.
Um ponto que é fácil de confundir é que
quando um objeto é passado para um método, após seus campos serem modificados através do objeto dentro do método, os campos correspondentes do objeto fora do método serão modificados. Isso pode ser considerado por algumas pessoas como não parâmetro de valor. Na verdade, ainda é um parâmetro de valor. O parâmetro formal copia o valor do parâmetro real, mas esse valor é um endereço no tipo de dados de referência. Após a cópia, os valores armazenados no parâmetro formal e no parâmetro real são o mesmo endereço, neste momento o endereço pode ser acessado através do parâmetro formal dentro do método. Se 形参.字段o valor de um determinado campo for modificado neste momento (o tipo de campo pode ser um tipo de dados básico ou um tipo de dados de referência), o campo do objeto armazenado no endereço apontado pelo parâmetro formal é modificado, e o formal O parâmetro em si não é modificado, pois o parâmetro formal O que é salvo é apenas o endereço do objeto referenciado. A única 形参 = 新对象maneira é modificar o próprio parâmetro formal. 形参 = 新对象Não resulta 实参 == 新对象, portanto, ainda em conformidade com a definição de parâmetros de valor.
class Student
{
public string name;
public int age;
}
class Program
{
static void Main(string[] args)
{
Student stu = new Student();
stu.name = "yy";
stu.age = 100;
Program.Test(stu);
// 到这里stu的字段的值分别是:
name = "xx";
age = 100;
// 新旧hash code 是不一样的
Console.WriteLine("hash code: {0}", stu.GetHashCode());
}
static void Test(Student stu)
{
// 通过形参stu访问了一个Student对象的字段name，并修改之，此修改外部能感知
stu.name = "xx";
stu = new Student(); // 形参新赋值了一个新对象，外部实参依旧是旧的对象
// 这两次赋值是对新对象的字段的赋值，并不会对
// 旧对象的字段造成影响
stu.name = "bb";
stu.age = 20;
Console.WriteLine("hash code: {0}", stu.GetHashCode());
}
}
Parâmetros de referência
Os parâmetros formais declarados com refmodificadores são 引用参数. Ao contrário dos parâmetros de valor, os parâmetros de referência não criam um novo local de armazenamento. Em outras palavras, os parâmetros reais e os parâmetros formais dos parâmetros de referência referem-se ao mesmo local de armazenamento.
class Program
{
static void Main(string[] args)
{
double a = 20;
Add(ref a); // a == 21
Console.WriteLine(a); // a == 21
}
static void Add(ref int a)
{
a = a + 1;
Console.WriteLine(a);
}
}
Parâmetros de saída
Os parâmetros formais declarados com outmodificadores são 输出参数. Semelhante aos parâmetros de referência, os parâmetros de saída não criam novos locais de armazenamento. O local de armazenamento dos parâmetros formais dos parâmetros de saída é exatamente o local de armazenamento dos parâmetros reais, ou seja, a soma dos parâmetros de saída é exatamente a mesma 形参variável 实参.
O design do parâmetro de saída é obter o valor de dentro do método. O valor inicial do parâmetro de saída será substituído dentro do método, portanto o valor inicial não tem sentido e não há necessidade de atribuir um valor inicial. Os parâmetros de saída podem ser entendidos como valores adicionais de retorno de função.
class Program
{
static void Main(string[] args)
{
double result;
// 调用时也显式地写上out,让人一看就知道是输出参数
bool b = TryAdd("1", "100", out result);
if (b)
Console.WriteLine("{0} + {1} = {2}", "1", "100", result);
}
// a和b能被解析成double并相加成功的话才返回true
static bool TryAdd(string a, string b, out double res)
{
try
{
res = double.Parse(a) + double.Parse(b);
return true;
} catch {
res = 0;
return false;
}
}
}
Parâmetros de referência VS parâmetros de saída
Palavras-chave oute palavras-chave refsão 等效的, ou seja, os mesmos metadados e código IL serão gerados independente de qual palavra-chave for utilizada.
No entanto, o compilador C# trata os dois de maneira diferente. A diferença entre essas duas palavras-chave é 谁负责初始化.
out: O chamador não deseja inicializar o objeto antes de chamar o método, o método chamado não pode ler o valor do objeto e o método chamado deve atribuir um valor a ele antes de retornar.ref: O chamador deve primeiro inicializar o valor do parâmetro antes de chamar o método. O método chamado pode ler o parâmetro ou atribuir um valor ao parâmetro.
Parâmetros de matriz
Os parâmetros formais declarados com paramsmodificadores são 数组参数.
// 普通的数组参数声明
void Method(int[] arr){
...}
// 调用时需要先创建一个数组，然后再传入
int[] array = new int[]{
1, 2, 3};
XXX.Method(array);
// 如果加上修饰符params就可以直接在调用方法时顺序输入值
// 声明方法
void Method(params int[] arr){
...}
// 调用
XXX.Method(1, 2, 3);
// 可以直接输入而无需创建数组
Nota: A lista de parâmetros de um método pode ter apenas 0 ou 1 paramsparâmetro, e paramsos parâmetros só podem estar no final da lista de parâmetros.
Parâmetros opcionais
É isso que fornece valores padrão para parâmetros ao declarar um método 可选参数. Os parâmetros tornam-se porque possuem valores padrão 可选.
...
// 声明一个参数有默认值的方法
public void Method(string name = "李四", int age = 20){
...}
...
// 因为Method方法有默认值，所以参数是可选的
// 不传入实参，形参默认使用的是默认值
XXX.Method(); // name = "李四", age = 20
Chamada de parâmetro nomeado
Chamar com parâmetros nomeados pode ser considerado um hábito de escrever código. De modo geral, quando chamamos uma função, preenchemos apenas o valor do parâmetro (ou o nome da variável). Por exemplo, isso é considerado uma chamada XXX.Method(100, "你好");anônima . A chamada nomeada requer que o nome do parâmetro seja escrito explicitamente. Por exemplo:
...
// 方法
public void Method(int id, string name){
...}
...
// 匿名调用
XXX.Method(1, "张三");
// 具名调用
XXX.Method(id:1, name:"张三");
// 具名调用可以忽略参数列表的顺序
XXX.Method(name:"张三", id:1); // 这样写等同于上面
este parâmetro (método de extensão)
Os métodos de extensão, também conhecidos como parâmetros, podem adicionar métodos a uma classe que não pode modificar o código-fonte, mas precisa adicionar métodos.
O método deve ser public staic modificado.
O exemplo a seguir adiciona o método ToInt à classe string:
class Pragram
{
static void Main(string[] args)
{
string a = "100";
// 因为input参数就是this,会
// 自动传入a，所以不用显式传入
// 参数
int b = a.ToInt();
}
}
// 声明一个静态类，这是string的扩展类
static class StringExtension
{
// 对string扩展了ToInt方法
// 该方法可以将字符串转成int
// this修饰的必须是第一个参数
public static int ToInt(this string input)
{
int res;
try
{
res = int.Parse(input);
}
catch
{
res = -1;
}
return res;
}
}