Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Object.Equals (Object)

 

Publicado: octubre de 2016

Determina si el objeto especificado es igual al objeto actual.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

Public Overridable Function Equals (
	obj As Object
) As Boolean

Parámetros

obj
Type: System.Object

Objeto que se va a comparar con el objeto actual.

Valor devuelto

Type: System.Boolean

Es true si el objeto especificado es igual al objeto actual; en caso contrario, es false.

El tipo de comparación entre la instancia actual y la obj parámetro depende de si la instancia actual es un tipo de referencia o un tipo de valor.

  • Si la instancia actual es un tipo de referencia, el Equals(Object) método comprueba la igualdad de referencia y una llamada a la Equals(Object) método es equivalente a una llamada a la ReferenceEquals método. Igualdad de referencia significa que las variables de objeto que se comparan hacen referencia al mismo objeto. En el ejemplo siguiente se muestra el resultado de una comparación de este tipo. Define un Person (clase), que es un tipo de referencia, y llama el Person constructor de clase para crear dos instancias de nuevo Person objetos, person1a y person2, que tienen el mismo valor. También asigna person1a a otra variable de objeto, person1b. Como se muestra en el ejemplo, el salida person1a y person1b son iguales porque hacen referencia al mismo objeto. Sin embargo, person1a y person2 no son iguales, aunque tienen el mismo valor.

    ' Define a reference type that does not override Equals.
    Public Class Person
       Private personName As String
    
       Public Sub New(name As String)
          Me.personName = name
       End Sub
    
       Public Overrides Function ToString() As String
          Return Me.personName
       End Function 
    End Class
    
    Module Example
       Public Sub Main()
          Dim person1a As New Person("John")
          Dim person1b As Person = person1a
          Dim person2 As New Person(person1a.ToString())
    
          Console.WriteLine("Calling Equals:") 
          Console.WriteLine("person1a and person1b: {0}", person1a.Equals(person1b))               
          Console.WriteLine("person1a and person2: {0}", person1a.Equals(person2))  
          Console.WriteLine()
    
          Console.WriteLine("Casting to an Object and calling Equals:")
          Console.WriteLine("person1a and person1b: {0}", CObj(person1a).Equals(CObj(person1b)))
          Console.WriteLine("person1a and person2: {0}", CObj(person1a).Equals(CObj(person2))) 
       End Sub
    End Module
    ' The example displays the following output:
    '       Calling Equals:
    '       person1a and person1b: True
    '       person1a and person2: False
    '       
    '       Casting to an Object and calling Equals:
    '       person1a and person1b: True
    '       person1a and person2: False
    
  • Si la instancia actual es un tipo de valor, la Equals(Object) método comprueba la igualdad de valor. Igualdad de valores significa lo siguiente:

    • Los dos objetos son del mismo tipo. Como se muestra en el ejemplo siguiente, un Byte objeto que tiene un valor de 12 no es igual a un Int32 objeto que tiene un valor de 12, porque los dos objetos tienen distintos tipos de tiempo de ejecución.

      Module Example
         Public Sub Main()
            Dim value1 As Byte = 12
            Dim value2 As Integer = 12
      
            Dim object1 As Object = value1
            Dim object2 As Object = value2
      
            Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                              object1, object1.GetType().Name,
                              object2, object2.GetType().Name,
                              object1.Equals(object2))
         End Sub
      End Module
      ' The example displays the following output:
      '       12 (Byte) = 12 (Int32): False
      
    • Los valores de los campos públicos y privados de los dos objetos son iguales. En el ejemplo siguiente se comprueba la igualdad de valor. Define un Person estructura, que es un tipo de valor, y llama el Person constructor de clase para crear dos instancias de nuevo Person objetos, person1 y person2, que tienen el mismo valor. Como se muestra en el resultado del ejemplo, aunque las dos variables de objeto hacen referencia a objetos diferentes, person1 y person2 son iguales porque tienen el mismo valor para la privada personName campo.

      ' Define a value type that does not override Equals.
      Public Structure Person
         Private personName As String
      
         Public Sub New(name As String)
            Me.personName = name
         End Sub
      
         Public Overrides Function ToString() As String
            Return Me.personName
         End Function 
      End Structure
      
      Module Example
         Public Sub Main()
            Dim p1 As New Person("John")
            Dim p2 As New Person("John")
      
            Console.WriteLine("Calling Equals:") 
            Console.WriteLine(p1.Equals(p2))
            Console.WriteLine()
      
            Console.WriteLine("Casting to an Object and calling Equals:")
            Console.WriteLine(CObj(p1).Equals(p2))
         End Sub
      End Module
      ' The example displays the following output:
      '       Calling Equals:
      '       True
      '       
      '       Casting to an Object and calling Equals:
      '       True
      

Dado que la Object clase es la clase base para todos los tipos de .NET Framework, el Object.Equals(Object) método proporciona la comparación de igualdad predeterminado para todos los demás tipos. Sin embargo, los tipos a menudo invalidar la Equals método para implementar la igualdad de valor. Para obtener más información, vea las notas para los autores de llamadas y notas de secciones de los herederos.

Cuando se llama a la Equals(Object) sobrecarga del método en una clase de la Windows en tiempo de ejecución, proporciona el comportamiento predeterminado para las clases que no se invalidan Equals(Object). Esto forma parte de la compatibilidad que .NET Framework proporciona para Windows en tiempo de ejecución (vea Compatibilidad de .NET Framework con las aplicaciones de la Tienda Windows y Windows Runtime). Las clases en el Windows en tiempo de ejecución no heredar Objecty actualmente no se implementa un Equals(Object)método. Sin embargo, parece que tienen ToString, Equals(Object), y GetHashCode métodos cuando se usa en el código de C# o Visual Basic y .NET Framework proporciona el comportamiento predeterminado para estos métodos.

System_CAPS_noteNota

Windows en tiempo de ejecuciónlas clases que se escriben en C# o Visual Basic pueden invalidar la Equals(Object) sobrecarga del método.

Las clases derivadas reemplazan con frecuencia el Object.Equals(Object) método para implementar la igualdad de valor. Además, los tipos también suelen proporcionan una sobrecarga fuertemente tipada adicional a la Equals método, normalmente mediante la implementación de la IEquatable(Of T) interfaz. Cuando se llama a la Equals método para comprobar la igualdad, debe saber si la instancia actual invalida Object.Equals y entender cómo una determinada llamada a un Equals método se ha resuelto. En caso contrario, puede estar realizando una prueba de igualdad que es diferente de los previstos, y el método puede devolver un valor inesperado.

Esto se muestra en el ejemplo siguiente. Crea una instancia de tres StringBuilder objetos con cadenas idénticas y, a continuación, realiza cuatro llamadas a Equals métodos. La primera llamada al método devuelve truey el rendimiento de tres restantes false.

Imports System.Text

Module Example
   Public Sub Main()
      Dim sb1 As New StringBuilder("building a string...")
      Dim sb2 As New StringBuilder("building a string...")

      Console.WriteLine("sb1.Equals(sb2): {0}", sb1.Equals(sb2))
      Console.WriteLine("CObj(sb1).Equals(sb2): {0}", 
                        CObj(sb1).Equals(sb2))
      Console.WriteLine("Object.Equals(sb1, sb2): {0}",
                        Object.Equals(sb1, sb2))                  

      Console.WriteLine()
      Dim sb3 As Object = New StringBuilder("building a string...")
      Console.WriteLine("sb3.Equals(sb2): {0}", sb3.Equals(sb2))                              
   End Sub
End Module
' The example displays the following output:
'       sb1.Equals(sb2): True
'       CObj(sb1).Equals(sb2): False
'       Object.Equals(sb1, sb2): False
'
'       sb3.Equals(sb2): False

