CODEWITHSUNDEEP
.netc#-4.0optional-parameters
Swapnil Gupta
Swapnil Gupta

Reputation: 8941

How to pass optional parameters to a method in C#?

How to pass optional parameters to a method in C#?

Suppose I created one method called 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 ...
}

Now I want to call this method in main method like

SendCommand("STOR ", filename);
SendCommand("LIST"); // In this case i don't want to pass the second parameter

How to achieve that?

Upvotes: 11

Views: 53234

Answers (13)

Siddiqui
Siddiqui

Reputation: 7840

Optional parameters feature come in c# 4.0 here is the link. Otherwise you have to write overloaded function.

Upvotes: 0

Incognito
Incognito

Reputation: 16597

Check C# 4.0 Optional Parameters.

Also make sure you are using .NET 4.

If you need to use older versions of .NET.

Method overloading is the solution :

public void SendCommand(String command)
{
    SendCommand(command, null);
    // or SendCommand(command, String.Empty);
} 

public void SendCommand(String command, String fileName)
{
    // your code here
}

Upvotes: 1

dosnetCore
dosnetCore

Reputation: 55

Using [option] attribute of Runtime.InteropServices namespace has not yet been proposed here.

Check 4 Different ways to make Method Parameter Optional in C#

Upvotes: 0

Kieren Johnstone
Kieren Johnstone

Reputation: 42013

The obvious answer for this should be, don't do it that way.

You should either have a separate method for each command, or a command base class and a separate derived class for each command, with an Execute method.

It's bad design to have one method that handles every conceivable command.

You really don't want one Sendcommand() to handle every possible command.

Upvotes: 5

corlettk
corlettk

Reputation: 13574

Folks,

I was looking at this thread, trying to solve a problem that doesn't actually exist, because C# "just passes through" a params array! Which I didn't know until I just tried it.

Here's an 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();
        }

    }
}

Produces:

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

Sweet!

But why? ... Well because (of course) the closest parameter-match to the heavily-overloaded Console.WriteLine method is (string format, params object[] arg) ... not (string format, object arg) as I was thinking.

I sort-of knew this had to be possible somehow, because (I presume) Console.WriteLine does it, I just somehow expected it to be HARD... and therefore think that the simplicity and "niceness" of this trick-of-the-language is note worthy. 

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

Cheers. Keith.

PS: I wonder if VB.NET behaves the same way? I suppose it must.

Upvotes: 1

Florian
Florian

Reputation: 4738

You can use params keyword :

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
            }
        }
    }
}

and you can use it as :

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

Upvotes: 0

Fenton
Fenton

Reputation: 251262

All of the answers given on this page are valid ways of accepting optional parameters, but in many cases, this is a sign that your method is trying to do too much.

In many cases you may be better off with the following unambiguous methods...

public void GetFileListFromServer()
{
    //Listing Files from Server.
    //code
}

public void UploadFileToServer(string strfilename)
{
    //Uploading file to Server
    //code
}

Upvotes: 0

Jonathon Bolster
Jonathon Bolster

Reputation: 15961

You can do this in a few ways. If you're using .NET 4.0, you can use optional parameters on the method:

public void SendCommand(String command,string strfilename = null)
{
    ....
}

Otherwise, you can just create another method which calls the method you already have but passing the default parameters you want to be optional:

public void SendCommand(String command)
{
    SendCommand(command,null);
}

Upvotes: 0

codymanix
codymanix

Reputation: 29540

Use the params attribute:

public void SendCommand(String command, params string[] strfilename)
{
}

then you can call it like this:

SendCommand("cmd");
SendCommand("cmd", "a");
SendCommand("cmd", "b");

or if you use C# 4.0 you can use the new optional arguments feature:

public void SendCommand(String command, string strfilename=null)
{ 
   if (strfilename!=null) .. 
}

Upvotes: 17

loxxy
loxxy

Reputation: 13151

Overload the function. rather than checking for conditional branch. Something like this:

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

}

Upvotes: 0

Arcturus
Arcturus

Reputation: 27065

Create another method which calls the first?

public void SendCommand(String command)
{
    SendCommand(command, null);
}

Upvotes: 0

Flynn1179
Flynn1179

Reputation: 12075

There's three easy solutions to this one:

  1. Overload the method
  2. Allow the method to accept 'null', and handle appropriately
  3. Use .NET 4, which allows optional parameters

Upvotes: 0

Martin Harris
Martin Harris

Reputation: 28637

Pre .NET 4 you need to overload the method:

public void sendCommand(String command)
{
    sendCommand(command, null);
}

.NET 4 introduces support for default parameters, which allow you to do all this in one line.

public void SendCommand(String command, string strfilename = null)
{
  //method body as in question
}

By the way, in the question as you have written it you aren't calling the method in your first example either:

Sendcommand("STOR " + filename);

is still using a single parameter which is the concatenation of the two strings.

Upvotes: 17

Related Questions