Type.Equals Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Bestimmt, ob der zugrunde liegende Systemtyp des aktuellen Type mit dem zugrunde liegende Systemtyp des angegebenen Object oder Type übereinstimmt.

Überlädt

Equals(Type)	Bestimmt, ob der zugrunde liegende Systemtyp des aktuellen Type mit dem zugrunde liegenden Systemtyp des angegebenen Type übereinstimmt.
Equals(Object)	Bestimmt, ob der zugrunde liegende Systemtyp des aktuellen Type-Objekts mit dem zugrunde liegenden Systemtyp des angegebenen Object-Objekts übereinstimmt

Equals(Type)

Source:

Type.cs

Bestimmt, ob der zugrunde liegende Systemtyp des aktuellen Type mit dem zugrunde liegenden Systemtyp des angegebenen Type übereinstimmt.

public:
 virtual bool Equals(Type ^ o);

public virtual bool Equals (Type? o);

override this.Equals : Type -> bool

Public Overridable Function Equals (o As Type) As Boolean

Parameter

o

Type

Das Objekt, dessen zugrunde liegender Systemtyp mit dem zugrunde liegenden Systemtyp des aktuellen Type verglichen werden soll.

Gibt zurück

Boolean

true, wenn der zugrunde liegende Systemtyp von o mit dem zugrunde liegenden Systemtyp des aktuellen Type übereinstimmt, andernfalls false.

Beispiele

Im folgenden Beispiel werden Equals zwei Typen verglichen.

using System;
using System.Reflection;

class Example
{
    public static void Main()
    {

        Type a = typeof(System.String);
        Type b = typeof(System.Int32);

        Console.WriteLine("{0} == {1}: {2}", a, b, a.Equals(b));

        // The Type objects in a and b are not equal,
        // because they represent different types.

        a = typeof(Example);
        b = new Example().GetType();

        Console.WriteLine("{0} is equal to {1}: {2}", a, b, a.Equals(b));

        // The Type objects in a and b are equal,
        // because they both represent type Example.

        b = typeof(Type);

        Console.WriteLine("typeof({0}).Equals(typeof({1})): {2}", a, b, a.Equals(b));

        // The Type objects in a and b are not equal,
        // because variable a represents type Example
        // and variable b represents type Type.

        //Console.ReadLine();
    }
}

//
/* This code example produces the following output:
    System.String == System.Int32: False
    Example is equal to Example: True
    typeof(Example).Equals(typeof(System.Type)): False
*/

open System

type Example() = class end

do
    let a = typeof<string>
    let b = typeof<int>

    printfn $"{a} == {b}: {a.Equals b}"

    // The Type objects in a and b are not equal,
    // because they represent different types.

    let a = typeof<Example>
    let b = Example().GetType()

    printfn $"{a} is equal to {b}: {a.Equals b}"

    // The Type objects in a and b are equal,
    // because they both represent type Example.

    let b = typeof<Type>

    printfn $"typeof({a}).Equals(typeof({b})): {a.Equals b}"

// The Type objects in a and b are not equal,
// because variable a represents type Example
// and variable b represents type Type.

(* This code example produces the following output:
    System.String == System.Int32: False
    Example is equal to Example: True
    typeof(Example).Equals(typeof(System.Type)): False
*)

Imports System.Reflection



Class Example
    
    Public Shared Sub Main() 
        
        Dim a As Type = GetType(System.String)
        Dim b As Type = GetType(System.Int32)
        
        Console.WriteLine("{0} = {1}: {2}", a, b, a.Equals(b))
        ' The Type objects in a and b are not equal,
        ' because they represent different types.

        a = GetType(Example)
        b = New Example().GetType()
        Console.WriteLine("{0} is equal to {1}: {2}", a, b, a.Equals(b))
        ' The Type objects in a and b are equal,
        ' because they both represent type Example.

        b = GetType(Type)
        Console.WriteLine("typeof({0}).Equals(typeof({1})): {2}", a, b, a.Equals(b))
        ' The Type objects in a and b are not equal,
        ' because variable a represents type Example
        ' and variable b represents type Type.

        'Console.ReadLine()
    
    End Sub 
End Class
'
' This code example produces the following output:
'    System.String = System.Int32: False
'    Example is equal to Example: True
'    typeof(Example).Equals(typeof(System.Type)): False
'

Weitere Informationen

• UnderlyingSystemType

Equals(Object)

Source:

Type.cs

Bestimmt, ob der zugrunde liegende Systemtyp des aktuellen Type-Objekts mit dem zugrunde liegenden Systemtyp des angegebenen Object-Objekts übereinstimmt

public:
 override bool Equals(System::Object ^ o);

public override bool Equals (object? o);

override this.Equals : obj -> bool

Public Overrides Function Equals (o As Object) As Boolean

Parameter

o

Object