En el primer caso, fuertemente tipado StringBuilder.Equals(StringBuilder) sobrecarga del método, que comprueba la igualdad de valor, se llama. Dado que las cadenas se asignan a los dos StringBuilder objetos son iguales, el método devuelve true. Sin embargo, StringBuilder no invalida Object.Equals(Object). Por este motivo, cuando la StringBuilder objeto se convierte en una Object, cuando un StringBuilder instancia se asigna a una variable de tipo Objecty cuándo el Object.Equals(Object, Object) se pasa al método dos StringBuilder objetos, el valor predeterminado Object.Equals(Object) se llama al método. Dado que StringBuilder es un tipo de referencia, es equivalente a pasar los dos StringBuilder objetos a la ReferenceEquals método. Aunque las tres StringBuilder objetos contienen cadenas idénticas, hacen referencia a tres objetos distintos. Como resultado, estos tres métodos llama devuelto false.

Puede comparar el objeto actual con otro objeto para la igualdad de referencia mediante una llamada a la ReferenceEquals método. En Visual Basic, también puede utilizar el is palabra clave (por ejemplo, If Me Is otherObject Then ...).

Al definir su propio tipo, ese tipo hereda la funcionalidad definida por el Equals método de su tipo base. La tabla siguiente muestra la implementación predeterminada de la Equals método para las categorías principales de tipos en .NET Framework.

Categoría de tipo

Igualdad definida por

Comentarios

Clase se deriva directamenteObject

Object.Equals(Object)

Igualdad de referencia; equivalente a llamar a Object.ReferenceEquals.

Estructura

ValueType.Equals

Igualdad de valor; comparación byte a byte directa o en la comparación de campo a campo mediante la reflexión.

Enumeración

Enum.Equals

Valores deben tener el mismo tipo de enumeración y el mismo valor subyacente.

delegate

MulticastDelegate.Equals

Delegados deben tener el mismo tipo con listas de invocaciones idénticos.

Interface

Object.Equals(Object)

Igualdad de referencia.

Para un tipo de valor, debe invalidar siempre Equals, ya que comprueba la igualdad que se basan en la reflexión ofrece un rendimiento deficiente. También puede invalidar la implementación predeterminada de Equals para los tipos de referencia para comprobar la igualdad de valores en lugar de la igualdad de referencia y para definir el significado exacto de igualdad de valores. Este tipo de implementaciones de Equals devolver true si los dos objetos tienen el mismo valor, aunque no sean la misma instancia. El implementador de tipos decide qué constituye el valor de un objeto, pero suele ser todos o algunos de los datos almacenados en las variables de instancia del objeto. Por ejemplo, el valor de un String objeto se basa en los caracteres de la cadena; la String.Equals(Object) reemplazos de método la Object.Equals(Object) método devuelva true para cualquiera de dos cadenas instancias que contienen los mismos caracteres en el mismo orden.

En el ejemplo siguiente se muestra cómo invalidar el Object.Equals(Object) método para comprobar la igualdad de valor. Reemplaza el Equals método para el Person clase. Si Person aceptado su implementación de la clase base de la igualdad de los dos Person objetos sería iguales sólo si hace referencia a un único objeto. Sin embargo, en este caso, dos Person objetos son iguales si tienen el mismo valor para el Person.Id propiedad.

Public Class Person
   Private idNumber As String
   Private personName As String

   Public Sub New(name As String, id As String)
      Me.personName = name
      Me.idNumber = id
   End Sub

   Public Overrides Function Equals(obj As Object) As Boolean
      Dim personObj As Person = TryCast(obj, Person) 
      If personObj Is Nothing Then
         Return False
      Else
         Return idNumber.Equals(personObj.idNumber)
      End If   
   End Function

   Public Overrides Function GetHashCode() As Integer
      Return Me.idNumber.GetHashCode() 
   End Function
End Class

Module Example
   Public Sub Main()
      Dim p1 As New Person("John", "63412895")
      Dim p2 As New Person("Jack", "63412895")
      Console.WriteLine(p1.Equals(p2))
      Console.WriteLine(Object.Equals(p1, p2))
   End Sub
End Module
' The example displays the following output:
'       True
'       True

Además de invalidar Equals, puede implementar la IEquatable(Of T) interfaz para proporcionar una prueba de igualdad fuertemente tipada.

