Type.HasElementType Propiedad
Definición
Obtiene un valor que indica si el objeto Type actual engloba o hace referencia a otro tipo; es decir, si el objeto Type actual es una matriz o un puntero, o si se pasa por referencia.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
Valor de propiedad
Es true
si Type es una matriz o un puntero, o si se pasa por referencia; en caso contrario, es false
.true
if the Type is an array, a pointer, or is passed by reference; otherwise, false
.
Implementaciones
Ejemplos
En el ejemplo siguiente true
se devuelve o false
en función de si el objeto es o no una matriz, un tipo de referencia o un puntero.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.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
Comentarios
Por ejemplo, escriba. GetType ("Int32 []"). HasElementType devuelve true
, pero Type. GetType ("Int32"). HasElementType devuelve false
.For example, Type.GetType("Int32[]").HasElementType returns true
, but Type.GetType("Int32").HasElementType returns false
. HasElementType también devuelve true
para "Int32 *" y "int32&".HasElementType also returns true
for "Int32*" and "Int32&".
Si el actual Type representa un tipo genérico o un parámetro de tipo en la definición de un tipo genérico o de un método genérico, esta propiedad siempre devuelve false
.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
.