Das Objekt, dessen zugrunde liegender Systemtyp mit dem zugrunde liegenden Systemtyp des aktuellen Type verglichen werden soll. Damit der Vergleich erfolgreich ist, o muss in ein Objekt vom Typ Typeumgewandelt oder konvertiert werden können.

Gibt zurück

Boolean

true, wenn der zugrunde liegende Systemtyp von o mit dem zugrunde liegenden Systemtyp des aktuellen Type übereinstimmt, andernfalls false. Diese Methode gibt auch in folgenden Fällen false zurück:

• o ist null.

• o nicht in ein Type-Objekt umgewandelt oder konvertiert werden kann.

Beispiele

Im folgenden Beispiel werden Equals(Object) verschiedene Type Objektinstanzen mit verschiedenen Object Instanzen verglichen.

using System;
using System.Collections.Generic;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      Type t =typeof(int);
      Object obj1 = typeof(int).GetTypeInfo();
      IsEqualTo(t, obj1);

      Object obj2 = typeof(String);
      IsEqualTo(t, obj2);
      
      t = typeof(Object);
      Object obj3 = typeof(Object);
      IsEqualTo(t, obj3);
      
      t = typeof(List<>);
      Object obj4 = (new List<String>()).GetType();
      IsEqualTo(t, obj4);
      
      t = typeof(Type);
      Object obj5 = null;
      IsEqualTo(t, obj5);
   }
   
   private static void IsEqualTo(Type t, Object inst)
   {
      Type t2 = inst as Type;
      if (t2 != null)
         Console.WriteLine("{0} = {1}: {2}", t.Name, t2.Name,
                           t.Equals(t2));
      else
         Console.WriteLine("Cannot cast the argument to a type.");

      Console.WriteLine();                        
   }
}
// The example displays the following output:
//       Int32 = Int32: True
//       
//       Int32 = String: False
//       
//       Object = Object: True
//       
//       List`1 = List`1: False
//       
//       Cannot cast the argument to a type.

open System
open System.Reflection

let isEqualTo (t: Type) (inst: obj) =
    match inst with
    | :? Type as t2 ->
        printfn $"{t.Name} = {t2.Name}: {t.Equals t2}\n"
    | _ ->
        printfn "Cannot cast the argument to a type.\n"

do 
    let t = typeof<int>
    typeof<int>.GetTypeInfo()
    |> isEqualTo t

    typeof<String>
    |> isEqualTo t

    let t = typeof<obj>
    typeof<obj>
    |> isEqualTo t

    let t = typeof<ResizeArray<_>>.GetGenericTypeDefinition()
    let obj4: obj = (ResizeArray<String>()).GetType()
    isEqualTo t obj4

    let t = typeof<Type>
    let obj5: obj = null
    isEqualTo t obj5
// The example displays the following output:
//       Int32 = Int32: True
//       
//       Int32 = String: False
//       
//       Object = Object: True
//       
//       List`1 = List`1: False
//       
//       Cannot cast the argument to a type.

Imports System.Collections.Generic
Imports System.Reflection

Module Example
   Public Sub Main()
      Dim t As Type = GetType(Integer)
      Dim obj1 As Object = GetType(Integer).GetTypeInfo()
      IsEqualTo(t, obj1)

      Dim obj2 As Object = GetType(String)
      IsEqualTo(t, obj2)
      
      t = GetType(Object)
      Dim obj3 As Object = GetType(Object)
      IsEqualTo(t, obj3)
      
      t = GetType(List(Of ))
      Dim obj4 As Object = (New List(Of String())).GetType()
      IsEqualTo(t, obj4)
      
      t = GetType(Type)
      Dim obj5 As Object = Nothing
      IsEqualTo(t, obj5)
   End Sub
   
   Private Sub IsEqualTo(t As Type, inst As Object)
      Dim t2 As Type = TryCast(inst, Type)
      If t2 IsNot Nothing Then
         Console.WriteLine("{0} = {1}: {2}", t.Name, t2.Name,
                           t.Equals(t2))
      Else
         Console.WriteLine("Cannot cast the argument to a type.")
      End If
      Console.WriteLine()                        
   End Sub
End Module
' The example displays the following output:
'       Int32 = Int32: True
'       
'       Int32 = String: False
'       
'       Object = Object: True
'       
'       List`1 = List`1: False
'       
'       Cannot cast the argument to a type.

Zwei Dinge sind am Beispiel besonders erwähnenswert:

• Der Vergleich eines Type Objekts, das eine ganze Zahl darstellt, mit einem TypeInfo Objekt, das eine ganze Zahl darstellt, true da TypeInfo von Typeabgeleitet wird.

• Der Vergleich eines Type Objekts, das ein IList<T> Objekt (ein offener generischer Typ) mit einem List(Of String) Objekt (ein geschlossener generischer Typ) darstellt, gibt zurück false.

Hinweise

Diese Methode überschreibt Object.Equals. Es wird in ein Objekt vom Typ Type umgewandelt o und die Type.Equals(Type) -Methode aufgerufen.

Weitere Informationen

• UnderlyingSystemType