Comment passer des paramètres facultatifs pour une méthode en C#?

Comment passer des paramètres facultatifs pour une méthode en C# ?

Supposons que j'ai créé une méthode appelée Sendcommand

public void SendCommand(String command,string strfilename)
{

    if (command == "NLST *" ) //Listing Files from Server.
    {
        //code
    }
    else if (command == "STOR " + Path.GetFileName(uploadfilename)) //Uploading file to Server
    {
        //code
    }
    else if ...
}

Maintenant, j'ai envie d'appeler cette méthode dans la méthode main comme

Sendcommand("STOR ", filename);
Sendcommand("LIST"); //In this case i dont want to pass the second parameter

Comment y parvenir?

double possible de Comment pouvez-vous utiliser l'option paramètres en C#?
Veuillez voir ma réponse: ne pas utiliser une seule méthode, utiliser une méthode par commande ou d'une commande distincte de la classe pour chaque commande

OriginalL'auteur Swapnil Gupta | 2010-07-29

11

Utiliser les paramètres d'attribut:
```
public void SendCommand(String command, params string[] strfilename)
{
}
```
ensuite, vous pouvez l'appeler comme ceci:
```
SendCommand("cmd");
SendCommand("cmd", "a");
SendCommand("cmd", "b");
```
ou si vous utilisez C# 4.0, vous pouvez utiliser la nouvelle option arguments de la fonction:
```
public void SendCommand(String command, string strfilename=null)
{ 
   if (strfilename!=null) .. 
}
```
En ajoutant ce commentaire ici, où il peut être vu - merci de ne pas mettre en œuvre une méthode unique qui fait beaucoup de choses tout à fait différentes. Une méthode doit être à peu près de langue faire un tâche. Cela signifie que des commandes simples peuvent être dans des méthodes - ou si les commandes sont complexes, créer une classe pour chaque commande. C'est pour la maintenabilité, la lisibilité, debuggability, et plus encore. SendCommand doit être nommé de la façon appropriée, qu'il ne fait d'envoyer une commande quelque part? Si elle est nécessaire, elle pourrait être appelée ParseCommand - il l'analyse et laisse l'exécution à d'autres méthodes/classes.
Notez également que dans le cas où vous avez plusieurs arguments optionnels, vous pouvez utiliser une virgule pour désigner le paramètre facultatif vous faites référence. Ex.: SendCommand("cmd", strfilename:"abc" );

OriginalL'auteur codymanix
15

Pré .NET 4, vous devez surcharger la méthode:
```
public void sendCommand(String command)
{
    sendCommand(command, null);
}
```
.NET 4 prend en charge les paramètres par défaut, vous permettant de faire tout cela en une seule ligne.
```
public void SendCommand(String command, string strfilename = null)
{
  //method body as in question
}
```
Par ailleurs, dans la question que vous avez écrit vous n'êtes pas à l'appel de la méthode dans votre premier exemple:
```
Sendcommand("STOR " + filename);
```
est encore à l'aide d'un seul paramètre qui est la concaténation des deux chaînes.

J'ai pensé à cela, mais dans ce cas, je ne suis pas sûr d'avoir une surcharge de l'appel de l'autre avec la valeur 'null' est nécessaire, il semble probable qu'un ensemble de commandes nécessiterait le paramètre, et une autre série ne serait pas, de sorte que chaque surcharge simplement gère un ensemble différent de commandes.
Désolé, c'est la virgule Sendcommand("STOR ", filename);

OriginalL'auteur Martin Harris
2

La réponse la plus évidente pour ce qui devrait être, ne pas faire de cette façon.

Vous devez avoir une méthode distincte pour chaque commande ou une commande de la classe de base et une autre classe dérivée pour chaque commande, avec une méthode Execute.

C'est mauvais design afin d'avoir une méthode qui gère tous les moyens imaginables de commande.

Vous ne voulez vraiment pas un Sendcommand() de traiter chaque commande possibles.

Si j'ai 100 commandes, je dois écrire 100 méthodes dans ce cas ?
Oui. Il serait préférable d'avoir 100 classes en fait un fichier avec 100 méthodes est de trop. Ces deux options sont cent fois mieux qu'une méthode qui gère l'exécution de 100 commandes! Pouvez-vous imaginer combien de temps cette méthode, comment dur il serait pour déboguer, comment de nombreux paramètres facultatifs il aurait du avoir: probablement en retrait, il sera difficile de voir qui { ou } est qui. Vous avez certainement, certainement, certainement ne voulez pas qu'une méthode pour traiter toutes les commandes. Un par commande ou une classe par commande.

OriginalL'auteur Kieren Johnstone
1

Vérifier C# 4.0 Paramètres Optionnels.

Assurez-vous également que vous utilisez .NET 4.

Si vous avez besoin d'utiliser des versions plus anciennes de .NET.

Surcharge de la méthode est la solution :
```
public void SendCommand(String command)
{
    SendCommand(command, null);
    //or SendCommand(command, String.Empty);
} 

public void SendCommand(String command, String fileName)
{
    //your code here
} 
```
C'est la surcharge, pas majeur 🙂
Merci, corrigé.

OriginalL'auteur Incognito

Gens,

J'ai été à la recherche à ce fil, en essayant de résoudre un problème qui n'existe pas réellement, parce que le C# "juste passe par" un tableau params! Que je ne connaissais pas jusqu'à ce que je l'ai juste essayé.

Voici un SSCCE:

using System;
using System.Diagnostics; //for Conditional compilation of method CONTENTS

namespace ConsoleApplication3
{
    public static class Log
    {
        [Conditional("DEBUG")] //active in Debug builds only (a no-op in Release builds)
        public static void Debug(string format, params object[] parms) {
            Console.WriteLine(format, parms); 
            //calls Console.WriteLine(string format, params object[] arg);
            //which I presume calls String.Format(string format, params object[] arg);
            //(Sweet! just not what I expected ;-)
        }
    }

    class Program //LogTest
    {
        static void Main(string[] args) {
            Log.Debug("args[0]={0} args[1]={1}", "one", "two");
            Console.Write("Press any key to continue . . .");
            Console.ReadKey();
        }

    }
}

Produit:

args[0]=one args[1]=two

Doux!

Mais pourquoi? ... Eh bien parce que (bien sûr) le plus proche de paramètre-match pour le très-surcharge de la Console.Méthode WriteLine est (string format, params object[] arg) ... pas (string format, object arg) que je pensais.

Je sorte savais que cela devait être possible, en quelque sorte, parce que (je suppose) de la Console.WriteLine t-il, je viens en quelque sorte, il devrait être DUR... et donc à penser que la simplicité et la "gentillesse" de ce truc-de-la-langue est digne de mention.

CSharpLanguageDesigners.ToList().ForEach(dude=>dude.Kudos++);

Acclamations. Keith.

PS: je me demande si VB.NET se comporte de la même manière? Je suppose qu'il doit.

OriginalL'auteur corlettk

0

Il y a trois solutions faciles à celui-ci:
1. La surcharge de la méthode
2. Permettre à la méthode d'accepter 'null', et gérer de manière appropriée
3. Utilisation .NET 4, qui permet à des paramètres facultatifs
OriginalL'auteur Flynn1179
0

Créer une autre méthode qui appelle le premier?
```
public void SendCommand(String command)
{
    SendCommand(command, null);
}
```
Je veux DotNet 3.5 un exemple s'il vous plaît ....

OriginalL'auteur Arcturus

Surcharge de la fonction. plutôt que de vérifier pour la branche conditionnelle. Quelque chose comme ceci:

public void SendCommand(String command,string strfilename)
{    
    if (command == "STOR " + 
        Path.GetFileName(uploadfilename)) //Uploading file to Server
    {
        //code
    }
    else if ............
}

public void SendCommand(String command)
{ 
        //code

}

OriginalL'auteur loxxy

0

Vous pouvez le faire de plusieurs façons. Si vous êtes en utilisant .NET 4.0, vous pouvez utiliser les paramètres facultatifs sur la méthode:
```
public void SendCommand(String command,string strfilename = null)
{
    ....
}
```
Sinon, vous pouvez simplement créer une autre méthode qui appelle la méthode que vous avez déjà, mais en passant les paramètres par défaut que vous voulez être en option:
```
public void SendCommand(String command)
{
    SendCommand(command,null);
}
```
OriginalL'auteur Jonathon Bolster
0

Facultatif fonction de paramètres entrent en c# 4.0 ici est le lien. Sinon, il faut écrire une fonction surchargée.

OriginalL'auteur Siddiqui
0

Toutes les réponses sur cette page sont valables façons d'accepter des paramètres facultatifs, mais dans de nombreux cas, ce est un signe que votre méthode est d'essayer d'en faire trop.

Dans de nombreux cas, vous pourriez être mieux avec la suite sans ambiguïté des méthodes...
```
public void GetFileListFromServer()
{
    //Listing Files from Server.
    //code
}

public void UploadFileToServer(string strfilename)
{
    //Uploading file to Server
    //code
}
```
OriginalL'auteur Fenton

Vous pouvez utiliser le mot clé params :

private static void SendCommand(String command, params string[] filenames)
{

    if (command == "NLST *" ) //Listing Files from Server.
    {
        //code
    }

    if (command == "STOR ")
    {
        foreach (string fileName in filenames)
        {
            if (String.IsNullOrWhiteSpace(fileName))
            {
                //code
            }
        }
    }
}

et vous pouvez l'utiliser comme :

static void Main(string[] args)
{
    SendCommand("NLST *");
    SendCommand("STOR ", "myfile1.txt", "myfile.txt");
}

OriginalL'auteur Florian

Vous devez vous connecter pour publier un commentaire.