Type.HasElementType Properti

Referensi

Definisi

Ruang nama:: System

Rakitan:: System.Runtime.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Sumber:: Type.cs

Sumber:: Type.cs

Sumber:: Type.cs

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Mendapatkan nilai yang menunjukkan apakah saat ini Type mencakup atau merujuk ke jenis lain; yaitu, apakah saat ini Type adalah array, penunjuk, atau diteruskan oleh referensi.

public:
 property bool HasElementType { bool get(); };

public bool HasElementType { get; }

member this.HasElementType : bool

Public ReadOnly Property HasElementType As Boolean

Nilai Properti

Boolean

true Type jika adalah array, pointer, atau diteruskan oleh referensi; jika tidak, false.

Penerapan

HasElementType

Contoh

Contoh berikut mengembalikan true atau false bergantung pada apakah objek tersebut adalah array, jenis referensi, atau penunjuk atau tidak.

using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::InteropServices;

public ref class Example
{
public:
    // This method is for demonstration purposes. It includes a
    // tracking reference (C# ref, VB ByRef), an out parameter,
    // and a pointer.
    void Test(int% x, [OutAttribute()] int% y, int* z)
    { 
        *z = x = y = 0; 
    }    
};

int main()
{
    // All of the following display 'True'.

    // Define a managed array, get its type, and display HasElementType. 
    array<Example^>^ examples = {gcnew Example(), gcnew Example()};
    Type^ t = examples::typeid; 
    Console::WriteLine(t);
    Console::WriteLine("HasElementType is '{0}' for managed array types.", t->HasElementType);

    // When you use Reflection Emit to emit dynamic methods and
    // assemblies, you can create array types using MakeArrayType.
    // The following creates the type 'array of Example'.
    t = Example::typeid->MakeArrayType();
    Console::WriteLine("HasElementType is '{0}' for managed array types.", t->HasElementType);

    // When you reflect over methods, HasElementType is true for
    // ref, out, and pointer parameter types. The following 
    // gets the Test method, defined above, and examines its
    // parameters.
    MethodInfo^ mi = Example::typeid->GetMethod("Test");
    array<ParameterInfo^>^ parms = mi->GetParameters();
    t = parms[0]->ParameterType;
    Console::WriteLine("HasElementType is '{0}' for ref parameter types.", t->HasElementType);
    t = parms[1]->ParameterType;
    Console::WriteLine("HasElementType is '{0}' for out parameter types.", t->HasElementType);
    t = parms[2]->ParameterType;
    Console::WriteLine("HasElementType is '{0}' for pointer parameter types.", t->HasElementType);

    // When you use Reflection Emit to emit dynamic methods and
    // assemblies, you can create pointer and ByRef types to use
    // when you define method parameters.
    t = Example::typeid->MakePointerType();
    Console::WriteLine("HasElementType is '{0}' for pointer types.", t->HasElementType);
    t = Example::typeid->MakeByRefType();
    Console::WriteLine("HasElementType is '{0}' for ByRef types.", t->HasElementType);
}

// This code must be compiled with the /unsafe switch:
//   csc /unsafe source.cs
using System;
using System.Reflection;

public class Example
{
    // This method is for demonstration purposes.
    unsafe public void Test(ref int x, out int y, int* z)
    {
        *z = x = y = 0;
    }

    public static void Main()
    {
        // All of the following display 'True'.

        // Define an array, get its type, and display HasElementType.
        int[] nums = {1, 1, 2, 3, 5, 8, 13};
        Type t = nums.GetType();
        Console.WriteLine("HasElementType is '{0}' for array types.", t.HasElementType);

        // Test an array type without defining an array.
        t = typeof(Example[]);
        Console.WriteLine("HasElementType is '{0}' for array types.", t.HasElementType);

        // When you use Reflection Emit to emit dynamic methods and
        // assemblies, you can create array types using MakeArrayType.
        // The following creates the type 'array of Example'.
        t = typeof(Example).MakeArrayType();
        Console.WriteLine("HasElementType is '{0}' for array types.", t.HasElementType);

        // When you reflect over methods, HasElementType is true for
        // ref, out, and pointer parameter types. The following
        // gets the Test method, defined above, and examines its
        // parameters.
        MethodInfo mi = typeof(Example).GetMethod("Test");
        ParameterInfo[] parms = mi.GetParameters();
        t = parms[0].ParameterType;
        Console.WriteLine("HasElementType is '{0}' for ref parameter types.", t.HasElementType);
        t = parms[1].ParameterType;
        Console.WriteLine("HasElementType is '{0}' for out parameter types.", t.HasElementType);
        t = parms[2].ParameterType;
        Console.WriteLine("HasElementType is '{0}' for pointer parameter types.", t.HasElementType);

        // When you use Reflection Emit to emit dynamic methods and
        // assemblies, you can create pointer and ByRef types to use
        // when you define method parameters.
        t = typeof(Example).MakePointerType();
        Console.WriteLine("HasElementType is '{0}' for pointer types.", t.HasElementType);
        t = typeof(Example).MakeByRefType();
        Console.WriteLine("HasElementType is '{0}' for ByRef types.", t.HasElementType);
    }
}

