web-dev-qa-db-fra.com

Passer des arguments nuls aux méthodes C #

Existe-t-il un moyen de passer des arguments nuls aux méthodes C # (quelque chose comme les arguments nuls en c ++)?

Par exemple:

Est-il possible de traduire la fonction c ++ suivante en méthode C #:

private void Example(int* arg1, int* arg2)
{
    if(arg1 == null)
    {
        //do something
    }
    if(arg2 == null)
    {
        //do something else
    }
}
c#methodsnull
29
Niko Gamulin

Oui. Il existe deux types de types dans .NET: les types de référence et les types de valeur.

Les types de références (généralement des classes) sont toujours référencés, ils supportent donc null sans travail supplémentaire. Cela signifie que si le type d'une variable est un type de référence, la variable est automatiquement une référence.

Les types de valeur (par exemple, int) par défaut n’ont pas de notion de null. Cependant, il existe pour eux un wrapper appelé Nullable. Cela vous permet d'encapsuler le type de valeur non nullable et d'inclure des informations nulles.

L'utilisation est légèrement différente, cependant.

// 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.
}
71
Sander

Je pense que l'équivalent C # le plus proche de int* serait ref int?. Parce que ref int? permet à la méthode appelée de renvoyer une valeur à la méthode appelante.

int*

  • Peut être nul.
  • Peut être non nul et pointer sur une valeur entière.
  • Si non null, la valeur peut être modifiéeet la modification est transmise à l'appelant.
  • La définition de la valeur null n'est pas retransmise à l'appelant.

ref int?

  • Peut être nul.
  • Peut avoir une valeur entière.
  • La valeur peut toujours être modifiéeet la modification est transmise à l'appelant.
  • La valeur peut être définie sur null et cette modification sera également transmise à l'appelant.
6
mackenir

Vous pouvez utiliser NullableValueTypes (comme int?) Pour cela. Le code serait comme ça:

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

De C # 2.0:

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

À partir de C # 2.0, vous pouvez utiliser le type générique nullable Nullable. En C #, il existe une notation abrégée du type suivi de?

par exemple.

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

On répond déjà bien à la question du PO, mais le titre est juste assez large pour que je pense qu'il tire profit de l'amorce suivante:

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() + "#");
        }
    }
}

sortie:

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

Vous pouvez utiliser 2 façons: int? ou Nullable, les deux ont le même comportement. Vous pouvez faire un mélange sans problèmes, mais il vaut mieux choisir le code le plus propre.

Option 1 (avec?):

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

Option 2 (avec Nullable):

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

À partir de C # 4.0, il existe une nouvelle façon de faire la même chose avec plus de flexibilité. Dans ce cas, le framework offre des paramètres optionnels avec des valeurs par défaut . Vous pouvez ainsi définir une valeur par défaut si la méthode est appelée sans tous les paramètres.

Option 3 (avec les valeurs par défaut)

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