Type.IsPointer Property

Reference

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Gets a value indicating whether the Type is a pointer.

public:
 virtual property bool IsPointer { bool get(); };

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

public virtual bool IsPointer { get; }

public bool IsPointer { get; }

member this.IsPointer : bool

Public Overridable ReadOnly Property IsPointer As Boolean

Public ReadOnly Property IsPointer As Boolean

Property Value

Boolean

true if the Type is a pointer; otherwise, false.

Implements

IsPointer

Examples

The following example shows a use of the IsPointer property.

using namespace System;
using namespace System::Reflection;
public ref class MyTypeDelegator: public TypeDelegator
{
public:
   String^ myElementType;

private:
   Type^ myType;

public:
   MyTypeDelegator( Type^ myType )
      : TypeDelegator( myType )
   {
      this->myType = myType;
   }


protected:

   // Override Type::HasElementTypeImpl().
   virtual bool HasElementTypeImpl() override
   {
      
      // Determine whether the type is an array.
      if ( myType->IsArray )
      {
         myElementType = "array";
         return true;
      }

      
      // Determine whether the type is a reference.
      if ( myType->IsByRef )
      {
         myElementType = "reference";
         return true;
      }

      
      // Determine whether the type is a pointer.
      if ( myType->IsPointer )
      {
         myElementType = "pointer";
         return true;
      }

      
      // Return false if the type is not a reference, array, or pointer type.
      return false;
   }

};

int main()
{
   try
   {
      int myInt = 0;
      array<Int32>^myArray = gcnew array<Int32>(5);
      MyTypeDelegator^ myType = gcnew MyTypeDelegator( myArray->GetType() );
      
      // Determine whether myType is an array, pointer, reference type.
      Console::WriteLine( "\nDetermine whether a variable is an array, pointer, or reference type.\n" );
      if ( myType->HasElementType )
            Console::WriteLine( "The type of myArray is {0}.", myType->myElementType );
      else
            Console::WriteLine( "myArray is not an array, pointer, or reference type." );
      myType = gcnew MyTypeDelegator( myInt.GetType() );
      
      // Determine whether myType is an array, pointer, reference type.
      if ( myType->HasElementType )
            Console::WriteLine( "The type of myInt is {0}.", myType->myElementType );
      else
            Console::WriteLine( "myInt is not an array, pointer, or reference type." );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}", e->Message );
   }

}

using System;
using System.Reflection;
public class MyTypeDelegator : TypeDelegator
{
    public string myElementType = null;
    private Type myType = null ;
    public MyTypeDelegator(Type myType) : base(myType)
    {
        this.myType = myType;
    }
    // Override Type.HasElementTypeImpl().
    protected override bool HasElementTypeImpl()
    {
        // Determine whether the type is an array.
        if(myType.IsArray)
        {
            myElementType = "array";
            return true;
        }
        // Determine whether the type is a reference.
        if(myType.IsByRef)
        {
            myElementType = "reference";
            return true;
        }
        // Determine whether the type is a pointer.
        if(myType.IsPointer)
        {
            myElementType = "pointer";
            return true;
        }
        // Return false if the type is not a reference, array, or pointer type.
        return false;
    }
}
public class Type_HasElementTypeImpl
{
    public static void Main()
    {
        try
        {
            int myInt = 0 ;
            int[] myArray = new int[5];
            MyTypeDelegator myType = new MyTypeDelegator(myArray.GetType());
            // Determine whether myType is an array, pointer, reference type.
            Console.WriteLine("\nDetermine whether a variable is an array, pointer, or reference type.\n");
            if( myType.HasElementType)
                Console.WriteLine("The type of myArray is {0}.", myType.myElementType);
            else
                Console.WriteLine("myArray is not an array, pointer, or reference type.");
            myType = new MyTypeDelegator(myInt.GetType());
            // Determine whether myType is an array, pointer, reference type.
            if( myType.HasElementType)
                Console.WriteLine("The type of myInt is {0}.", myType.myElementType);
            else
                Console.WriteLine("myInt is not an array, pointer, or reference type.");
        }
        catch( Exception e )
        {
            Console.WriteLine("Exception: {0}", e.Message);
        }
    }
}

open System.Reflection

type MyTypeDelegator(myType) =
    inherit TypeDelegator(myType)
    
    [<DefaultValue>]
    val mutable public myElementType: string
    
    // Override Type.HasElementTypeImpl().
    override this.HasElementTypeImpl() =
        // Determine whether the type is an array.
        if myType.IsArray then
            this.myElementType <- "array"
            true
        // Determine whether the type is a reference.
        elif myType.IsByRef then
            this.myElementType <- "reference"
            true
        // Determine whether the type is a pointer.
        elif myType.IsPointer then
            this.myElementType <- "pointer"
            true
        // Return false if the type is not a reference, array, or pointer type.
        else false

try
    let myInt = 0 
    let myArray = Array.zeroCreate<int> 5
    let myType = MyTypeDelegator(myArray.GetType())
    // Determine whether myType is an array, pointer, reference type.
    printfn "\nDetermine whether a variable is an array, pointer, or reference type.\n"
    if myType.HasElementType then
        printfn $"The type of myArray is {myType.myElementType}."
    else
        printfn "myArray is not an array, pointer, or reference type."
    let myType = MyTypeDelegator(myInt.GetType())
    // Determine whether myType is an array, pointer, reference type.
    if myType.HasElementType then
        printfn $"The type of myInt is {myType.myElementType}."
    else
        printfn "myInt is not an array, pointer, or reference type."
with e ->
    printfn $"Exception: {e.Message}"

Imports System.Reflection

Public Class MyTypeDelegator
    Inherits TypeDelegator
    Public myElementType As String = Nothing
    Private myType As Type = Nothing
    Public Sub New(ByVal myType As Type)
        MyBase.New(myType)
        Me.myType = myType
    End Sub
    ' Override Type.HasElementTypeImpl().
    Protected Overrides Function HasElementTypeImpl() As Boolean
        ' Determine whether the type is an array.
        If myType.IsArray Then
            myElementType = "array"
            Return True
        End If
        ' Determine whether the type is a reference.
        If myType.IsByRef Then
            myElementType = "reference"
            Return True
        End If
        ' Determine whether the type is a pointer.
        If myType.IsPointer Then
            myElementType = "pointer"
            Return True
        End If
        ' The type is not a reference, array, or pointer type.
        Return False
    End Function 'HasElementTypeImpl
End Class
Public Class Type_HasElementTypeImpl
    Public Shared Sub Main()
        Try
            Dim myInt As Integer = 0
            Dim myArray(4) As Integer
            Dim myType As New MyTypeDelegator(myArray.GetType())
            Console.WriteLine(ControlChars.NewLine + "Determine whether a variable refers to an array or pointer or reference type." + ControlChars.NewLine)
            ' Determine whether myType is an array, pointer, reference type.  
            If myType.HasElementType Then
                Console.WriteLine("The type of myArray is {0}.", myType.myElementType.ToString())
            Else
                Console.WriteLine("myArray is not an array, pointer, or reference type.")
            End If
            myType = New MyTypeDelegator(myInt.GetType())
            ' Determine whether myType is an array, pointer, reference type. 
            If myType.HasElementType Then
                Console.WriteLine("The type of myInt is {0}.", myType.myElementType.ToString())
            Else
                Console.WriteLine("myInt is not an array, pointer, or reference type.")
            End If
        Catch e As Exception
            Console.WriteLine("Exception: {0}", e.Message.ToString())
        End Try
    End Sub
End Class

Remarks

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.

This property is read-only.

Applies to

Deila með