#nowarn "9"
open FSharp.NativeInterop

type Example() =
    // This method is for demonstration purposes.
    member _.Test(x: int byref, y: int outref, z: int nativeptr) =
        x <- 0
        y <- 0
        NativePtr.write z 0

// All of the following display 'True'.

do
    // Define an array, get its type, and display HasElementType.
    let nums = [| 1; 1; 2; 3; 5; 8; 13 |]
    let t = nums.GetType()
    printfn $"HasElementType is '{t.HasElementType}' for array types."

    // Test an array type without defining an array.
    let t = typeof<Example[]>
    printfn $"HasElementType is '{t.HasElementType}' for array types."

    // When you use Reflection Emit to emit dynamic methods and
    // assemblies, you can create array types using MakeArrayType.
    // The following creates the type 'array of Example'.
    let t = typeof<Example>.MakeArrayType()
    printfn $"HasElementType is '{t.HasElementType}' for array types."

    // When you reflect over methods, HasElementType is true for
    // byref, outref, and pointer parameter types. The following
    // gets the Test method, defined above, and examines its
    // parameters.
    let mi = typeof<Example>.GetMethod "Test"
    let parms = mi.GetParameters()
    let t = parms[0].ParameterType
    printfn $"HasElementType is '{t.HasElementType}' for ref parameter types."
    let t = parms[1].ParameterType
    printfn $"HasElementType is '{t.HasElementType}' for out parameter types."
    let t = parms[2].ParameterType
    printfn $"HasElementType is '{t.HasElementType}' for pointer parameter types."

    // When you use Reflection Emit to emit dynamic methods and
    // assemblies, you can create pointer and ByRef types to use
    // when you define method parameters.
    let t = typeof<Example>.MakePointerType()
    printfn $"HasElementType is '{t.HasElementType}' for pointer types."
    let t = typeof<Example>.MakeByRefType()
    printfn $"HasElementType is '{t.HasElementType}' for ByRef types."

Imports System.Reflection
Imports System.Runtime.InteropServices

Public Class Example

    ' This method is for demonstration purposes.
    Public Shared Sub Test(ByRef x As Integer, <Out> ByRef y As Integer)
    End Sub

    Public Shared Sub Main()
        ' All of the following display 'True'.

        ' Define an array, get its type, and display HasElementType. 
        Dim nums() As Integer = {1, 1, 2, 3, 5, 8, 13}
        Dim t As Type = nums.GetType()
        Console.WriteLine("HasElementType is '{0}' for array types.", t.HasElementType)

        ' Test an array type without defining an array.
        t = GetType(Example())
        Console.WriteLine("HasElementType is '{0}' for array types.", t.HasElementType)

        ' When you use Reflection Emit to emit dynamic methods and
        ' assemblies, you can create array types using MakeArrayType.
        ' The following creates the type 'array of Example'.
        t = GetType(Example).MakeArrayType()
        Console.WriteLine("HasElementType is '{0}' for array types.", t.HasElementType)

        ' When you reflect over methods, HasElementType is true for
        ' ref, out, and pointer parameter types. The following 
        ' gets the Test method, defined above, and examines its
        ' parameters.
        Dim mi As MethodInfo = GetType(Example).GetMethod("Test")
        Dim parms() As ParameterInfo = mi.GetParameters()
        t = parms(0).ParameterType
        Console.WriteLine("HasElementType is '{0}' for ref parameter types.", t.HasElementType)
        t = parms(1).ParameterType
        Console.WriteLine("HasElementType is '{0}' for <Out> parameter types.", t.HasElementType)

        ' When you use Reflection Emit to emit dynamic methods and
        ' assemblies, you can create pointer and ByRef types to use
        ' when you define method parameters.
        t = GetType(Example).MakePointerType()
        Console.WriteLine("HasElementType is '{0}' for pointer types.", t.HasElementType)
        t = GetType(Example).MakeByRefType()
        Console.WriteLine("HasElementType is '{0}' for ByRef types.", t.HasElementType)
    End Sub 

End Class

Keterangan

Misalnya, Type.GetType("Int32[]"). HasElementType mengembalikan true, tetapi Type.GetType("Int32"). HasElementType mengembalikan false. HasElementType juga mengembalikan true untuk "Int32*" dan "Int32&".

Jika saat ini Type mewakili jenis generik, atau parameter jenis dalam definisi jenis generik atau metode generik, properti ini selalu mengembalikan false.

Berlaku untuk

Bagikan melalui