C# Language
Métodos

Declarar un método

Cada método tiene una firma única que consiste en un descriptor de acceso ( public , private , ...), un modificador opcional ( abstract ), un nombre y, si es necesario, parámetros del método. Tenga en cuenta que el tipo de retorno no es parte de la firma. Un prototipo de método se parece a lo siguiente:

AccessModifier OptionalModifier ReturnType MethodName(InputParameters)
{
    //Method body
}

AccessModifier puede ser public , protected , pirvate o por defecto internal .

OptionalModifier puede ser virtual override virtual abstract static new o sealed .

ReturnType puede void para no devolverse o puede ser de cualquier tipo desde los básicos, como int a clases complejas.

un método puede tener algunos o ningún parámetro de entrada. para establecer parámetros para un método, debe declarar cada una como declaraciones de variables normales (como int a ), y para más de un parámetro debe usar una coma entre ellos (como int a, int b ).

Los parámetros pueden tener valores por defecto. para esto, debe establecer un valor para el parámetro (como int a = 0 ). Si un parámetro tiene un valor predeterminado, establecer el valor de entrada es opcional.

El siguiente ejemplo de método devuelve la suma de dos enteros:

private int Sum(int a, int b)
{
    return a + b;
} 

Llamando a un método

Llamando a un método estático:

// Single argument
System.Console.WriteLine("Hello World");  

// Multiple arguments
string name = "User";
System.Console.WriteLine("Hello, {0}!", name);  

Llamando a un método estático y almacenando su valor de retorno:

string input = System.Console.ReadLine();

Llamando a un método de instancia:

int x = 42;
// The instance method called here is Int32.ToString()
string xAsString = x.ToString();

Llamando a un método genérico

// Assuming a method 'T[] CreateArray<T>(int size)'
DateTime[] dates = CreateArray<DateTime>(8);

Parámetros y Argumentos

Un método puede declarar cualquier número de parámetros (en este ejemplo, i , s y o son los parámetros):

static void DoSomething(int i, string s, object o) {
    Console.WriteLine(String.Format("i={0}, s={1}, o={2}", i, s, o));
}

Los parámetros se pueden usar para pasar valores a un método, de modo que el método pueda trabajar con ellos. Puede tratarse de todo tipo de trabajos, como imprimir los valores, realizar modificaciones en el objeto referenciado por un parámetro o almacenar los valores.

Cuando llama al método, debe pasar un valor real para cada parámetro. En este punto, los valores que realmente pasa a la llamada al método se denominan Argumentos:

DoSomething(x, "hello", new object());

Tipos de retorno

Un método puede devolver nada ( void ) o un valor de un tipo especificado:

// If you don't want to return a value, use void as return type.
static void ReturnsNothing() { 
    Console.WriteLine("Returns nothing");
}

// If you want to return a value, you need to specify its type.
static string ReturnsHelloWorld() {
    return "Hello World";
}

Si su método especifica un valor de retorno, el método debe devolver un valor. Haces esto usando la declaración de return . Una vez que se ha alcanzado una declaración de return , devuelve el valor especificado y cualquier código después de que ya no se ejecute (las excepciones finally son bloques, que aún se ejecutarán antes de que el método regrese).

Si su método no devuelve nada ( void ), aún puede usar la declaración de return sin un valor si desea regresar del método inmediatamente. Al final de tal método, una declaración de return sería innecesaria sin embargo.

Ejemplos de declaraciones de return válidas:

return; 
return 0; 
return x * 2;
return Console.ReadLine();

Lanzar una excepción puede finalizar la ejecución del método sin devolver un valor. Además, hay bloques de iteradores, donde los valores de retorno se generan mediante el uso de la palabra clave de rendimiento, pero esos son casos especiales que no se explicarán en este momento.

Parámetros predeterminados

Puede usar parámetros predeterminados si desea proporcionar la opción de omitir parámetros:

static void SaySomething(string what = "ehh") {
    Console.WriteLine(what);
}  

static void Main() {
    // prints "hello"
    SaySomething("hello"); 
    // prints "ehh"
    SaySomething(); // The compiler compiles this as if we had typed SaySomething("ehh")
}

Cuando llama a un método de este tipo y omite un parámetro para el que se proporciona un valor predeterminado, el compilador inserta ese valor predeterminado para usted.

Tenga en cuenta que los parámetros con valores predeterminados deben escribirse después de los parámetros sin valores predeterminados.

static void SaySomething(string say, string what = "ehh") {
        //Correct
        Console.WriteLine(say + what);
    }

static void SaySomethingElse(string what = "ehh", string say) {
        //Incorrect
        Console.WriteLine(say + what);
    }   

ADVERTENCIA : debido a que funciona de esa manera, los valores predeterminados pueden ser problemáticos en algunos casos. Si cambia el valor predeterminado de un parámetro de método y no vuelve a compilar a todos los llamadores de ese método, esos llamadores seguirán usando el valor predeterminado que estaba presente cuando se compilaron, lo que podría causar inconsistencias.

Método de sobrecarga

Definición: Cuando se declaran múltiples métodos con el mismo nombre con diferentes parámetros, se denomina sobrecarga del método. La sobrecarga de métodos generalmente representa funciones que son idénticas en su propósito pero que están escritas para aceptar diferentes tipos de datos como sus parámetros.

Factores que afectan

• Número de Argumentos
• Tipo de argumentos
• Tipo de devolución **

Considere un método llamado Area que realizará funciones de cálculo, que aceptará varios argumentos y devolverá el resultado.

Ejemplo

public string Area(int value1)
{
    return String.Format("Area of Square is {0}", value1 * value1);
}

Este método aceptará un argumento y devolverá una cadena, si llamamos al método con un entero (por ejemplo, 5 ), la salida será "Area of Square is 25" .

public  double Area(double value1, double value2)
{
    return value1 * value2;
}

De manera similar, si pasamos dos valores dobles a este método, la salida será el producto de los dos valores y será de tipo doble. Esto puede ser usado tanto para la multiplicación como para encontrar el área de los rectángulos.

public double Area(double value1)
{
    return 3.14 * Math.Pow(value1,2);
}

Esto se puede usar especialmente para encontrar el área del círculo, que acepta un valor doble ( radius ) y devuelve otro valor doble como su Área.

Cada uno de estos métodos se puede llamar normalmente sin conflicto: el compilador examinará los parámetros de cada llamada de método para determinar qué versión de Area debe usar.

string squareArea = Area(2);
double rectangleArea = Area(32.0, 17.5);
double circleArea = Area(5.0); // all of these are valid and will compile.

** Tenga en cuenta que el tipo de retorno solo no puede diferenciar entre dos métodos. Por ejemplo, si tuviéramos dos definiciones para el Área que tenían los mismos parámetros, así:

public string Area(double width, double height) { ... }
public double Area(double width, double height) { ... }
// This will NOT compile. 

Si necesitamos que nuestra clase use los mismos nombres de métodos que devuelven valores diferentes, podemos eliminar los problemas de ambigüedad implementando una interfaz y definiendo explícitamente su uso.

public interface IAreaCalculatorString {
    
    public string Area(double width, double height);

}

public class AreaCalculator : IAreaCalculatorString {

    public string IAreaCalculatorString.Area(double width, double height) { ... } 
    // Note that the method call now explicitly says it will be used when called through
    // the IAreaCalculatorString interface, allowing us to resolve the ambiguity.
    public double Area(double width, double height) { ... }

Método anónimo

Los métodos anónimos proporcionan una técnica para pasar un bloque de código como un parámetro delegado. Son métodos con cuerpo, pero sin nombre.

delegate int IntOp(int lhs, int rhs);

class Program
{
    static void Main(string[] args)
    {
        // C# 2.0 definition
        IntOp add = delegate(int lhs, int rhs)
        {
            return lhs + rhs;
        };

        // C# 3.0 definition
        IntOp mul = (lhs, rhs) =>
        {
            return lhs * rhs;
        };

        // C# 3.0 definition - shorthand
        IntOp sub = (lhs, rhs) => lhs - rhs;

        // Calling each method
        Console.WriteLine("2 + 3 = " + add(2, 3));
        Console.WriteLine("2 * 3 = " + mul(2, 3));
        Console.WriteLine("2 - 3 = " + sub(2, 3));
    }
}

Derechos de acceso

// static: is callable on a class even when no instance of the class has been created
public static void MyMethod()

// virtual: can be called or overridden in an inherited class
public virtual  void MyMethod()

// internal: access is limited within the current assembly
internal  void MyMethod()

//private: access is limited only within the same class
private  void MyMethod()

//public: access right from every class / assembly
public void MyMethod()

//protected: access is limited to the containing class or types derived from it
protected void MyMethod()

//protected internal: access is limited to the current assembly or types derived from the containing class.
protected internal void MyMethod()