pasar - parametros programacion c#

Pasar argumentos nulos a los métodos C#

Question

¿Hay alguna manera de pasar argumentos nulos a los métodos de C # (algo así como argumentos nulos en c ++)?

Por ejemplo:

¿Es posible traducir la siguiente función de C ++ al método de C #?

private void Example(int* arg1, int* arg2)
{
    if(arg1 == null)
    {
        //do something
    }
    if(arg2 == null)
    {
        //do something else
    }
}

Answer 1

A partir de C # 2.0, puede utilizar el tipo genérico de nulos Nullable, y en C # hay una notación abreviada del tipo seguido de?

p.ej

private void Example(int? arg1, int? arg2)
{
    if(arg1 == null)
    {
        //do something
    }
    if(arg2 == null)
    {
        //do something else
    }
}

Answer 2

Creo que el C # más cercano equivalente a int* sería ref int? . Porque ref int? permite que el método llamado pase un valor de regreso al método de llamada.

int*

• Puede ser nulo
• Puede ser no nulo y apuntar a un valor entero.
• Si no es nulo, el valor puede cambiarse y el cambio se propaga a la persona que llama.
• La configuración para null no se transfiere a la persona que llama .

ref int?

• Puede ser nulo
• Puede tener un valor entero
• El valor puede cambiarse siempre , y el cambio se propaga a la persona que llama.
• El valor puede establecerse en nulo, y este cambio también se propagará a la persona que llama .

Answer 3

De C # 2.0:

private void Example(int? arg1, int? arg2)
{
    if(arg1 == null)
    {
        //do something
    }
    if(arg2 == null)
    {
        //do something else
    }
}

Answer 4

La pregunta del OP ya está bien respondida, pero el título es lo suficientemente amplio como para pensar que se beneficia del siguiente manual:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace consolePlay
{
    class Program
    {
        static void Main(string[] args)
        {
            Program.test(new DateTime());
            Program.test(null);
            //Program.test(); // <<< Error.  
            // "No overload for method ''test'' takes 0 arguments"  
            // So don''t mistake nullable to be optional.

            Console.WriteLine("Done.  Return to quit");
            Console.Read();
        }

        static public void test(DateTime? dteIn)
        {
            Console.WriteLine("#" + dteIn.ToString() + "#");
        }
    }
}

salida:

#1/1/0001 12:00:00 AM#
##
Done.  Return to quit

Answer 5

Puede usar NullableValueTypes (como int?) Para esto. El código sería así:

private void Example(int? arg1, int? arg2)
{
    if(!arg1.HasValue)
    {
        //do something
    }
    if(!arg2.HasValue)
    {
        //do something else
    }
}

Answer 6

Puedes usar 2 formas: int? o Nullable, ambos tienen el mismo comportamiento. Podría hacer una mezcla sin problemas, pero es mejor elegir uno para hacer el código más limpio.

Opción 1 (¿Con?):

private void Example(int? arg1, int? arg2)
    {
        if (arg1.HasValue)
        {
            //do something
        }
        if (arg1.HasValue)
        {
            //do something else
        }
    }

Opción 2 (con Nullable):

private void Example(Nullable<int> arg1, Nullable<int> arg2)
    {
        if (arg1.HasValue)
        {
            //do something
        }
        if (arg1.HasValue)
        {
            //do something else
        }
    }

Desde C # 4.0 surge una nueva forma de hacer lo mismo con más flexibilidad, en este caso el framework ofrece parámetros opcionales con valores predeterminados , de esta manera puede establecer un valor predeterminado si se llama al método sin todos los parámetros.

Opción 3 (Con valores predeterminados)

private void Example(int arg1 = 0, int arg2 = 1)
    {
        //do something else
    }

Answer 7

Sí. Hay dos tipos de tipos en .NET: tipos de referencia y tipos de valores.

Los tipos de referencias (generalmente clases) siempre se refieren a referencias, por lo que admiten null sin ningún trabajo adicional. Esto significa que si el tipo de una variable es un tipo de referencia, la variable es automáticamente una referencia.

Los tipos de valor (por ejemplo, int) de forma predeterminada no tienen un concepto de nulo. Sin embargo, hay un contenedor para ellos llamado Nullable. Esto le permite encapsular el tipo de valor que no admite nulos e incluye información nula.

El uso es ligeramente diferente, sin embargo.

// Both of these types mean the same thing, the ? is just C# shorthand.
private void Example(int? arg1, Nullable<int> arg2)
{
    if (arg1.HasValue)
        DoSomething();

    arg1 = null; // Valid.
    arg1 = 123;  // Also valid.

    DoSomethingWithInt(arg1); // NOT valid!
    DoSomethingWithInt(arg1.Value); // Valid.
}