Acessando os valores de argumento padrão
Algumas linguagens (como, por exemplo, Visual C++ e Microsoft Visual Basic 2005) oferecem suporte a atribuição de valores padrão para argumentos. Por exemplo, a seguir está uma verdadeira Visual Basic 2005 declaração que tem valores padrão para os dois argumentos.
Public Sub MyMethod (a as Integer, _
Optional b as Double = 1.2, _
Optional c as Integer = 1)
Você pode usar um atributo de parâmetro para atribuir um valor de parâmetro padrão.
Em Visual Basic e C++, os parâmetros opcionais podem ser omitidos quando o método for chamado. No C# valores devem ser especificados para argumentos opcionais.
Por exemplo, os seguintes exemplos de Visual Basic e C++ são chamadas válidas para MyMethod.
MyMethod(10, 55.3, 12)
MyMethod(10, 1.3) ' c == 1
MyMethod(11) ' b == 1.2, c == 1
MyMethod(10, 55.3, 12);
MyMethod(10, 1.3); // c == 1
MyMethod(11); // b == 1.2, c == 1
Para recuperar o valor padrão de um argumento usando reflexão, obter um ParameterInfo para o parâmetro de objeto e, em seguida, recuperar o valor padrão usando o ParameterInfo.DefaultValue propriedade. Se não houver nenhum valor padrão, a propriedade retornará Value.DBNull.
O exemplo a seguir exibe os valores padrão para MyMethod para o console.
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
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);
}
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);
}
Para chamar os métodos que possuem argumentos com valores padrão, use Type.Missing como um valor de parâmetro para o InvokeMember método. Isso permite que o serviço de ligação atrasada para usar o valor padrão para o valor do parâmetro indicado. Se Type.Missing é passado para um parâmetro que não tem valor padrão, um ArgumentException é lançada. É importante observar que não compiladores de todos os mecanismos de ligação pode respeitar estas regras para Type.Missing. Alguns fichários podem não oferecer suporte a essa funcionalidade, ou pode tratar Type.Missing diferente. Ao usar Type.Missing, os valores padrão não precisam estar à direita.
O idioma C# não oferece suporte a argumentos padrão.
O seguinte Visual Basic 2005 exemplo mostra como usar a reflexão para invocar os métodos que possuem argumentos do padrão.
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
Ao usar a técnica anterior, os argumentos finais do padrão são considerados mesmo quando o chamador não especificar nenhum valor. Esta é a maneira mais comum para chamar métodos com argumentos padrão.
Se você estiver usando MethodBase.Invoke para invocar o método, você precisa especificar explicitamente quais argumentos são padrões passando uma matriz de objeto que contém Type.Missing para todos os parâmetros que não têm valores.