BitVector32.Equals Método
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Equals(BitVector32) |
Indica si la instancia actual es igual a otra instancia del mismo tipo. |
Equals(Object) |
Determina si el objeto especificado es igual a BitVector32. |
- Source:
- BitVector32.cs
- Source:
- BitVector32.cs
- Source:
- BitVector32.cs
Indica si la instancia actual es igual a otra instancia del mismo tipo.
public:
virtual bool Equals(System::Collections::Specialized::BitVector32 other);
public bool Equals (System.Collections.Specialized.BitVector32 other);
override this.Equals : System.Collections.Specialized.BitVector32 -> bool
Public Function Equals (other As BitVector32) As Boolean
Parámetros
- other
- BitVector32
Instancia de que se va a comparar con esta instancia.
Devoluciones
true
si la instancia actual es igual a la otra instancia; de lo contrario, false
.
Implementaciones
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | 7, 8, 9 |
- Source:
- BitVector32.cs
- Source:
- BitVector32.cs
- Source:
- BitVector32.cs
Determina si el objeto especificado es igual a BitVector32.
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
Parámetros
- o
- Object
Objeto que se va a comparar con el objeto BitVector32 actual.
Devoluciones
Es true
si el objeto especificado es igual a BitVector32; en caso contrario, es false
.
Ejemplos
En el ejemplo de código siguiente se compara un BitVector32 objeto con otro BitVector32 y con .Int32
#using <system.dll>
using namespace System;
using namespace System::Collections::Specialized;
int main()
{
// Creates and initializes a BitVector32 with the value 123.
// This is the BitVector32 that will be compared to different types.
BitVector32 myBV(123);
// Creates and initializes a new BitVector32 which will be set up as sections.
BitVector32 myBVsect(0);
// Compares myBV and myBVsect.
Console::WriteLine( "myBV : {0}", myBV );
Console::WriteLine( "myBVsect : {0}", myBVsect );
if ( myBV.Equals( myBVsect ) )
Console::WriteLine( " myBV( {0}) equals myBVsect( {1}).", myBV.Data, myBVsect.Data );
else
Console::WriteLine( " myBV( {0}) does not equal myBVsect( {1}).", myBV.Data, myBVsect.Data );
Console::WriteLine();
// Assigns values to the sections of myBVsect.
BitVector32::Section mySect1 = BitVector32::CreateSection( 5 );
BitVector32::Section mySect2 = BitVector32::CreateSection( 1, mySect1 );
BitVector32::Section mySect3 = BitVector32::CreateSection( 20, mySect2 );
myBVsect[ mySect1 ] = 3;
myBVsect[ mySect2 ] = 1;
myBVsect[ mySect3 ] = 7;
// Compares myBV and myBVsect.
Console::WriteLine( "myBV : {0}", myBV );
Console::WriteLine( "myBVsect with values : {0}", myBVsect );
if ( myBV.Equals( myBVsect ) )
Console::WriteLine( " myBV( {0}) equals myBVsect( {1}).", myBV.Data, myBVsect.Data );
else
Console::WriteLine( " myBV( {0}) does not equal myBVsect( {1}).", myBV.Data, myBVsect.Data );
Console::WriteLine();
// Compare myBV with an Int32.
Console::WriteLine( "Comparing myBV with an Int32: " );
Int32 myInt32 = 123;
// Using Equals will fail because Int32 is not compatible with BitVector32.
if ( myBV.Equals( myInt32 ) )
Console::WriteLine( " Using BitVector32::Equals, myBV( {0}) equals myInt32( {1}).", myBV.Data, myInt32 );
else
Console::WriteLine( " Using BitVector32::Equals, myBV( {0}) does not equal myInt32( {1}).", myBV.Data, myInt32 );
// To compare a BitVector32 with an Int32, use the "==" operator.
if ( myBV.Data == myInt32 )
Console::WriteLine( " Using the \"==\" operator, myBV.Data( {0}) equals myInt32( {1}).", myBV.Data, myInt32 );
else
Console::WriteLine( " Using the \"==\" operator, myBV.Data( {0}) does not equal myInt32( {1}).", myBV.Data, myInt32 );
}
/*
This code produces the following output.
myBV : BitVector32 {00000000000000000000000001111011}
myBVsect : BitVector32 {00000000000000000000000000000000}
myBV(123) does not equal myBVsect(0).
myBV : BitVector32 {00000000000000000000000001111011}
myBVsect with values : BitVector32 {00000000000000000000000001111011}
myBV(123) equals myBVsect(123).
Comparing myBV with an Int32:
Using BitVector32::Equals, myBV(123) does not equal myInt32(123).
Using the "==" operator, myBV.Data(123) equals myInt32(123).
*/
using System;
using System.Collections.Specialized;
public class SamplesBitVector32 {
public static void Main() {
// Creates and initializes a BitVector32 with the value 123.
// This is the BitVector32 that will be compared to different types.
BitVector32 myBV = new BitVector32( 123 );
// Creates and initializes a new BitVector32 which will be set up as sections.
BitVector32 myBVsect = new BitVector32( 0 );
// Compares myBV and myBVsect.
Console.WriteLine( "myBV : {0}", myBV.ToString() );
Console.WriteLine( "myBVsect : {0}", myBVsect.ToString() );
if ( myBV.Equals( myBVsect ) )
Console.WriteLine( " myBV({0}) equals myBVsect({1}).", myBV.Data, myBVsect.Data );
else
Console.WriteLine( " myBV({0}) does not equal myBVsect({1}).", myBV.Data, myBVsect.Data );
Console.WriteLine();
// Assigns values to the sections of myBVsect.
BitVector32.Section mySect1 = BitVector32.CreateSection( 5 );
BitVector32.Section mySect2 = BitVector32.CreateSection( 1, mySect1 );
BitVector32.Section mySect3 = BitVector32.CreateSection( 20, mySect2 );
myBVsect[mySect1] = 3;
myBVsect[mySect2] = 1;
myBVsect[mySect3] = 7;
// Compares myBV and myBVsect.
Console.WriteLine( "myBV : {0}", myBV.ToString() );
Console.WriteLine( "myBVsect with values : {0}", myBVsect.ToString() );
if ( myBV.Equals( myBVsect ) )
Console.WriteLine( " myBV({0}) equals myBVsect({1}).", myBV.Data, myBVsect.Data );
else
Console.WriteLine( " myBV({0}) does not equal myBVsect({1}).", myBV.Data, myBVsect.Data );
Console.WriteLine();
// Compare myBV with an Int32.
Console.WriteLine( "Comparing myBV with an Int32: " );
Int32 myInt32 = 123;
// Using Equals will fail because Int32 is not compatible with BitVector32.
if ( myBV.Equals( myInt32 ) )
Console.WriteLine( " Using BitVector32.Equals, myBV({0}) equals myInt32({1}).", myBV.Data, myInt32 );
else
Console.WriteLine( " Using BitVector32.Equals, myBV({0}) does not equal myInt32({1}).", myBV.Data, myInt32 );
// To compare a BitVector32 with an Int32, use the "==" operator.
if ( myBV.Data == myInt32 )
Console.WriteLine( " Using the \"==\" operator, myBV.Data({0}) equals myInt32({1}).", myBV.Data, myInt32 );
else
Console.WriteLine( " Using the \"==\" operator, myBV.Data({0}) does not equal myInt32({1}).", myBV.Data, myInt32 );
}
}
/*
This code produces the following output.
myBV : BitVector32{00000000000000000000000001111011}
myBVsect : BitVector32{00000000000000000000000000000000}
myBV(123) does not equal myBVsect(0).
myBV : BitVector32{00000000000000000000000001111011}
myBVsect with values : BitVector32{00000000000000000000000001111011}
myBV(123) equals myBVsect(123).
Comparing myBV with an Int32:
Using BitVector32.Equals, myBV(123) does not equal myInt32(123).
Using the "==" operator, myBV.Data(123) equals myInt32(123).
*/
Imports System.Collections.Specialized
Public Class SamplesBitVector32
Public Shared Sub Main()
' Creates and initializes a BitVector32 with the value 123.
' This is the BitVector32 that will be compared to different types.
Dim myBV As New BitVector32(123)
' Creates and initializes a new BitVector32 which will be set up as sections.
Dim myBVsect As New BitVector32(0)
' Compares myBV and myBVsect.
Console.WriteLine("myBV : {0}", myBV.ToString())
Console.WriteLine("myBVsect : {0}", myBVsect.ToString())
If myBV.Equals(myBVsect) Then
Console.WriteLine(" myBV({0}) equals myBVsect({1}).", myBV.Data, myBVsect.Data)
Else
Console.WriteLine(" myBV({0}) does not equal myBVsect({1}).", myBV.Data, myBVsect.Data)
End If
Console.WriteLine()
' Assigns values to the sections of myBVsect.
Dim mySect1 As BitVector32.Section = BitVector32.CreateSection(5)
Dim mySect2 As BitVector32.Section = BitVector32.CreateSection(1, mySect1)
Dim mySect3 As BitVector32.Section = BitVector32.CreateSection(20, mySect2)
myBVsect(mySect1) = 3
myBVsect(mySect2) = 1
myBVsect(mySect3) = 7
' Compares myBV and myBVsect.
Console.WriteLine("myBV : {0}", myBV.ToString())
Console.WriteLine("myBVsect with values : {0}", myBVsect.ToString())
If myBV.Equals(myBVsect) Then
Console.WriteLine(" myBV({0}) equals myBVsect({1}).", myBV.Data, myBVsect.Data)
Else
Console.WriteLine(" myBV({0}) does not equal myBVsect({1}).", myBV.Data, myBVsect.Data)
End If
Console.WriteLine()
' Compare myBV with an Int32.
Console.WriteLine("Comparing myBV with an Int32: ")
Dim myInt32 As Int32 = 123
' Using Equals will fail because Int32 is not compatible with BitVector32.
If myBV.Equals(myInt32) Then
Console.WriteLine(" Using BitVector32.Equals, myBV({0}) equals myInt32({1}).", myBV.Data, myInt32)
Else
Console.WriteLine(" Using BitVector32.Equals, myBV({0}) does not equal myInt32({1}).", myBV.Data, myInt32)
End If ' To compare a BitVector32 with an Int32, use the "==" operator.
If myBV.Data = myInt32 Then
Console.WriteLine(" Using the ""=="" operator, myBV.Data({0}) equals myInt32({1}).", myBV.Data, myInt32)
Else
Console.WriteLine(" Using the ""=="" operator, myBV.Data({0}) does not equal myInt32({1}).", myBV.Data, myInt32)
End If
End Sub
End Class
' This code produces the following output.
'
' myBV : BitVector32{00000000000000000000000001111011}
' myBVsect : BitVector32{00000000000000000000000000000000}
' myBV(123) does not equal myBVsect(0).
'
' myBV : BitVector32{00000000000000000000000001111011}
' myBVsect with values : BitVector32{00000000000000000000000001111011}
' myBV(123) equals myBVsect(123).
'
' Comparing myBV with an Int32:
' Using BitVector32.Equals, myBV(123) does not equal myInt32(123).
' Using the "==" operator, myBV.Data(123) equals myInt32(123).
Comentarios
El objeto o
se considera igual que BitVector32 si el tipo de o
es compatible con el BitVector32 tipo y si el valor de o
es igual al valor de Data.
Este método es una operación O(1).
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
UWP | 10.0 |
Comentarios de .NET
.NET es un proyecto de código abierto. Seleccione un vínculo para proporcionar comentarios: