C# | Parámetros del método

Los métodos en C# son generalmente el bloque de códigos o declaraciones en un programa que le da al usuario la capacidad de reutilizar el mismo código, lo que finalmente ahorra el uso excesivo de memoria, actúa como un ahorro de tiempo y, lo que es más importante, proporciona una mejor legibilidad del código. . Entonces, puede decir que un método es una colección de declaraciones que realizan alguna tarea específica y pueden o no devolver el resultado a la persona que llama.
Puede haber ciertas situaciones en las que el usuario desee ejecutar un método, pero a veces ese método requiere algunas entradas valiosas para ejecutar y completar sus tareas. Estos valores de entrada se conocen como parámetros en términos de lenguaje informático.

C# contiene los siguientes tipos de parámetros de método:

• Parámetros con nombre
• Parámetros de referencia
• Parámetros de salida
• Parámetros predeterminados u opcionales
• Parámetros dinámicos
• Parámetros de valor
• Parámetros

Parámetros con nombre

Usando parámetros con nombre, puede especificar el valor del parámetro según sus nombres, no su orden en el método. O dicho de otro modo, nos da la facilidad de no recordar parámetros según su orden. Este concepto se introduce en C# 4.0 . Hace que su programa sea más fácil de entender cuando trabaja con una mayor cantidad de parámetros en su método. Pero recuerde siempre que los parámetros con nombre siempre aparecen después de los argumentos fijos, si intenta proporcionar un argumento fijo después del parámetro con nombre, entonces el compilador arrojará un error.

Ejemplo:

// C# program to illustrate the 
// concept of the named parameters
using System;
  
public class GFG {
  
    // addstr contain three parameters
    public static void addstr(string s1, string s2, string s3)
    {
        string result = s1 + s2 + s3;
        Console.WriteLine("Final string is: " + result);
    }
  
    // Main Method
    static public void Main()
    {
        // calling the static method with named 
        // parameters without any order
        addstr(s1: "Geeks", s2: "for", s3: "Geeks");
                     
    }
}

Producción:

Final string is: GeeksforGeeks

Parámetros de referencia

La ref es una palabra clave en C# que se usa para pasar los tipos de valor por referencia. O podemos decir que si cualquier cambio realizado en este argumento en el método se reflejará en esa variable cuando el control regrese al método de llamada. El parámetro ref no pasa la propiedad. En los parámetros de referencia, es necesario que los parámetros se inicialicen antes de pasar a la referencia. El paso de valor a través del parámetro ref es útil cuando el método llamado también necesita cambiar el valor del parámetro pasado.

Ejemplo:

// C# program to illustrate the
// concept of ref parameter
using System;
  
class GFG {
  
    // Main Method
    public static void Main()
    {
  
        // Assigning value
        string val = "Dog";
  
        // Pass as a reference parameter
        CompareValue(ref val);
  
        // Display the given value
        Console.WriteLine(val);
    }
  
    static void CompareValue(ref string val1)
    {
        // Compare the value
        if (val1 == "Dog") 
        {
            Console.WriteLine("Matched!");
        }
  
        // Assigning new value
        val1 = "Cat";
    }
}

Producción:

Matched!
Cat

Parámetros de salida

La salida es una palabra clave en C# que se usa para pasar los argumentos a los métodos como un tipo de referencia. Generalmente se usa cuando un método devuelve múltiples valores. El parámetro out no pasa la propiedad. No es necesario inicializar los parámetros antes de que pase a out. La declaración de parámetro a lo largo de parámetro es útil cuando un método devuelve múltiples valores.

Ejemplo:

// C# program to illustrate the
// concept of out parameter
using System;
  
class GFG {
  
    // Main method
    static public void Main()
    {
  
        // Creating variable
        // without assigning value
        int num;
  
        // Pass variable num to the method
        // using out keyword
        AddNum(out num);
  
        // Display the value of num
        Console.WriteLine("The sum of"
          + " the value is: {0}",num);
                            
    }
  
    // Method in which out parameter is passed
    // and this method returns the value of
    // the passed parameter
    public static void AddNum(out int num)
    {
        num = 40;
        num += num;
    }
}

Producción:

The sum of the value is: 80

Parámetros predeterminados u opcionales

Como sugiere el nombre, los parámetros opcionales no son parámetros obligatorios, son opcionales. Ayuda a excluir argumentos para algunos parámetros. O podemos decir en parámetros opcionales, no es necesario pasar todos los parámetros en el método. Este concepto se introduce en C# 4.0. Aquí, todos y cada uno de los parámetros opcionales contienen un valor predeterminado que es parte de su definición. Si no pasamos ningún argumento a los parámetros opcionales, toma su valor predeterminado. Los parámetros opcionales siempre se definen al final de la lista de parámetros. O en otras palabras, el último parámetro del método, constructor, etc. es el parámetro opcional.

Ejemplo:

// C# program to illustrate the 
// concept of optional parameters 
using System; 
    
class GFG { 
    
    // This method contains two regular 
    // parameters, i.e. ename and eid
    // And two optional parameters, i.e. 
    // bgrp and dept 
    static public void detail(string ename,  
                               int eid, 
                               string bgrp = "A+", 
                    string dept = "Review-Team") 
    
    { 
        Console.WriteLine("Employee name: {0}", ename); 
        Console.WriteLine("Employee ID: {0}", eid); 
        Console.WriteLine("Blood Group: {0}", bgrp); 
        Console.WriteLine("Department: {0}", dept); 
    } 
    
    // Main Method 
    static public void Main() 
    { 
    
        // Calling the detail method 
        detail("XYZ", 123); 
        detail("ABC", 456, "B-"); 
        detail("DEF", 789, "B+", 
           "Software Developer"); 
    } 
} 

Producción:

Employee name: XYZ
Employee ID: 123
Blood Group: A+
Department: Review-Team
Employee name: ABC
Employee ID: 456
Blood Group: B-
Department: Review-Team
Employee name: DEF
Employee ID: 789
Blood Group: B+
Department: Software Developer

Parámetros dinámicos

En C# 4.0 , se introduce un nuevo tipo de parámetros que se conoce como parámetro dinámico. Aquí los parámetros pasan dinámicamente significa que el compilador no verifica el tipo de la variable de tipo dinámico en tiempo de compilación, en lugar de esto, el compilador obtiene el tipo en tiempo de ejecución. La variable de tipo dinámico se crea utilizando una palabra clave dinámica.

Ejemplo:

// C# program to illustrate the concept 
// of the dynamic parameters
using System;
  
class GFG {
  
    // Method which contains dynamic parameter
    public static void mulval(dynamic val)
    {
        val *= val;
        Console.WriteLine(val);
    }
  
    // Main method
    static public void Main()
    {
  
        // Calling mulval method
        mulval(30);
    }
}

Producción:

900

Parámetros de valor

Es un parámetro de valor normal en un método o puede decir el paso de tipos de valor por valor. Entonces, cuando las variables se pasan como tipo de valor, contienen los datos o el valor, no ninguna referencia. Si realiza algún cambio en el parámetro de tipo de valor, no reflejará el valor original almacenado como argumento.

Ejemplo:

// C# program to illustrate value parameters
using System;
  
public class GFG {
  
    // Main Method
    static public void Main()
    {
  
        // The value of the parameter
        // is already assigned
        string str1 = "Geeks";
        string str2 = "geeks";
        string res = addstr(str1, str2);
        Console.WriteLine(res);
    }
  
    public static string addstr(string s1, string s2)
    {
        return s1 + s2;
    }
}

Producción:

Geeksgeeks

Parámetros

Es útil cuando el programador no tiene conocimiento previo sobre la cantidad de parámetros a utilizar. Al usar params, puede pasar cualquier número variable de argumentos. Solo se permite una palabra clave params y no se permitirán parámetros adicionales en la declaración de función después de una palabra clave params. La longitud de los parámetros será cero si no se pasan argumentos.

Ejemplo:

// C# program to illustrate params
using System;
namespace Examples {
  
class Geeks {
  
    // function containing params parameters
    public static int mulval(params int[] num)
    {
        int res = 1;
  
        // foreach loop
        foreach(int j in num)
        {
            res *= j;
        }
        return res;
    }
  
    static void Main(string[] args)
    {
  
        // Calling mulval method
        int x = mulval(20, 49, 56, 69, 78);
  
        // show result
        Console.WriteLine(x);
    }
}
}

Producción:

295364160