Type.Missing Campo

public: static initonly System::Object ^ Missing;

public static readonly object Missing;

 staticval mutable Missing : obj

Public Shared ReadOnly Missing As Object 

Valor do campo

Object

Exemplos

O exemplo de código a seguir mostra o uso do Missing campo para invocar um método com seus argumentos padrão.

#using <System.dll>

using namespace System;
using namespace System::Reflection;
using namespace System::CodeDom::Compiler;

ref class Example
{
public:
    static void Main()
    {
        // VB source for example. Not all versions of CS and CPP compilers
        // support optional arguments.
        String^ codeLines =
            "Imports System\n\n" +
            "Public Class OptionalArg\n" +
            "  Public Sub MyMethod(ByVal a As Integer, _\n" +
            "    Optional ByVal b As Double = 1.2, _\n" +
            "    Optional ByVal c As Integer = 1)\n\n" +
            "    Console.WriteLine(\"a = \" & a & \" b = \" & b & \" c = \" & c)\n" +
            "  End Sub\n" +
            "End Class\n";

        // Generate a OptionalArg instance from the source above.
        Object^ o = GenerateObjectFromSource("OptionalArg", codeLines, "VisualBasic");
        Type^ t;

        t = o->GetType();
        BindingFlags bf = BindingFlags::Public | BindingFlags::Instance |
            BindingFlags::InvokeMethod | BindingFlags::OptionalParamBinding;

        t->InvokeMember("MyMethod", bf, nullptr, o, gcnew array<Object^> {10, 55.3, 12});
        t->InvokeMember("MyMethod", bf, nullptr, o, gcnew array<Object^> {10, 1.3, Type::Missing});
        t->InvokeMember("MyMethod", bf, nullptr, o, gcnew array<Object^> {10, Type::Missing, Type::Missing});
    }

private:
    static Object^ GenerateObjectFromSource(String^ objectName,
        String^ sourceLines, String^ providerName)
    {
        Object^ genObject = nullptr;
        CodeDomProvider^ codeProvider = CodeDomProvider::CreateProvider(providerName);
        CompilerParameters^ cp = gcnew CompilerParameters();

        cp->GenerateExecutable = false;
        cp->GenerateInMemory = true;

        CompilerResults^ results =
            codeProvider->CompileAssemblyFromSource(cp, sourceLines);
        if (results->Errors->Count == 0)
        {
            genObject = results->CompiledAssembly->CreateInstance(objectName);
        }

        return genObject;
    }
};

int main()
{
    Example::Main();
}

using System;
using System.Reflection;
using System.CodeDom.Compiler;

class Example
{
    public static void Main()
    {
        // VB source for example. Not all versions of CS and CPP compilers
        // support optional arguments.
        string codeLines =
            "Imports System\n\n" +
            "Public Class OptionalArg\n" +
            "  Public Sub MyMethod(ByVal a As Integer, _\n" +
            "    Optional ByVal b As Double = 1.2, _\n" +
            "    Optional ByVal c As Integer = 1)\n\n" +
            "    Console.WriteLine(\"a = \" & a & \" b = \" & b & \" c = \" & c)\n" +
            "  End Sub\n" +
            "End Class\n";

        // Generate a OptionalArg instance from the source above.
        object o = GenerateObjectFromSource("OptionalArg", codeLines, "VisualBasic");
        Type t;

        t = o.GetType();
        BindingFlags bf = BindingFlags.Public | BindingFlags.Instance |
            BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding;

        t.InvokeMember("MyMethod", bf, null, o, new object[] {10, 55.3, 12});
        t.InvokeMember("MyMethod", bf, null, o, new object[] {10, 1.3, Type.Missing});
        t.InvokeMember("MyMethod", bf, null, o, new object[] {10, Type.Missing, Type.Missing});
    }

    private static object GenerateObjectFromSource(string objectName,
        string sourceLines, string providerName)
    {
        object genObject = null;
        CodeDomProvider codeProvider = CodeDomProvider.CreateProvider(providerName);
        CompilerParameters cp = new CompilerParameters();

        cp.GenerateExecutable = false;
        cp.GenerateInMemory = true;

        CompilerResults results =
            codeProvider.CompileAssemblyFromSource(cp, sourceLines);
        if (results.Errors.Count == 0)
        {
            genObject = results.CompiledAssembly.CreateInstance(objectName);
        }

        return genObject;
    }
}

Imports System.Reflection

Public Class OptionalArg
    Public Sub MyMethod(ByVal a As Integer, _
        Optional ByVal b As Double = 1.2, _
        Optional ByVal c As Integer = 1)
        
        Console.WriteLine("a = " & a & " b = " & b & " c = " & c)
    End Sub
End Class

Class Example
    Public Shared Sub Main()
        Dim o As New OptionalArg()
        Dim t As Type
        t = GetType(OptionalArg)

        Dim bf As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Instance Or _
            BindingFlags.InvokeMethod Or BindingFlags.OptionalParamBinding

        t.InvokeMember("MyMethod", bf, Nothing, o, New Object() {10, 55.3, 12})
        t.InvokeMember("MyMethod", bf, Nothing, o, New Object() {10, 1.3, Type.Missing})
        t.InvokeMember("MyMethod", bf, Nothing, o, New Object() {10, Type.Missing, Type.Missing})
    End Sub
End Class

Este código produz a seguinte saída:

a = 10 b = 55,3 c = 12

a = 10 b = 1,3 c = 1

a = 10 b = 1,2 c = 1

Comentários

Use o Missing campo para invocação por meio de reflexão para obter o valor padrão de um parâmetro. Se o Missing campo for passado para um valor de parâmetro e não houver nenhum valor padrão para esse parâmetro, um ArgumentException será gerado.

Aplica-se a

Confira também

• Missing