Type.Equals Metod

Definition

Namnområde:
System
Sammansättningar:
mscorlib.dll, System.Runtime.dll
Sammansättningar:
netstandard.dll, System.Runtime.dll
Sammansättning:
System.Runtime.dll
Sammansättning:
mscorlib.dll
Sammansättning:
netstandard.dll

Avgör om den underliggande systemtypen för den aktuella är Type samma som den underliggande systemtypen för den angivna Object eller Type.

Överlagringar

Name Description
Equals(Type)

Avgör om den underliggande systemtypen för den aktuella är Type samma som den underliggande systemtypen för den angivna Type.
Equals(Object)

Avgör om den underliggande systemtypen för det aktuella Type objektet är samma som den underliggande systemtypen för den angivna Object.

Equals(Type)

Källa:
Type.cs
Källa:
Type.cs
Källa:
Type.cs
Källa:
Type.cs
Källa:
Type.cs

Avgör om den underliggande systemtypen för den aktuella är Type samma som den underliggande systemtypen för den angivna Type.

public:
 bool Equals(Type ^ o);
public:
 virtual bool Equals(Type ^ o);
public bool Equals(Type o);
public virtual bool Equals(Type? o);
public virtual bool Equals(Type o);
override this.Equals : Type -> bool
Public Function Equals (o As Type) As Boolean
Public Overridable Function Equals (o As Type) As Boolean

Parametrar

o
Type

Objektet vars underliggande systemtyp ska jämföras med den underliggande systemtypen för den aktuella Type.

Returer

Boolean

true om den underliggande systemtypen o är samma som den underliggande systemtypen för den aktuella Type, annars false.

Implementeringar

Equals(Type)

Exempel

I följande exempel används Equals för att jämföra två typer.


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
'

Se även

Gäller för

Equals(Object)

Källa:
Type.cs
Källa:
Type.cs
Källa:
Type.cs
Källa:
Type.cs
Källa:
Type.cs

Avgör om den underliggande systemtypen för det aktuella Type objektet är samma som den underliggande systemtypen för den angivna Object.

public:
 override bool Equals(System::Object ^ o);
public override bool Equals(object o);
public override bool Equals(object? o);
override this.Equals : obj -> bool
Public Overrides Function Equals (o As Object) As Boolean

Parametrar

o
Object

Objektet vars underliggande systemtyp ska jämföras med den underliggande systemtypen för den aktuella Type. För att jämförelsen ska lyckas o måste kunna konverteras eller konverteras till ett objekt av typen Type.

Returer

Boolean

true om den underliggande systemtypen o är samma som den underliggande systemtypen för den aktuella Type, annars false. Den här metoden returnerar false även om:

  • o är null.

  • o kan inte gjutas eller konverteras till ett Type objekt.

Implementeringar

Equals(Object)

Exempel

I följande exempel används Equals(Object) för att jämföra olika Type objektinstanser med olika Object instanser.

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.

Två saker är särskilt värda att notera i exemplet:

  • Jämförelsen av ett Type objekt som representerar ett heltal med ett TypeInfo objekt som representerar en heltalsretur true eftersom TypeInfo härleds från Type.

  • Jämförelsen av ett Type objekt som representerar ett IList<T> objekt (en öppen allmän typ) med ett List(Of String) objekt (en sluten allmän typ) returnerar false.

Kommentarer

Den här metoden åsidosätter Object.Equals. Den genererar o ett objekt av typen Type och anropar Type.Equals(Type) metoden.

Se även

Gäller för