String.Equals Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Determina se dois objetos String têm o mesmo valor.

Sobrecargas

Equals(Object)	Determina se essa instância e um objeto especificado, que também deve ser um objeto String, têm o mesmo valor.
Equals(String)	Determina se essa instância e outro objeto String especificado têm o mesmo valor.
Equals(String, String)	Determina se dois objetos String especificados têm o mesmo valor.
Equals(String, StringComparison)	Determina se essa cadeia de caracteres e um objeto String especificado têm o mesmo valor. Um parâmetro especifica a cultura, as maiúsculas e minúsculas e as regras de classificação usadas na comparação.
Equals(String, String, StringComparison)	Determina se dois objetos String especificados têm o mesmo valor. Um parâmetro especifica a cultura, as maiúsculas e minúsculas e as regras de classificação usadas na comparação.

Equals(Object)

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Determina se essa instância e um objeto especificado, que também deve ser um objeto String, têm o mesmo valor.

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

public override bool Equals (object obj);

public override bool Equals (object? obj);

override this.Equals : obj -> bool

Public Overrides Function Equals (obj As Object) As Boolean

Parâmetros

obj: Object

A cadeia de caracteres a ser comparada com esta instância.

Retornos

Boolean

true se obj for um String e seu valor for o mesmo que o dessa instância; caso contrário, false. Se obj for null, o método retornará false.

Exemplos

O exemplo a seguir demonstra o Equals método.

// Sample for String::Equals(Object)
//            String::Equals(String)
//            String::Equals(String, String)
using namespace System;
using namespace System::Text;
int main()
{
   StringBuilder^ sb = gcnew StringBuilder( "abcd" );
   String^ str1 = "abcd";
   String^ str2 = nullptr;
   Object^ o2 = nullptr;
   Console::WriteLine();
   Console::WriteLine( " *  The value of String str1 is '{0}'.", str1 );
   Console::WriteLine( " *  The value of StringBuilder sb is '{0}'.", sb );
   Console::WriteLine();
   Console::WriteLine( "1a) String::Equals(Object). Object is a StringBuilder, not a String." );
   Console::WriteLine( "    Is str1 equal to sb?: {0}", str1->Equals( sb ) );
   Console::WriteLine();
   Console::WriteLine( "1b) String::Equals(Object). Object is a String." );
   str2 = sb->ToString();
   o2 = str2;
   Console::WriteLine( " *  The value of Object o2 is '{0}'.", o2 );
   Console::WriteLine( "    Is str1 equal to o2?: {0}", str1->Equals( o2 ) );
   Console::WriteLine();
   Console::WriteLine( " 2) String::Equals(String)" );
   Console::WriteLine( " *  The value of String str2 is '{0}'.", str2 );
   Console::WriteLine( "    Is str1 equal to str2?: {0}", str1->Equals( str2 ) );
   Console::WriteLine();
   Console::WriteLine( " 3) String::Equals(String, String)" );
   Console::WriteLine( "    Is str1 equal to str2?: {0}", String::Equals( str1, str2 ) );
}

/*
This example produces the following results:

 *  The value of String str1 is 'abcd'.
 *  The value of StringBuilder sb is 'abcd'.

1a) String::Equals(Object). Object is a StringBuilder, not a String.
    Is str1 equal to sb?: False

1b) String::Equals(Object). Object is a String.
 *  The value of Object o2 is 'abcd'.
    Is str1 equal to o2?: True

 2) String::Equals(String)
 *  The value of String str2 is 'abcd'.
    Is str1 equal to str2?: True

 3) String::Equals(String, String)
    Is str1 equal to str2?: True
*/

// Sample for String.Equals(Object)
//            String.Equals(String)
//            String.Equals(String, String)
using System;
using System.Text;

class Sample1
{
    public static void Main()
    {
        StringBuilder sb = new StringBuilder("abcd");
        String str1 = "abcd";
        String str2 = null;
        Object o2 = null;

        Console.WriteLine();
        Console.WriteLine(" *  The value of String str1 is '{0}'.", str1);
        Console.WriteLine(" *  The value of StringBuilder sb is '{0}'.", sb.ToString());

        Console.WriteLine();
        Console.WriteLine("1a) String.Equals(Object). Object is a StringBuilder, not a String.");
        Console.WriteLine("    Is str1 equal to sb?: {0}", str1.Equals(sb));

        Console.WriteLine();
        Console.WriteLine("1b) String.Equals(Object). Object is a String.");
        str2 = sb.ToString();
        o2 = str2;
        Console.WriteLine(" *  The value of Object o2 is '{0}'.", o2);
        Console.WriteLine("    Is str1 equal to o2?: {0}", str1.Equals(o2));

        Console.WriteLine();
        Console.WriteLine(" 2) String.Equals(String)");
        Console.WriteLine(" *  The value of String str2 is '{0}'.", str2);
        Console.WriteLine("    Is str1 equal to str2?: {0}", str1.Equals(str2));

        Console.WriteLine();
        Console.WriteLine(" 3) String.Equals(String, String)");
        Console.WriteLine("    Is str1 equal to str2?: {0}", String.Equals(str1, str2));
    }
}
/*
This example produces the following results:

 *  The value of String str1 is 'abcd'.
 *  The value of StringBuilder sb is 'abcd'.

1a) String.Equals(Object). Object is a StringBuilder, not a String.
    Is str1 equal to sb?: False

1b) String.Equals(Object). Object is a String.
 *  The value of Object o2 is 'abcd'.
    Is str1 equal to o2?: True

 2) String.Equals(String)
 *  The value of String str2 is 'abcd'.
    Is str1 equal to str2?: True

 3) String.Equals(String, String)
    Is str1 equal to str2?: True
*/

// Sample for String.Equals(Object)
//            String.Equals(String)
//            String.Equals(String, String)
open System
open System.Text

let sb = StringBuilder "abcd"
let str1 = "abcd"
let str2 = string sb
let o2: obj = str2

printfn $"""
*  The value of String str1 is '{str1}'.
*  The value of StringBuilder sb is '{sb}'.

1a) String.Equals(Object). Object is a StringBuilder, not a String.
Is str1 equal to sb?: {str1.Equals sb}"

1b) String.Equals(Object). Object is a String.
*  The value of Object o2 is '{o2}'.
Is str1 equal to o2?: {str1.Equals o2}

2) String.Equals(String)
*  The value of String str2 is '{str2}'.
Is str1 equal to str2?: {str1.Equals str2}

3) String.Equals(String, String)
Is str1 equal to str2?: {String.Equals(str1, str2)}"""
(*
This example produces the following results:

 *  The value of String str1 is 'abcd'.
 *  The value of StringBuilder sb is 'abcd'.

1a) String.Equals(Object). Object is a StringBuilder, not a String.
    Is str1 equal to sb?: False

1b) String.Equals(Object). Object is a String.
 *  The value of Object o2 is 'abcd'.
    Is str1 equal to o2?: True

 2) String.Equals(String)
 *  The value of String str2 is 'abcd'.
    Is str1 equal to str2?: True

 3) String.Equals(String, String)
    Is str1 equal to str2?: True
*)

' Sample for String.Equals(Object)
'            String.Equals(String)
'            String.Equals(String, String)
Imports System.Text

Class Sample
   Public Shared Sub Main()
      Dim sb As New StringBuilder("abcd")
      Dim str1 As [String] = "abcd"
      Dim str2 As [String] = Nothing
      Dim o2 As [Object] = Nothing
      
      Console.WriteLine()
      Console.WriteLine(" *  The value of String str1 is '{0}'.", str1)
      Console.WriteLine(" *  The value of StringBuilder sb is '{0}'.", sb.ToString())
      
      Console.WriteLine()
      Console.WriteLine("1a) String.Equals(Object). Object is a StringBuilder, not a String.")
      Console.WriteLine("    Is str1 equal to sb?: {0}", str1.Equals(sb))
      
      Console.WriteLine()
      Console.WriteLine("1b) String.Equals(Object). Object is a String.")
      str2 = sb.ToString()
      o2 = str2
      Console.WriteLine(" *  The value of Object o2 is '{0}'.", o2)
      Console.WriteLine("    Is str1 equal to o2?: {0}", str1.Equals(o2))
      
      Console.WriteLine()
      Console.WriteLine(" 2) String.Equals(String)")
      Console.WriteLine(" *  The value of String str2 is '{0}'.", str2)
      Console.WriteLine("    Is str1 equal to str2?: {0}", str1.Equals(str2))
      
      Console.WriteLine()
      Console.WriteLine(" 3) String.Equals(String, String)")
      Console.WriteLine("    Is str1 equal to str2?: {0}", [String].Equals(str1, str2))
   End Sub
End Class
'
'This example produces the following results:
'
' *  The value of String str1 is 'abcd'.
' *  The value of StringBuilder sb is 'abcd'.
'
'1a) String.Equals(Object). Object is a StringBuilder, not a String.
'    Is str1 equal to sb?: False
'
'1b) String.Equals(Object). Object is a String.
' *  The value of Object o2 is 'abcd'.
'    Is str1 equal to o2?: True
'
' 2) String.Equals(String)
' *  The value of String str2 is 'abcd'.
'    Is str1 equal to str2?: True
'
' 3) String.Equals(String, String)
'    Is str1 equal to str2?: True
'

Comentários

Este método executa uma comparação ordinal (diferencia maiúsculas de minúsculas e insensível à cultura).

Confira também

Aplica-se a

Equals(String)

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Determina se essa instância e outro objeto String especificado têm o mesmo valor.

public:
 virtual bool Equals(System::String ^ value);

public:
 bool Equals(System::String ^ value);

public bool Equals (string value);

public bool Equals (string? value);

override this.Equals : string -> bool

Public Function Equals (value As String) As Boolean

Parâmetros

value: String

A cadeia de caracteres a ser comparada com esta instância.

Retornos

Boolean

true se o valor do parâmetro value for igual ao valor dessa instância; caso contrário, false. Se value for null, o método retornará false.

Implementações

Equals(T)

Exemplos

O exemplo a seguir demonstra o Equals método. Ele compara a palavra com letras maiúsculas "Arquivo" com uma palavra equivalente, seu equivalente minúsculo, seu equivalente maiúsculo e uma palavra que contém LATIN SMALL LETTER DOTLESS I (U+0131) em vez de LATIN SMALL LETTER I (U+0069). Como o Equals(String) método executa uma comparação ordinal, apenas a comparação com uma palavra idêntica retorna true.

using System;

public class Example
{
    public static void Main()
    {
        Console.OutputEncoding = System.Text.Encoding.UTF8;
        string word = "File";
        string[] others = { word.ToLower(), word, word.ToUpper(), "Fıle" };
        foreach (string other in others)
        {
            if (word.Equals(other))
                Console.WriteLine("{0} = {1}", word, other);
            else
                Console.WriteLine("{0} {1} {2}", word, '\u2260', other);
        }
    }
}
// The example displays the following output:
//       File ≠ file
//       File = File
//       File ≠ FILE
//       File ≠ Fıle

open System

Console.OutputEncoding <- Text.Encoding.UTF8
let word = "File"
let others = [| word.ToLower(); word; word.ToUpper(); "Fıle" |]
for other in others do
    if word.Equals other then
        printfn $"{word} = {other}"
    else
        printfn $"{word} \u2260 {other}"
// The example displays the following output:
//       File ≠ file
//       File = File
//       File ≠ FILE
//       File ≠ Fıle

Module Example
   Public Sub Main()
      Console.OutputEncoding = System.Text.Encoding.UTF8
      
      Dim word As String = "File"
      Dim others() As String = { word.ToLower(), word, word.ToUpper(), _
                                 "Fıle" }
      For Each other As String In others
         If word.Equals(other) Then 
            Console.WriteLine("{0} = {1}", word, other)
         Else
            Console.WriteLine("{0} {1} {2}", word, ChrW(&H2260), other)
         End If      
      Next        
   End Sub
End Module
' The example displays the following output:
'       File ≠ file
'       File = File
'       File ≠ FILE
'       File ≠ Fıle

Comentários

Este método executa uma comparação ordinal (diferencia maiúsculas de minúsculas e insensível à cultura).

Confira também

CompareOrdinal(String, String)

Aplica-se a

Equals(String, String)

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Determina se dois objetos String especificados têm o mesmo valor.

public:
 static bool Equals(System::String ^ a, System::String ^ b);

public static bool Equals (string a, string b);

public static bool Equals (string? a, string? b);

static member Equals : string * string -> bool

Public Shared Function Equals (a As String, b As String) As Boolean

Parâmetros

a: String

A primeira cadeia de caracteres a ser comparada ou null.

b: String

A segunda cadeia de caracteres a ser comparada ou null.

Retornos

Boolean

true se o valor de a for o mesmo que o valor de b; caso contrário, false. Se tanto a quanto b forem null, o método retornará true.

Exemplos

O exemplo a seguir demonstra o Equals método.

// Sample for String::Equals(Object)
//            String::Equals(String)
//            String::Equals(String, String)
using namespace System;
using namespace System::Text;
int main()
{
   StringBuilder^ sb = gcnew StringBuilder( "abcd" );
   String^ str1 = "abcd";
   String^ str2 = nullptr;
   Object^ o2 = nullptr;
   Console::WriteLine();
   Console::WriteLine( " *  The value of String str1 is '{0}'.", str1 );
   Console::WriteLine( " *  The value of StringBuilder sb is '{0}'.", sb );
   Console::WriteLine();
   Console::WriteLine( "1a) String::Equals(Object). Object is a StringBuilder, not a String." );
   Console::WriteLine( "    Is str1 equal to sb?: {0}", str1->Equals( sb ) );
   Console::WriteLine();
   Console::WriteLine( "1b) String::Equals(Object). Object is a String." );
   str2 = sb->ToString();
   o2 = str2;
   Console::WriteLine( " *  The value of Object o2 is '{0}'.", o2 );
   Console::WriteLine( "    Is str1 equal to o2?: {0}", str1->Equals( o2 ) );
   Console::WriteLine();
   Console::WriteLine( " 2) String::Equals(String)" );
   Console::WriteLine( " *  The value of String str2 is '{0}'.", str2 );
   Console::WriteLine( "    Is str1 equal to str2?: {0}", str1->Equals( str2 ) );
   Console::WriteLine();
   Console::WriteLine( " 3) String::Equals(String, String)" );
   Console::WriteLine( "    Is str1 equal to str2?: {0}", String::Equals( str1, str2 ) );
}

/*
This example produces the following results:

 *  The value of String str1 is 'abcd'.
 *  The value of StringBuilder sb is 'abcd'.

1a) String::Equals(Object). Object is a StringBuilder, not a String.
    Is str1 equal to sb?: False

1b) String::Equals(Object). Object is a String.
 *  The value of Object o2 is 'abcd'.
    Is str1 equal to o2?: True

 2) String::Equals(String)
 *  The value of String str2 is 'abcd'.
    Is str1 equal to str2?: True

 3) String::Equals(String, String)
    Is str1 equal to str2?: True
*/

// Sample for String.Equals(Object)
//            String.Equals(String)
//            String.Equals(String, String)
using System;
using System.Text;

class Sample1
{
    public static void Main()
    {
        StringBuilder sb = new StringBuilder("abcd");
        String str1 = "abcd";
        String str2 = null;
        Object o2 = null;

        Console.WriteLine();
        Console.WriteLine(" *  The value of String str1 is '{0}'.", str1);
        Console.WriteLine(" *  The value of StringBuilder sb is '{0}'.", sb.ToString());

        Console.WriteLine();
        Console.WriteLine("1a) String.Equals(Object). Object is a StringBuilder, not a String.");
        Console.WriteLine("    Is str1 equal to sb?: {0}", str1.Equals(sb));

        Console.WriteLine();
        Console.WriteLine("1b) String.Equals(Object). Object is a String.");
        str2 = sb.ToString();
        o2 = str2;
        Console.WriteLine(" *  The value of Object o2 is '{0}'.", o2);
        Console.WriteLine("    Is str1 equal to o2?: {0}", str1.Equals(o2));

        Console.WriteLine();
        Console.WriteLine(" 2) String.Equals(String)");
        Console.WriteLine(" *  The value of String str2 is '{0}'.", str2);
        Console.WriteLine("    Is str1 equal to str2?: {0}", str1.Equals(str2));

        Console.WriteLine();
        Console.WriteLine(" 3) String.Equals(String, String)");
        Console.WriteLine("    Is str1 equal to str2?: {0}", String.Equals(str1, str2));
    }
}
/*
This example produces the following results:

 *  The value of String str1 is 'abcd'.
 *  The value of StringBuilder sb is 'abcd'.

1a) String.Equals(Object). Object is a StringBuilder, not a String.
    Is str1 equal to sb?: False

1b) String.Equals(Object). Object is a String.
 *  The value of Object o2 is 'abcd'.
    Is str1 equal to o2?: True

 2) String.Equals(String)
 *  The value of String str2 is 'abcd'.
    Is str1 equal to str2?: True

 3) String.Equals(String, String)
    Is str1 equal to str2?: True
*/

// Sample for String.Equals(Object)
//            String.Equals(String)
//            String.Equals(String, String)
open System
open System.Text

let sb = StringBuilder "abcd"
let str1 = "abcd"
let str2 = string sb
let o2: obj = str2

printfn $"""
*  The value of String str1 is '{str1}'.
*  The value of StringBuilder sb is '{sb}'.

1a) String.Equals(Object). Object is a StringBuilder, not a String.
Is str1 equal to sb?: {str1.Equals sb}"

1b) String.Equals(Object). Object is a String.
*  The value of Object o2 is '{o2}'.
Is str1 equal to o2?: {str1.Equals o2}

2) String.Equals(String)
*  The value of String str2 is '{str2}'.
Is str1 equal to str2?: {str1.Equals str2}

3) String.Equals(String, String)
Is str1 equal to str2?: {String.Equals(str1, str2)}"""
(*
This example produces the following results:

 *  The value of String str1 is 'abcd'.
 *  The value of StringBuilder sb is 'abcd'.

1a) String.Equals(Object). Object is a StringBuilder, not a String.
    Is str1 equal to sb?: False

1b) String.Equals(Object). Object is a String.
 *  The value of Object o2 is 'abcd'.
    Is str1 equal to o2?: True

 2) String.Equals(String)
 *  The value of String str2 is 'abcd'.
    Is str1 equal to str2?: True

 3) String.Equals(String, String)
    Is str1 equal to str2?: True
*)

' Sample for String.Equals(Object)
'            String.Equals(String)
'            String.Equals(String, String)
Imports System.Text

Class Sample
   Public Shared Sub Main()
      Dim sb As New StringBuilder("abcd")
      Dim str1 As [String] = "abcd"
      Dim str2 As [String] = Nothing
      Dim o2 As [Object] = Nothing
      
      Console.WriteLine()
      Console.WriteLine(" *  The value of String str1 is '{0}'.", str1)
      Console.WriteLine(" *  The value of StringBuilder sb is '{0}'.", sb.ToString())
      
      Console.WriteLine()
      Console.WriteLine("1a) String.Equals(Object). Object is a StringBuilder, not a String.")
      Console.WriteLine("    Is str1 equal to sb?: {0}", str1.Equals(sb))
      
      Console.WriteLine()
      Console.WriteLine("1b) String.Equals(Object). Object is a String.")
      str2 = sb.ToString()
      o2 = str2
      Console.WriteLine(" *  The value of Object o2 is '{0}'.", o2)
      Console.WriteLine("    Is str1 equal to o2?: {0}", str1.Equals(o2))
      
      Console.WriteLine()
      Console.WriteLine(" 2) String.Equals(String)")
      Console.WriteLine(" *  The value of String str2 is '{0}'.", str2)
      Console.WriteLine("    Is str1 equal to str2?: {0}", str1.Equals(str2))
      
      Console.WriteLine()
      Console.WriteLine(" 3) String.Equals(String, String)")
      Console.WriteLine("    Is str1 equal to str2?: {0}", [String].Equals(str1, str2))
   End Sub
End Class
'
'This example produces the following results:
'
' *  The value of String str1 is 'abcd'.
' *  The value of StringBuilder sb is 'abcd'.
'
'1a) String.Equals(Object). Object is a StringBuilder, not a String.
'    Is str1 equal to sb?: False
'
'1b) String.Equals(Object). Object is a String.
' *  The value of Object o2 is 'abcd'.
'    Is str1 equal to o2?: True
'
' 2) String.Equals(String)
' *  The value of String str2 is 'abcd'.
'    Is str1 equal to str2?: True
'
' 3) String.Equals(String, String)
'    Is str1 equal to str2?: True
'

Comentários

Este método executa uma comparação ordinal (diferencia maiúsculas de minúsculas e insensível à cultura).

Confira também

CompareOrdinal(String, String)

Aplica-se a

Equals(String, StringComparison)

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Determina se essa cadeia de caracteres e um objeto String especificado têm o mesmo valor. Um parâmetro especifica a cultura, as maiúsculas e minúsculas e as regras de classificação usadas na comparação.

public:
 bool Equals(System::String ^ value, StringComparison comparisonType);

public bool Equals (string value, StringComparison comparisonType);

public bool Equals (string? value, StringComparison comparisonType);

override this.Equals : string * StringComparison -> bool

Public Function Equals (value As String, comparisonType As StringComparison) As Boolean

Parâmetros

value: String

A cadeia de caracteres a ser comparada com esta instância.

comparisonType: StringComparison

Um dos valores de enumeração que especifica como as cadeias de caracteres serão comparadas.

Retornos

Boolean

true se o valor do parâmetro value for igual a essa cadeia de caracteres; caso contrário, false.

Exceções

ArgumentException

comparisonType não é um valor StringComparison.

Exemplos

O exemplo a seguir cria uma matriz de cadeia de caracteres que consiste em um "I" maiúsculo, um "i" minúsculo e um "ı" sem ponto. Em seguida, ele chama o Equals(String, StringComparison) método para compará-los usando cada valor de enumeração possível StringComparison .

using System;

class Sample 
{
   public static void Main() 
   {
      // Define a string array with the following three "I" characters:
      //      U+0069, U+0131, and U+0049.  
      string[] threeIs = { "i", "ı", "I" };
      // Define Type object representing StringComparison type.
      Type scType = typeof(StringComparison);  
      
      // Show the current culture (for culture-sensitive string comparisons).
      Console.WriteLine("The current culture is {0}.\n", 
                        System.Globalization.CultureInfo.CurrentCulture.Name);
        
      // Perform comparisons using each StringComparison member. 
      foreach (string scName in Enum.GetNames(scType))
      {
         StringComparison sc = (StringComparison) Enum.Parse(scType, scName);
         Console.WriteLine("Comparisons using {0}:", sc);
         // Compare each character in character array.
         for (int ctr = 0; ctr <= 1; ctr++)
         {
            string instanceChar = threeIs[ctr];
            for (int innerCtr = ctr + 1; innerCtr <= threeIs.GetUpperBound(0); innerCtr++)
            {
               string otherChar = threeIs[innerCtr];
               Console.WriteLine("{0} (U+{1}) = {2} (U+{3}): {4}", 
                                 instanceChar, Convert.ToInt16(Char.Parse(instanceChar)).ToString("X4"), 
                                 otherChar, Convert.ToInt16(Char.Parse(otherChar)).ToString("X4"), 
                                 instanceChar.Equals(otherChar, sc));
            }
            Console.WriteLine();
         }
      }   
   }
}
// The example displays the following output:
//       The current culture is en-US.
//       
//       Comparisons using CurrentCulture:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using CurrentCultureIgnoreCase:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using InvariantCulture:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using InvariantCultureIgnoreCase:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using Ordinal:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using OrdinalIgnoreCase:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       ı (U+0131) = I (U+0049): False

open System
open System.Globalization

// Define a string array with the following three "I" characters:
//      U+0069, U+0131, and U+0049.  
let threeIs = [| "i"; "ı"; "I" |]
// Define Type object representing StringComparison type.
let scType = typeof<StringComparison>  

// Show the current culture (for culture-sensitive string comparisons).
printfn $"The current culture is {CultureInfo.CurrentCulture.Name}.\n"

// Perform comparisons using each StringComparison member. 
for scName in Enum.GetNames scType do
    let sc = Enum.Parse(scType, scName) :?> StringComparison
    printfn $"Comparisons using {sc}:"
    // Compare each character in character array.
    for ctr = 0 to 1 do
        let instanceChar = threeIs[ctr]
        for innerCtr = ctr + 1 to threeIs.GetUpperBound 0 do
            let otherChar = threeIs[innerCtr]
            printfn $"{instanceChar} (U+{Convert.ToInt16(Char.Parse instanceChar):X4}) = {otherChar} (U+{Convert.ToInt16(Char.Parse otherChar):X4}): {instanceChar.Equals(otherChar, sc)}"
        printfn ""
// The example displays the following output:
//       The current culture is en-US.
//       
//       Comparisons using CurrentCulture:
//       i (U+0069) = i (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       i (U+0131) = I (U+0049): False
//       
//       Comparisons using CurrentCultureIgnoreCase:
//       i (U+0069) = i (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       i (U+0131) = I (U+0049): False
//       
//       Comparisons using InvariantCulture:
//       i (U+0069) = i (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       i (U+0131) = I (U+0049): False
//       
//       Comparisons using InvariantCultureIgnoreCase:
//       i (U+0069) = i (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       i (U+0131) = I (U+0049): False
//       
//       Comparisons using Ordinal:
//       i (U+0069) = i (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       i (U+0131) = I (U+0049): False
//       
//       Comparisons using OrdinalIgnoreCase:
//       i (U+0069) = i (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       i (U+0131) = I (U+0049): False

Class Sample
   Public Shared Sub Main() 
      ' Define a string array with the following three "I" characters:
      '      U+0069, U+0131, and U+0049.  
      Dim threeIs() As String = { "i", "ı", "I" }
      ' Define Type object representing StringComparison type.
      Dim scType As Type = GetType(StringComparison)  
      
      ' Show the current culture (for culture-sensitive string comparisons).
      Console.WriteLine("The current culture is {0}." & vbCrLf, _
                        System.Globalization.CultureInfo.CurrentCulture.Name)
        
      ' Perform comparisons using each StringComparison member. 
      For Each scName As String In [Enum].GetNames(scType)
         Dim sc As StringComparison = [Enum].Parse(scType, scName)
         Console.WriteLine("Comparisons using {0}:", sc)
         ' Compare each character in character array.
         For ctr As Integer = 0 To 1
            Dim instanceChar As String = threeIs(ctr)
            For innerCtr As Integer = ctr + 1 To threeIs.GetUpperBound(0)
               Dim otherChar As STring = threeIs(innerCtr)
               Console.WriteLine("{0} (U+{1}) = {2} (U+{3}): {4}", _
                                 instanceChar, Convert.ToInt16(Char.Parse(instanceChar)).ToString("X4"), _
                                 otherChar, Convert.ToInt16(Char.Parse(otherChar)).ToString("X4"), _
                                 instanceChar.Equals(otherChar, sc))
            Next
            Console.WriteLine()
         Next
      Next              
   End Sub
End Class
' The example displays the following output:
'       The current culture is en-US.
'       
'       Comparisons using CurrentCulture:
'       i (U+0069) = i (U+0131): False
'       i (U+0069) = I (U+0049): False
'       
'       i (U+0131) = I (U+0049): False
'       
'       Comparisons using CurrentCultureIgnoreCase:
'       i (U+0069) = i (U+0131): False
'       i (U+0069) = I (U+0049): True
'       
'       i (U+0131) = I (U+0049): False
'       
'       Comparisons using InvariantCulture:
'       i (U+0069) = i (U+0131): False
'       i (U+0069) = I (U+0049): False
'       
'       i (U+0131) = I (U+0049): False
'       
'       Comparisons using InvariantCultureIgnoreCase:
'       i (U+0069) = i (U+0131): False
'       i (U+0069) = I (U+0049): True
'       
'       i (U+0131) = I (U+0049): False
'       
'       Comparisons using Ordinal:
'       i (U+0069) = i (U+0131): False
'       i (U+0069) = I (U+0049): False
'       
'       i (U+0131) = I (U+0049): False
'       
'       Comparisons using OrdinalIgnoreCase:
'       i (U+0069) = i (U+0131): False
'       i (U+0069) = I (U+0049): True
'       
'       i (U+0131) = I (U+0049): False

Comentários

O comparisonType parâmetro indica se a comparação deve usar a cultura atual ou invariável, respeitar ou ignorar o caso das duas cadeias de caracteres que estão sendo comparadas ou usar regras de classificação de palavra ou ordinal.

Confira também

CompareOrdinal(String, String)

Aplica-se a

Equals(String, String, StringComparison)

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Origem:: String.Comparison.cs

Determina se dois objetos String especificados têm o mesmo valor. Um parâmetro especifica a cultura, as maiúsculas e minúsculas e as regras de classificação usadas na comparação.

public:
 static bool Equals(System::String ^ a, System::String ^ b, StringComparison comparisonType);

public static bool Equals (string a, string b, StringComparison comparisonType);

public static bool Equals (string? a, string? b, StringComparison comparisonType);

static member Equals : string * string * StringComparison -> bool

Public Shared Function Equals (a As String, b As String, comparisonType As StringComparison) As Boolean

Parâmetros

a: String

A primeira cadeia de caracteres a ser comparada ou null.

b: String

A segunda cadeia de caracteres a ser comparada ou null.

comparisonType: StringComparison

Um dos valores de enumeração que especifica as regras para a comparação.

Retornos

Boolean

true se o valor do parâmetro a for igual ao valor do parâmetro b; caso contrário, false.

Exceções

ArgumentException

comparisonType não é um valor StringComparison.

Exemplos

O exemplo a seguir compara três conjuntos de cadeias de caracteres usando cada membro da StringComparison enumeração. As comparações usam as convenções das culturas inglesa (Estados Unidos), tailandesa (Tailândia) e turca (Turquia). Observe que as cadeias de caracteres "a" e "a-" são consideradas equivalentes na cultura "th-TH", mas não nas outras, enquanto "i" e "İ" são consideradas equivalentes na cultura "tr-TR" quando o caso é ignorado, mas não nas outras culturas.

using System;
using System.Globalization;
using System.Threading;

public class Example3
{
    public static void Main()
    {
        String[] cultureNames = { "en-US", "th-TH", "tr-TR" };
        String[] strings1 = { "a", "i", "case", };
        String[] strings2 = { "a-", "\u0130", "Case" };
        StringComparison[] comparisons = (StringComparison[])Enum.GetValues(typeof(StringComparison));

        foreach (var cultureName in cultureNames)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
            Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name);
            for (int ctr = 0; ctr <= strings1.GetUpperBound(0); ctr++)
            {
                foreach (var comparison in comparisons)
                    Console.WriteLine("   {0} = {1} ({2}): {3}", strings1[ctr],
                                      strings2[ctr], comparison,
                                      String.Equals(strings1[ctr], strings2[ctr], comparison));

                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//    Current Culture: en-US
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: th-TH
//       a = a- (CurrentCulture): True
//       a = a- (CurrentCultureIgnoreCase): True
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: tr-TR
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): True
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True

open System
open System.Globalization
open System.Threading

let cultureNames = 
    [| "en-US"; "se-SE" |]
let strings1 = 
    [| "case"; "encyclopædia" 
       "encyclopædia"; "Archæology" |]
let strings2 = 
    [| "Case"; "encyclopaedia" 
       "encyclopedia"; "ARCHÆOLOGY" |]
let comparisons = 
    Enum.GetValues typeof<StringComparison> :?> StringComparison[]

for cultureName in cultureNames do
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture cultureName
    printfn $"Current Culture: {CultureInfo.CurrentCulture.Name}"
    for i = 0 to strings1.GetUpperBound 0 do
        for comparison in comparisons do
            printfn $"   {strings1[i]} = {strings2[i]} ({comparison}): {String.Equals(strings1[i], strings2[i], comparison)}"
        printfn ""         
    printfn ""
// The example displays the following output:
//    Current Culture: en-US
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//    
//       encyclopædia = encyclopaedia (CurrentCulture): True
//       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (InvariantCulture): True
//       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (Ordinal): False
//       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
//    
//       encyclopædia = encyclopedia (CurrentCulture): False
//       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopedia (InvariantCulture): False
//       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
//       encyclopædia = encyclopedia (Ordinal): False
//       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
//    
//       Archæology = ARCHÆOLOGY (CurrentCulture): False
//       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (InvariantCulture): False
//       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (Ordinal): False
//       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
//    
//    
//    Current Culture: se-SE
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//    
//       encyclopædia = encyclopaedia (CurrentCulture): False
//       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopaedia (InvariantCulture): True
//       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (Ordinal): False
//       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
//    
//       encyclopædia = encyclopedia (CurrentCulture): False
//       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopedia (InvariantCulture): False
//       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
//       encyclopædia = encyclopedia (Ordinal): False
//       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
//    
//       Archæology = ARCHÆOLOGY (CurrentCulture): False
//       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (InvariantCulture): False
//       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (Ordinal): False
//       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True

Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "se-SE" }
      Dim strings1() As String = { "case",  "encyclopædia",  
                                   "encyclopædia", "Archæology" }
      Dim strings2() As String = { "Case", "encyclopaedia", 
                                   "encyclopedia" , "ARCHÆOLOGY" }
      Dim comparisons() As StringComparison = CType([Enum].GetValues(GetType(StringComparison)),
                                           StringComparison())
      
      For Each cultureName In cultureNames
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name)
         For ctr As Integer = 0 To strings1.GetUpperBound(0)
            For Each comparison In comparisons
               Console.WriteLine("   {0} = {1} ({2}): {3}", strings1(ctr),
                                 strings2(ctr), comparison, 
                                 String.Equals(strings1(ctr), strings2(ctr), comparison))
            Next
            Console.WriteLine()         
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    Current Culture: en-US
'       case = Case (CurrentCulture): False
'       case = Case (CurrentCultureIgnoreCase): True
'       case = Case (InvariantCulture): False
'       case = Case (InvariantCultureIgnoreCase): True
'       case = Case (Ordinal): False
'       case = Case (OrdinalIgnoreCase): True
'    
'       encyclopædia = encyclopaedia (CurrentCulture): True
'       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (InvariantCulture): True
'       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (Ordinal): False
'       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
'    
'       encyclopædia = encyclopedia (CurrentCulture): False
'       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopedia (InvariantCulture): False
'       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
'       encyclopædia = encyclopedia (Ordinal): False
'       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
'    
'       Archæology = ARCHÆOLOGY (CurrentCulture): False
'       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (InvariantCulture): False
'       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (Ordinal): False
'       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
'    
'    
'    Current Culture: se-SE
'       case = Case (CurrentCulture): False
'       case = Case (CurrentCultureIgnoreCase): True
'       case = Case (InvariantCulture): False
'       case = Case (InvariantCultureIgnoreCase): True
'       case = Case (Ordinal): False
'       case = Case (OrdinalIgnoreCase): True
'    
'       encyclopædia = encyclopaedia (CurrentCulture): False
'       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopaedia (InvariantCulture): True
'       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (Ordinal): False
'       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
'    
'       encyclopædia = encyclopedia (CurrentCulture): False
'       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopedia (InvariantCulture): False
'       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
'       encyclopædia = encyclopedia (Ordinal): False
'       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
'    
'       Archæology = ARCHÆOLOGY (CurrentCulture): False
'       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (InvariantCulture): False
'       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (Ordinal): False
'       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True

Comentários

Confira também

CompareOrdinal(String, String)

Aplica-se a

String.Equals Método

Definição

Sobrecargas

Equals(Object)

Parâmetros

Retornos

Exemplos

Comentários

Confira também

Aplica-se a

Equals(String)

Parâmetros

Retornos

Implementações

Exemplos

Comentários

Confira também

Aplica-se a

Equals(String, String)

Parâmetros

Retornos

Exemplos

Comentários

Confira também

Aplica-se a

Equals(String, StringComparison)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Equals(String, String, StringComparison)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Comentários

Recursos adicionais