Type.HasElementType Type.HasElementType Type.HasElementType Type.HasElementType Property

Definition

Ruft einen Wert ab, der angibt, ob der aktuelle Type einen anderen Typ umfasst oder auf einen anderen Typ verweist, d. h. ob der aktuelle Type ein Array oder ein Zeiger ist oder als Verweis übergeben wird.Gets a value indicating whether the current Type encompasses or refers to another type; that is, whether the current Type is an array, a pointer, or is passed by reference.

public:
 property bool HasElementType { bool get(); };
public bool HasElementType { get; }
member this.HasElementType : bool
Public ReadOnly Property HasElementType As Boolean

Eigenschaftswert

true, wenn Type ein Array oder ein Zeiger ist oder als Verweis übergeben wird, andernfalls false.true if the Type is an array, a pointer, or is passed by reference; otherwise, false.

Implementiert

Beispiele

Das folgende Beispiel gibt true oder false zurück, je nachdem, ob es sich bei dem Objekt um ein Array, einen Verweistyp oder einen Zeiger handelt.The following example returns true or false depending on whether or not the object is an array, a reference type, or a pointer.

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);
    }
}
Imports System
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

Hinweise

Beispielsweise Type.GetType("Int32[]"). HasElementType gibt true, wohingegen Type.GetType("Int32"). HasElementType gibt false.For example, Type.GetType("Int32[]").HasElementType returns true, but Type.GetType("Int32").HasElementType returns false. HasElementType gibt auch true für "Int32 *" und "Int32 &" zurück.HasElementType also returns true for "Int32*" and "Int32&".

Wenn der aktuelle Type einen generischen Typ oder einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, gibt diese falseEigenschaft immer zurück.If the current Type represents a generic type, or a type parameter in the definition of a generic type or generic method, this property always returns false.

Gilt für:

Siehe auch