Type.IsPrimitiveImpl Method

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.

When overridden in a derived class, implements the IsPrimitive property and determines whether the Type is one of the primitive types.

protected:
 abstract bool IsPrimitiveImpl();

protected abstract bool IsPrimitiveImpl ();

abstract member IsPrimitiveImpl : unit -> bool

Protected MustOverride Function IsPrimitiveImpl () As Boolean

Returns

Boolean

true if the Type is one of the primitive types; otherwise, false.

Examples

The following example determines whether the given type is a primitive type and displays the result.

using namespace System;
using namespace System::Reflection;

public ref class MyTypeDelegatorClass: public TypeDelegator
{
public:
   String^ myElementType;

private:
   Type^ myType;

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

protected:

   // Override the IsPrimitiveImpl.
   virtual bool IsPrimitiveImpl() override
   {
      
      // Determine whether the type is a primitive type.
      if ( myType->IsPrimitive )
      {
         myElementType = "primitive";
         return true;
      }

      return false;
   }
};

int main()
{
   try
   {
      Console::WriteLine( "Determine whether int is a primitive type." );
      MyTypeDelegatorClass^ myType;
      myType = gcnew MyTypeDelegatorClass( int::typeid );
      
      // Determine whether int is a primitive type.
      if ( myType->IsPrimitive )
      {
         Console::WriteLine( "{0} is a primitive type.", int::typeid );
      }
      else
      {
         Console::WriteLine( "{0} is not a primitive type.", int::typeid );
      }
      Console::WriteLine( "\nDetermine whether String is a primitive type." );
      myType = gcnew MyTypeDelegatorClass( String::typeid );
      
      // Determine if String is a primitive type.
      if ( myType->IsPrimitive )
      {
         Console::WriteLine( "{0} is a primitive type.", String::typeid );
      }
      else
      {
         Console::WriteLine( "{0} is not a primitive type.", String::typeid );
      }
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}", e->Message );
   }
}

using System;
using System.Reflection;
public class MyTypeDelegatorClass : TypeDelegator
{
    public string myElementType = null;
    private Type myType = null ;
    public MyTypeDelegatorClass(Type myType) : base(myType)
    {
        this.myType = myType;
    }
    // Override the IsPrimitiveImpl.
    protected override bool IsPrimitiveImpl()
    {
        // Determine whether the type is a primitive type.
        if(myType.IsPrimitive)
        {
            myElementType = "primitive";
            return true;
        }
        return false;
    }
}
public class MyTypeDemoClass
{
    public static void Main()
    {
        try
        {
            Console.WriteLine ("Determine whether int is a primitive type.");
            MyTypeDelegatorClass myType;
            myType = new MyTypeDelegatorClass(typeof(int));
            // Determine whether int is a primitive type.
            if( myType.IsPrimitive)
            {
                Console.WriteLine(typeof(int) + " is a primitive type.");
            }
            else
            {
                Console.WriteLine(typeof(int) + " is not a primitive type.");
            }
            Console.WriteLine ("\nDetermine whether string is a primitive type.");
            myType = new MyTypeDelegatorClass(typeof(string));
            // Determine if string is a primitive type.
            if( myType.IsPrimitive)
            {
                Console.WriteLine(typeof(string) + " is a primitive type.");
            }
            else
            {
                Console.WriteLine(typeof(string) + " is not a primitive type.");
            }
        }
        catch( Exception e )
        {
            Console.WriteLine("Exception: {0}", e.Message);
        }
    }
}

open System.Reflection

type MyTypeDelegatorClass(myType) =
    inherit TypeDelegator(myType)
    [<DefaultValue>]
    val mutable public myElementType : string
    // Override the IsPrimitiveImpl.
    override this.IsPrimitiveImpl() =
        // Determine whether the type is a primitive type.
        if myType.IsPrimitive then
            this.myElementType <- "primitive"
            true
        else
            false

try
    printfn "Determine whether int is a primitive type."
    let myType = MyTypeDelegatorClass typeof<int>
    // Determine whether int is a primitive type.
    if myType.IsPrimitive then
        printfn $"{typeof<int>} is a primitive type."
    else
        printfn $"{typeof<int>} is not a primitive type."
    printfn "\nDetermine whether string is a primitive type."
    let myType = MyTypeDelegatorClass typeof<string>
    // Determine if string is a primitive type.
    if myType.IsPrimitive then
        printfn $"{typeof<string>} is a primitive type."
    else
        printfn $"{typeof<string>} is not a primitive type."
with e ->
    printfn $"Exception: {e.Message}"

Imports System.Reflection

Public Class MyTypeDelegatorClass
    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 the IsPrimitiveImpl method.
    Protected Overrides Function IsPrimitiveImpl() As Boolean
        ' Determine whether the type is a primitive type.
        If myType.IsPrimitive Then
            myElementType = "primitive"
            Return True
        End If
        Return False
    End Function 'IsPrimitiveImpl
End Class
Public Class MyTypeDemoClass
    Public Shared Sub Main()
        Try
            Console.WriteLine("Determine whether int is a primitive type.")
            Dim myType As MyTypeDelegatorClass
            myType = New MyTypeDelegatorClass(GetType(Integer))
            ' Determine whether int is a primitive type.
            If myType.IsPrimitive Then
                Console.WriteLine(GetType(Integer).ToString() + " is a primitive type.")
            Else
                Console.WriteLine(GetType(Integer).ToString() + " is not a primitive type.")
            End If
            Console.WriteLine(ControlChars.NewLine + "Determine whether string is a primitive type.")
            myType = New MyTypeDelegatorClass(GetType(String))
            ' Determine whether string is a primitive type.
            If myType.IsPrimitive Then
                Console.WriteLine(GetType(String).ToString() + " is a primitive type.")
            Else
                Console.WriteLine(GetType(String).ToString() + " is not a primitive type.")
            End If
        Catch e As Exception
            Console.WriteLine("Exception: {0}", e.Message.ToString())
        End Try
    End Sub
End Class

Remarks

The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Char, Double, and Single.

Applies to

Jagamisviis: