How to Use Optional Parameters in C#

How can you use optional parameters in C#?

Surprised no one mentioned C# 4.0 optional parameters that work like this:

public void SomeMethod(int a, int b = 0)
{
   //some code
}

Edit: I know that at the time the question was asked, C# 4.0 didn't exist. But this question still ranks #1 in Google for "C# optional arguments" so I thought - this answer worth being here. Sorry.

Trying to use optional parameters in c#

The problem is that you're using [Optional] instead of the C# language integration for optional parameters. As far as the language is concerned (in terms of the method declaration part), num1 is a required parameter, so it has to come before optInput. The compiler does know about OptionalAttribute when consuming methods, but not when declaring them.

Assuming you wanted both parameters to be optional, use the language integration for both:

public string UserAnswer(string optInput = null, int num1 = 0)

I would strongly advise against using OptionalAttribute explicitly - there's no reason to do so now there's language support, and it's more likely to cause confusion than to help when it comes to anyone else reading the code.

Use a function to define an optional parameter

One of the ways:

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

public void ExampleMethod(int a, int b, int? c=null)
{
    c = c ?? ChangeC(a,b);
}

How do I declare a function with optional parameters in C#

You can use default values for the optional paramenters, something like:

exportToExcel(string title, DataGridView dgv, int colId1, int colId2 = 0, int colId3 = 0);

With a method like that you'd be able to make a call with 1 to 3 columns.

Also another approach would be this - the good thing about using this one is that if one day your number of columns increases or decreases you won't have to change the signature:

exportToExcel(string title, DataGridView dgv, params int[] colIds);

C# Optional parameters / multiple required

I think you need the old way - method overloading.

// b = true
public void ParamChoise(string A, string C)

// b = false
public void ParamChoise(string A)

They should call a private version of your original

private void ParamChoiseInternal(string A, bool B = false, string C = "")

You should ensure that you're giving the 2 public methods a name that accurately conveys their meaning - that will help the programmer (probably you, I know) call the right method for their current state.

After update

Same as above, names reflect requirement, and you should still be able to call your original private method. The overloads ensure your consistency

public void AOnly(string A)
public void AAndBAndC(string A, bool B, string C)

Struggling to decipher these 2:

NOT A & B WITHOUT C !!!

NOT A AND C (Because B gives the point if C is needed)

How to use multiple optional parameters in C#

Use the name:

MyMethod(3, opt2: new byte[]);

How to call Method with optional parameters using reflections c#

Optional parameters: aren't actually optional - all that happens is that the compiler normally supplies the omitted value automatically for you. Since you're not using a compiler here, you'll need to supply it yourself, using new object[] {request, constants, null}. Note that if you want to properly respect the default value (rather than knowing it is null in this case), you'd need to look at the ParameterInfo, specifically .HasDefaultValue and .DefaultValue.

Example (not using ParameterInfo, note):

using System;
using System.Reflection;

class P
{
    static void Main()
    {
        string request = "r", constants = "c", count = "#";
        var classInstance = new P();

        typeof(P).GetMethod(nameof(Method1),
            BindingFlags.Instance | BindingFlags.NonPublic)
            .Invoke(classInstance, new object[] { request, constants, null });

        typeof(P).GetMethod(nameof(Method1),
            BindingFlags.Instance | BindingFlags.NonPublic)
            .Invoke(classInstance, new object[] { request, constants, count });

        typeof(P).GetMethod(nameof(Method2),
            BindingFlags.Instance | BindingFlags.NonPublic)
            .Invoke(classInstance, new object[] { request, constants });
    }

    void Method1(string request, string constants, string count = null)
        => Console.WriteLine($"#1: {request}, {constants}, {count}");

    void Method2(string request, string constants)
        => Console.WriteLine($"#2: {request}, {constants}");
}

How can we declare Optional Parameters in C#.net?

New to visual studio 2010

named and optional arguments

for example

public void ExampleMethod(int required, string optionalstr = "default string",
int optionalint = 10)
{
}