Type.Missing Campo

Definizione

Spazio dei nomi:

System

Assembly:

netstandard.dll, System.Runtime.dll

Origine:

Type.cs

Rappresenta un valore mancante nelle Type informazioni. Questo campo è di sola lettura.

public: static initonly System::Object ^ Missing;

public static readonly object Missing;

 staticval mutable Missing : obj

Public Shared ReadOnly Missing As Object 

Valore del campo

Object

Esempio

Nell'esempio di codice seguente viene illustrato l'uso del Missing campo per richiamare un metodo con gli argomenti predefiniti.

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

open System
open System.Reflection
open System.CodeDom.Compiler

let generateObjectFromSource objectName (sourceLines: string) providerName =
    let codeProvider = CodeDomProvider.CreateProvider providerName
    let cp = CompilerParameters()

    cp.GenerateExecutable <- false
    cp.GenerateInMemory <- true

    let results = codeProvider.CompileAssemblyFromSource(cp, sourceLines)
    if results.Errors.Count = 0 then
        results.CompiledAssembly.CreateInstance objectName
    else 
        null


// VB source for example. Not all versions of CS and CPP compilers
// support optional arguments.
let codeLines =
    """Imports System
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"""

// Generate a OptionalArg instance from the source above.
let o = generateObjectFromSource "OptionalArg" codeLines "VisualBasic"

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

t.InvokeMember("MyMethod", bf, null, o, [| 10; 55.3; 12 |]) |> ignore
t.InvokeMember("MyMethod", bf, null, o, [| 10; 1.3; Type.Missing |]) |> ignore
t.InvokeMember("MyMethod", bf, null, o, [| 10; Type.Missing; Type.Missing |]) |> ignore

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

Questo codice genera l'output seguente:

a = 10 b = 55,3 c = 12

a = 10 b = 1,3 c = 1

a = 10 b = 1,2 c = 1

Commenti

Usare il campo per la Missing chiamata tramite reflection per ottenere il valore predefinito di un parametro. Se il Missing campo viene passato per un valore di parametro e non esiste alcun valore predefinito per tale parametro, viene generata un'eccezione ArgumentException .

Vedi anche

• Missing