Las instrucciones siguientes deben ser true para todas las implementaciones de la Equals(Object) método. En la lista, x, y, y z representan referencias a objetos que no son null.

  • x.Equals(x)Devuelve true, excepto en los casos que implican tipos de punto flotante. Vea ISO/IEC/IEEE 60559:2011, Information technology--microprocesador sistemas--aritmética de coma flotante.

  • x.Equals(y)Devuelve el mismo valor que y.Equals(x).

  • x.Equals(y)Devuelve true si x y y son NaN.

  • Si (x.Equals(y) && y.Equals(z)) devuelve true, a continuación, x.Equals(z) devuelve true.

  • Las llamadas sucesivas a x.Equals(y) devuelven el mismo valor siempre y cuando los objetos al que hace referencia x y y no se modifican.

  • x.Equals(null) devuelve false.

Las implementaciones de Equals no deben producir excepciones; siempre deben devolver un valor. Por ejemplo, si obj es null, Equals método debe devolver false en lugar de producir una ArgumentNullException.

Siga estas directrices al reemplazar Equals(Object):

  • Los tipos que implementan IComparable debe invalidar Equals(Object).

  • Tipos que reemplazan Equals(Object) también debe invalidar GetHashCode; en caso contrario, las tablas hash no funcionen correctamente.

  • Puede implementar la IEquatable(Of T) interfaz para admitir fuertemente tipados comprueba la igualdad. Su IEquatable(Of T).Equals implementación debe devolver resultados coherentes con Equals.

  • Si su lenguaje de programación admite la sobrecarga de operadores y sobrecargar el operador de igualdad para un tipo determinado, también debe invalidar el Equals(Object) método para devolver el mismo resultado que el operador de igualdad. Esto ayuda a garantizar que código de biblioteca de clase que usa Equals (como ArrayList y Hashtable) se comporta de forma que sea coherente con la manera en que se usa el operador de igualdad por código de aplicación.

Las siguientes directrices se aplican a reemplazar Equals(Object) para un tipo de referencia:

  • Considere la posibilidad de reemplazar Equals si la semántica del tipo es basada en el hecho de que el tipo representa algunos valores.

  • La mayoría de los tipos de referencia no deben sobrecargar el operador de igualdad, aunque reemplacen Equals. Sin embargo, si va a implementar un tipo de referencia destinado a tener semántica de valor, como un tipo de número complejo, debe reemplazar el operador de igualdad.

  • No se debe reemplazar Equals en un tipo de referencia mutable. Esto es porque reemplazar Equals requiere que también invalidar el GetHashCode método, como se describe en la sección anterior. Esto significa que puede cambiar el código hash de una instancia de un tipo de referencia mutable durante su duración, lo que puede producir el objeto que se va a ser perdidos en una tabla hash.

Las siguientes directrices se aplican a reemplazar Equals(Object) para un tipo de valor:

  • Si va a definir un tipo de valor que incluye uno o más campos cuyos valores son tipos de referencia, debe invalidar Equals(Object). El Equals(Object) implementación proporcionada por ValueType realiza una comparación byte a byte para los tipos de valor cuyos campos son todos los tipos de valor, pero utiliza la reflexión para realizar una comparación de campo a campo de tipos de valor cuyos campos son tipos de referencia.

  • Si invalida Equals y el lenguaje de programación admite la sobrecarga de operadores, debe sobrecargar el operador de igualdad.

  • Debe implementar la IEquatable(Of T) interfaz. Al llamar a fuertemente tipado IEquatable(Of T).Equals método evita la conversión boxing el obj argumento.

El siguiente ejemplo se muestra un Point clase que invalide la Equals método para proporcionar la igualdad de valor y un Point3D clase que se deriva de Point. Dado que Point invalida Object.Equals(Object) para comprobar la igualdad de valor, la Object.Equals(Object) no se llama el método. Sin embargo, Point3D.Equals llamadas Point.Equals porque Point implementa Object.Equals(Object) de forma que se proporciona igualdad de valor.

Class Point
    Protected x, y As Integer

    Public Sub New() 
        Me.x = 0
        Me.y = 0
    End Sub

    Public Sub New(x As Integer, y As Integer) 
        Me.x = x
        Me.y = y
    End Sub 

    Public Overrides Function Equals(obj As Object) As Boolean 
        ' Check for null and compare run-time types.
        If obj Is Nothing OrElse Not Me.GetType().Equals(obj.GetType()) Then
           Return False
        Else
           Dim p As Point = DirectCast(obj, Point)
           Return x = p.x AndAlso y = p.y
        End If
    End Function 

    Public Overrides Function GetHashCode() As Integer 
        Return (x << 2) XOr y
    End Function

    Public Overrides Function ToString() As String
        Return String.Format("Point({0}, {1})", x, y)
    End Function
End Class

Class Point3D : Inherits Point
    Private z As Integer

    Public Sub New(ByVal x As Integer, ByVal y As Integer, ByVal z As Integer) 
        MyBase.New(x, y) 
        Me.z = Z
    End Sub

    Public Overrides Function Equals(ByVal obj As Object) As Boolean 
        Dim pt3 As Point3D = TryCast(obj, Point3D)
        If pt3 Is Nothing Then
           Return False
        Else
           Return MyBase.Equals(CType(pt3, Point)) AndAlso z = pt3.Z  
        End If
    End Function

    Public Overrides Function GetHashCode() As Integer 
        Return (MyBase.GetHashCode() << 2) XOr z
    End Function 

    Public Overrides Function ToString() As String
        Return String.Format("Point({0}, {1}, {2})", x, y, z)
    End Function
End Class 

Module Example
    Public Sub Main() 
        Dim point2D As New Point(5, 5)
        Dim point3Da As New Point3D(5, 5, 2)
        Dim point3Db As New Point3D(5, 5, 2)
        Dim point3Dc As New Point3D(5, 5, -1)

        Console.WriteLine("{0} = {1}: {2}", 
                          point2D, point3Da, point2D.Equals(point3Da))
        Console.WriteLine("{0} = {1}: {2}", 
                          point2D, point3Db, point2D.Equals(point3Db))        
        Console.WriteLine("{0} = {1}: {2}", 
                          point3Da, point3Db, point3Da.Equals(point3Db))
        Console.WriteLine("{0} = {1}: {2}", 
                          point3Da, point3Dc, point3Da.Equals(point3Dc))
    End Sub  
End Module 
' The example displays the following output
'       Point(5, 5) = Point(5, 5, 2): False
'       Point(5, 5) = Point(5, 5, 2): False
'       Point(5, 5, 2) = Point(5, 5, 2): True
'       Point(5, 5, 2) = Point(5, 5, -1): False

The Point.Equals method checks to make sure that the obj argument is not null and that it references an instance of the same type as this object. If either check fails, the method returns false.

The Point.Equals method calls the M:System.Object.GetType method to determine whether the run-time types of the two objects are identical. If the method used a check of the form obj is Point in C# or TryCast(obj, Point) in Visual Basic, the check would return true in cases where obj is an instance of a derived class of Point, even though obj and the current instance are not of the same run-time type. Having verified that both objects are of the same type, the method casts obj to type Point and returns the result of comparing the instance fields of the two objects.

In Point3D.Equals, the inherited Point.Equals method, which overrides M:System.Object.Equals(System.Object), is invoked before anything else is done. Because Point3D is a sealed class (NotInheritable in Visual Basic), a check in the form obj is Point in C# or TryCast(obj, Point) in Visual Basic is adequate to ensure that obj is a Point3D object. If it is a Point3D object, it is cast to a Point object and passed to the base class implementation of M:System.Object.Equals(System.Object). Only when the inherited Point.Equals method returns true does the method compare the z instance fields introduced in the derived class.

En el ejemplo siguiente se define un Rectangle clase que implementa internamente un rectángulo como dos Point objetos. El Rectangle también clase invalidaciones Object.Equals(Object) para proporcionar la igualdad de valores.

