Type.IsPrimitive-Eigenschaft

Ruft einen Wert ab, der angibt, ob Type zu den primitiven Typen gehört.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public ReadOnly Property IsPrimitive As Boolean
'Usage
Dim instance As Type
Dim value As Boolean

value = instance.IsPrimitive

public bool IsPrimitive { get; }

public:
virtual property bool IsPrimitive {
    bool get () sealed;
}

/** @property */
public final boolean get_IsPrimitive ()

public final function get IsPrimitive () : boolean

Eigenschaftenwert

true, wenn Type zu den primitiven Typen gehört, andernfalls false.

Hinweise

Die primitiven Typen sind Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Char, Double und Single.

Wenn der aktuelle Type einen generischen Typ oder einen Typparameter einer generischen Typ- oder Methodendefinition darstellt, gibt diese Eigenschaft immer false zurück.

Beispiel

Im folgenden Beispiel wird die IsContextful-Eigenschaft, die IsMarshalByRef-Eigenschaft und die IsPrimitive-Eigenschaft der Type-Klasse veranschaulicht. Es wird überprüft, ob der angegebene Typ in den Kontext aufgenommen werden kann, ob er als Verweis gemarshallt werden kann und ob der Typ ein primitiver Datentyp ist.

Imports System
Imports System.Runtime.Remoting.Contexts
Imports Microsoft.VisualBasic
Public Class MyContextBoundClass
    Inherits ContextBoundObject
    Public myString As String = "This class demonstrates the IsContextful, IsMarshalByRef, and IsPrimitive properties."
End Class 'MyContextBoundClass
Public Class MyTypeDemoClass
    Public Shared Sub Main()
        Try
            ' Determine whether the types can be hosted in a Context.
            Console.WriteLine("The Contextful property for the {0} type is {1}.", GetType(MyTypeDemoClass).Name, GetType(MyTypeDemoClass).IsContextful.ToString())
            Console.WriteLine("The Contextful property for the {0} type is {1}.", GetType(MyContextBoundClass).Name, GetType(MyContextBoundClass).IsContextful.ToString())
            ' Determine whether the types are marshalled by reference.
            Console.WriteLine("The MarshalByRef property of {0} is {1}.", GetType(MyTypeDemoClass).Name, GetType(MyTypeDemoClass).IsMarshalByRef.ToString())
            Console.WriteLine("The MarshalByRef property of {0} is {1}.", GetType(MyContextBoundClass).Name, GetType(MyContextBoundClass).IsMarshalByRef.ToString())
            ' Determine whether the types are primitive datatypes.
            Console.WriteLine("Is {0} a primitive data type? {1}.", GetType(Integer).Name, GetType(Integer).IsPrimitive.ToString())
            Console.WriteLine("Is {0} a primitive data type? {1}.", GetType(String).Name, GetType(String).IsPrimitive.ToString())
        Catch e As Exception
            Console.WriteLine("An exception occurred: " + e.Message.ToString())
        End Try
    End Sub 'Main
End Class 'MyTypeDemoClass

using System;
using System.Runtime.Remoting.Contexts;
public class MyContextBoundClass: ContextBoundObject
{
    public string myString = "This class demonstrates the IsContextful, IsMarshalByRef, and IsPrimitive properties.";
}
public class MyTypeDemoClass
{
    public static void Main()
    {
        try
        {
            // Determine whether the types can be hosted in a Context.
            Console.WriteLine ("The IsContextful property for the {0} type is {1}.", typeof(MyTypeDemoClass).Name, typeof(MyTypeDemoClass).IsContextful);
            Console.WriteLine ("The IsContextful property for the {0} type is {1}.", typeof(MyContextBoundClass).Name, typeof(MyContextBoundClass).IsContextful);

            // Determine whether the types are marshalled by reference.
            Console.WriteLine ("The MarshalByRef property of {0} is {1}.", typeof(MyTypeDemoClass).Name, typeof(MyTypeDemoClass).IsMarshalByRef);
            Console.WriteLine ("The MarshalByRef property of {0} is {1}.", typeof(MyContextBoundClass).Name, typeof(MyContextBoundClass).IsMarshalByRef);
            
            // Determine whether the types are primitive datatypes.
            Console.WriteLine ("Is {0} is a primitive data type? {1}.", typeof(int).Name, typeof(int).IsPrimitive);
            Console.WriteLine ("Is {0} a primitive data type? {1}.", typeof(string).Name, typeof(string).IsPrimitive);
        } 
        catch (Exception e)
        {
            Console.WriteLine("An exception occurred: " + e.Message);
        }
    }
}

using namespace System;
using namespace System::Runtime::Remoting::Contexts;
public ref class MyContextBoundClass: public ContextBoundObject
{
public:
   String^ myString;
};

public ref class MyTypeDemoClass
{
public:
   void Demo()
   {
      try
      {
         // Determine whether the types can be hosted in a Context.
         Console::WriteLine( "The IsContextful property for the {0} type is {1}.", MyTypeDemoClass::typeid->Name, MyTypeDemoClass::typeid->IsContextful );
         Console::WriteLine( "The IsContextful property for the {0} type is {1}.", MyContextBoundClass::typeid->Name, MyContextBoundClass::typeid->IsContextful );
         
         // Determine whether the types are marshalled by reference.
         Console::WriteLine( "The MarshalByRef property of {0} is {1}.", MyTypeDemoClass::typeid->Name, MyTypeDemoClass::typeid->IsMarshalByRef );
         Console::WriteLine( "The MarshalByRef property of {0} is {1}.", MyContextBoundClass::typeid->Name, MyContextBoundClass::typeid->IsMarshalByRef );
         
         // Determine whether the types are primitive datatypes.
         Console::WriteLine( "Is {0} is a primitive data type? {1}.", int::typeid->Name, int::typeid->IsPrimitive );
         Console::WriteLine( "Is {0} a primitive data type? {1}.", String::typeid->Name, String::typeid->IsPrimitive );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( "An exception occurred: {0}", e->Message );
      }
   }
};

int main()
{
   MyTypeDemoClass^ mtdc = gcnew MyTypeDemoClass;
   mtdc->Demo();
}

import System.*;
import System.Runtime.Remoting.Contexts.*;

public class MyContextBoundClass extends ContextBoundObject
{
    public String myString = "This class demonstrates the IsContextful, "
        +"IsMarshalByRef, and IsPrimitive properties.";
} //MyContextBoundClass

public class MyTypeDemoClass
{
    public static void main(String[] args)
    {
        try {
            // Determine whether the types can be hosted in a Context.
            Console.WriteLine("The IsContextful property for the"
                +" {0} type is {1}.", MyTypeDemoClass.class.ToType().get_Name(),
                System.Convert.ToString(MyTypeDemoClass.class.ToType().
                get_IsContextful()));
            Console.WriteLine("The IsContextful property for the"
                +" {0} type is {1}.", MyContextBoundClass.class.ToType().
                get_Name(), System.Convert.ToString(MyContextBoundClass.class.
                ToType().get_IsContextful()));

            // Determine whether the types are marshalled by reference.
            Console.WriteLine("The MarshalByRef property of {0} is {1}.",
                MyTypeDemoClass.class.ToType().get_Name(),
                System.Convert.ToString(MyTypeDemoClass.class.ToType().
                get_IsMarshalByRef()));
            Console.WriteLine("The MarshalByRef property of {0} is {1}.",
                MyContextBoundClass.class.ToType().get_Name(),
                System.Convert.ToString(MyContextBoundClass.class.ToType().
                get_IsMarshalByRef()));

            // Determine whether the types are primitive datatypes.
            Console.WriteLine("Is {0} is a primitive data type? {1}.",
                int.class.ToType().get_Name(),
                System.Convert.ToString(int.class.ToType().get_IsPrimitive()));
            Console.WriteLine("Is {0} a primitive data type? {1}.",
                String.class.ToType().get_Name(),System.Convert.ToString(
                String.class.ToType().get_IsPrimitive()));
        }
        catch (System.Exception e) {
            Console.WriteLine("An exception occurred: " + e.get_Message());
        }
    } //main
} //MyTypeDemoClass

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

Type-Klasse
Type-Member
System-Namespace
Boolean-Struktur
Byte-Struktur
SByte-Struktur
Int16-Struktur
UInt16
Int32-Struktur
UInt32
Int64-Struktur
UInt64
Char-Struktur
Double-Struktur
Single-Struktur
IsPrimitiveImpl