C#

Some languages (such as the Managed Extensions for C++ and Microsoft Visual Basic 2005) support the assignment of default values to arguments. For example, the following is a legitimate Visual Basic 2005 declaration that has default values for two of the arguments.

<code>
Visual Basic  Copy Code 
Public Sub MyMethod (a as Integer, _
                     Optional b as Double = 1.2, _
                     Optional c as Integer = 1)
 
</code>
You can use a parameter attribute to assign a default parameter value. 

In Visual Basic and C++, optional parameters can be omitted when the method is called. In C# values must be specified for optional arguments.

For example, all the following Visual Basic and C++ examples are valid calls for MyMethod.

Visual Basic  Copy Code 
<code>
MyMethod(10, 55.3, 12)
MyMethod(10, 1.3) ' c == 1
MyMethod(11) ' b == 1.2, c == 1
 </code>

C++  Copy Code 
<code>
MyMethod(10, 55.3, 12);
MyMethod(10, 1.3);   // c == 1
MyMethod(11);        // b == 1.2, c == 1
</code>

To retrieve the default value of an argument using reflection, get a ParameterInfo object for the parameter, and then retrieve the default value using the ParameterInfo.DefaultValue property. If there is no default value, the property returns Value.DBNull.

The following example displays the default values for MyMethod to the console.

Visual Basic  Copy Code
<code> 
Dim m As MethodInfo = t.GetMethod("MyMethod")
Dim ps As ParameterInfo() = m.GetParameters()
Dim i As Integer
For i = 0 To ps.Length - 1
    Console.WriteLine("Default Value == {0}", ps(i).DefaultValue)
Next i
 </code>
C#  Copy Code
<code> 
MethodInfo m = t.GetMethod("MyMethod");
ParameterInfo[] ps = m.GetParameters();
for (int i = 0; i < ps.Length; i++) 
{
    Console.WriteLine("Default Value == {0}", ps[i].DefaultValue);
}
 </code>
C++  Copy Code
<code> 
MethodInfo m = t->GetMethod("MyMethod");
ParameterInfo[] ps = m->GetParameters();
for (int i = 0; i < ps.Length; i++) 
{
    Console::WriteLine(S"Default Value == {0}", ps[i]->DefaultValue);
}
 
</code>
To invoke methods that have arguments with default values, use Type.Missing as a parameter value to the InvokeMember method. This enables the late-binding service to use the default value for the indicated parameter value. If Type.Missing is passed for a parameter that has no default value, an ArgumentException is thrown. It is important to note that not all compilers' binding mechanisms might respect these rules for Type.Missing. Some binders might not support this functionality, or might treat Type.Missing differently. When using Type.Missing, the default values do not have to be trailing.

The C# language does not support default arguments.

The following Visual Basic 2005 example shows how to use Reflection to invoke methods that have default arguments.

  Copy Code 
<code>
Option Strict Off
Imports System
Imports System.Reflection
Public Class OptionalArg
    Public Sub MyMethod (a As Integer, Optional b As Double = 1.2, Optional c As Integer=1)
        Console.WriteLine("a = " & a & " b = " & b & " c = " & c)
    End Sub
End Class
Module Module1
    Sub Main()
        Dim o As New OptionalArg
        Dim t As Type
        t = GetType(OptionalArg)
        Dim Param As Object()= {10, 20, 30}
        t.InvokeMember("MyMethod", _
                        BindingFlags.Public Or _
                        BindingFlags.Instance Or _
                        BindingFlags.InvokeMethod Or _
                        BindingFlags.OptionalParamBinding, _
                        Nothing, _
                        o, _
                        New Object() {10, 55.3, 12})
        t.InvokeMember("MyMethod", _
                        BindingFlags.Public Or _
                        BindingFlags.Instance Or _
                        BindingFlags.InvokeMethod Or _
                        BindingFlags.OptionalParamBinding, _
                        Nothing, _
                        o, _
                        New Object() {10, 1.3, Type.Missing})
        t.InvokeMember("MyMethod", _
                        BindingFlags.Public Or _
                        BindingFlags.Instance Or _
                        BindingFlags.InvokeMethod Or _
                        BindingFlags.OptionalParamBinding, _
                        Nothing, _
                        o, _
                        New Object() {10, Type.Missing, Type.Missing})
    End Sub
End Module
 
</code>
When using the preceding technique, trailing default arguments are considered even when the caller specifies no value. This is the most common way to invoke methods with default arguments.

private void MyMethod(int x, int y, int z)
{...}

private void MyMethod(int x, int y)
{
  MyMethod(x, y, 10); //gives z default value 10
}

private void MyMethod(int x)
{
  MyMethod(x, 5); //gives y default value 5
}

using System;<br />
public class MyClass <br />
{<br />
<br />
    public static void UseParams(params int[] list) <br />
    {<br />
        for (int i = 0 ; i < list.Length; i++)<br />
        {<br />
            Console.WriteLine(list[i]);<br />
        }<br />
        Console.WriteLine();<br />
    }<br />
<br />
    public static void UseParams2(params object[] list) <br />
    {<br />
        for (int i = 0 ; i < list.Length; i++)<br />
        {<br />
            Console.WriteLine(list[i]);<br />
        }<br />
        Console.WriteLine();<br />
    }<br />
<br />
    static void Main() <br />
    {<br />
        UseParams(1, 2, 3);<br />
        UseParams2(1, 'a', "test"); <br />
<br />
        // An array of objects can also be passed, as long as<br />
        // the array type matches the method being called.<br />
        int[] myarray = new int[3] {10,11,12};<br />
        UseParams(myarray);<br />
    }<br />
}

public void DoSomething(params string[] items)
{
  if (items != null && items.Length > 0)
  {
    foreach (string item in item)
    {
      // Do something.
    }
  }
}

<br />
string str; //your string <br />
<br />
XmlDocument xmlDoc=new XmlDocument();<br />
xmlDoc.LoadXml(str);<br />
<br />
<br />
MemoryStream stream = new MemoryStream();<br />
<br />
StreamWriter sw = new StreamWriter(stream);<br />
sw.Write(str);<br />
<br />

switch (something)
{
    case A:
        // do something
        goto B;

    case B:
        // do something different
        break;
}

<br />
<br />
            ArrayList arr = null;<br />
            NewArr(out arr);<br />
        }<br />
<br />
        static void NewArr(out ArrayList arr)<br />
        {<br />
            arr = new ArrayList();<br />
        }<br />

Yanshof wrote:

as far as i know the parameters in this case are always delivered by reference