Class Rectangle 
    Private a, b As Point

    Public Sub New(ByVal upLeftX As Integer, ByVal upLeftY As Integer, _
                   ByVal downRightX As Integer, ByVal downRightY As Integer) 
        Me.a = New Point(upLeftX, upLeftY)
        Me.b = New Point(downRightX, downRightY)
    End Sub 

    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        ' Performs an equality check on two rectangles (Point object pairs).
        If obj Is Nothing OrElse Not [GetType]().Equals(obj.GetType()) Then
            Return False
        End If
        Dim r As Rectangle = CType(obj, Rectangle)
        Return a.Equals(r.a) AndAlso b.Equals(r.b)
    End Function

    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(a, b).GetHashCode()
    End Function 

    Public Overrides Function ToString() As String
       Return String.Format("Rectangle({0}, {1}, {2}, {3})",
                            a.x, a.y, b.x, b.y) 
    End Function
End Class 

Class Point
    Friend x As Integer
    Friend y As Integer

    Public Sub New(ByVal X As Integer, ByVal Y As Integer) 
        Me.x = X
        Me.y = Y
    End Sub 

    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        ' Performs an equality check on two points (integer pairs).
        If obj Is Nothing OrElse Not [GetType]().Equals(obj.GetType()) Then
            Return False
        Else
           Dim p As Point = CType(obj, Point)
           Return x = p.x AndAlso y = p.y
        End If
    End Function 

    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(x, y).GetHashCode()
    End Function 
End Class  

Class Example
    Public Shared Sub Main() 
        Dim r1 As New Rectangle(0, 0, 100, 200)
        Dim r2 As New Rectangle(0, 0, 100, 200)
        Dim r3 As New Rectangle(0, 0, 150, 200)

        Console.WriteLine("{0} = {1}: {2}", r1, r2, r1.Equals(r2))
        Console.WriteLine("{0} = {1}: {2}", r1, r3, r1.Equals(r3))
        Console.WriteLine("{0} = {1}: {2}", r2, r3, r2.Equals(r3))
    End Sub 
End Class 
' The example displays the following output:
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
'    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False

Algunos lenguajes como C# y Visual Basic admiten la sobrecarga de operadores. Cuando un tipo sobrecarga el operador de igualdad, también debe invalidar el Equals(Object) método para proporcionar la misma funcionalidad. Esto se consigue normalmente escribiendo el Equals(Object) método en términos del operador de igualdad sobrecargado, como en el ejemplo siguiente.

Public Structure Complex
    Public re, im As Double

    Public Overrides Function Equals(ByVal obj As [Object]) As Boolean 
        Return TypeOf obj Is Complex AndAlso Me = CType(obj, Complex)
    End Function 

    Public Overrides Function GetHashCode() As Integer 
        Return Tuple.Create(re, im).GetHashCode()
    End Function 

    Public Shared Operator = (x As Complex, y As Complex) As Boolean
       Return x.re = y.re AndAlso x.im = y.im
    End Operator 

    Public Shared Operator <> (x As Complex, y As Complex) As Boolean
       Return Not (x = y)
    End Operator 

    Public Overrides Function ToString() As String
       Return String.Format("({0}, {1})", re, im)
    End Function 
End Structure

Class Example
   Public Shared Sub Main() 
      Dim cmplx1, cmplx2 As Complex

      cmplx1.re = 4.0
      cmplx1.im = 1.0

      cmplx2.re = 2.0
      cmplx2.im = 1.0

      Console.WriteLine("{0} <> {1}: {2}", cmplx1, cmplx2, cmplx1 <> cmplx2)        
      Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2))        

      cmplx2.re = 4.0

      Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1 = cmplx2)        
      Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2))        
   End Sub
End Class 
' The example displays the following output:
'       (4, 1) <> (2, 1): True
'       (4, 1) = (2, 1): False
'       (4, 1) = (4, 1): True
'       (4, 1) = (4, 1): True

Because Complex is a value type, it cannot be derived from. Therefore, the override to M:System.Object.Equals(System.Object) method need not call M:System.Object.GetType to determine the precise run-time type of each object, but can instead use the is operator in C# or the TypeOf operator in Visual Basic to check the type of the obj parameter.

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: