String.Equals Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Bestimmt, ob zwei String Objekte denselben Wert aufweisen.

Überlädt

Equals(Object)	Bestimmt, ob diese Instanz und ein angegebenes Objekt, das auch ein String -Objekt sein muss, denselben Wert aufweisen.
Equals(String)	Bestimmt, ob diese Instanz und ein anderes angegebenes String -Objekt denselben Wert aufweisen.
Equals(String, String)	Bestimmt, ob zwei angegebene String Objekte denselben Wert aufweisen.
Equals(String, StringComparison)	Bestimmt, ob diese Zeichenfolge und ein angegebenes String -Objekt denselben Wert aufweisen. Ein Parameter gibt die Kultur-, Fall- und Sortierregeln an, die im Vergleich verwendet werden.
Equals(String, String, StringComparison)	Bestimmt, ob zwei angegebene String Objekte denselben Wert aufweisen. Ein Parameter gibt die Kultur-, Fall- und Sortierregeln an, die im Vergleich verwendet werden.

Equals(Object)

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Bestimmt, ob diese Instanz und ein angegebenes Objekt, das auch ein String -Objekt sein muss, denselben Wert aufweisen.

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

Parameter

obj: Object

Die Zeichenfolge, die mit dieser Instanz verglichen werden soll.

Gibt zurück

Boolean

true, wenn obj ein String ist und sein Wert mit dieser Instanz identisch ist; andernfalls false. Wenn objnullist, gibt die Methode falsezurück.

Beispiele

Im folgenden Beispiel wird die Equals-Methode veranschaulicht.

// 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
'

Hinweise

Diese Methode führt einen Ordinalvergleich (Groß-/Kleinschreibung und Kultur-Insensitive) durch.

Weitere Informationen

Gilt für:

Equals(String)

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Bestimmt, ob diese Instanz und ein anderes angegebenes String -Objekt denselben Wert aufweisen.

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

Parameter

value: String

Die Zeichenfolge, die mit dieser Instanz verglichen werden soll.

Gibt zurück

Boolean

true, wenn der Wert des value Parameters mit dem Wert dieser Instanz identisch ist; andernfalls false. Wenn valuenullist, gibt die Methode falsezurück.

Implementiert

Equals(T)

Beispiele

Im folgenden Beispiel wird die Equals-Methode veranschaulicht. Es vergleicht das titelgeschriebene Wort "Datei" mit einem entsprechenden Wort, dessen Kleinbuchstabe, dessen Großbuchstabenentsprechung und einem Wort, das LATIN SMALL LETTER DOTLESS I (U+0131) anstelle von LATIN SMALL LETTER I (U+0069) enthält. Da die Equals(String)-Methode einen Ordinalvergleich durchführt, gibt nur der Vergleich mit einem identischen Wort truezurück.

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

Hinweise

Diese Methode führt einen Ordinalvergleich (Groß-/Kleinschreibung und Kultur-Insensitive) durch.

Weitere Informationen

CompareOrdinal(String, String)

Gilt für:

Equals(String, String)

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Bestimmt, ob zwei angegebene String Objekte denselben Wert aufweisen.

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

Parameter

a: String

Die erste zu vergleichende Zeichenfolge oder null.

b: String

Die zweite zu vergleichende Zeichenfolge oder null.

Gibt zurück

Boolean

true, wenn der Wert von a mit dem Wert von bidentisch ist; andernfalls false. Wenn sowohl a als auch bnullsind, gibt die Methode truezurück.

Beispiele

Im folgenden Beispiel wird die Equals-Methode veranschaulicht.

// 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
'

Hinweise

Diese Methode führt einen Ordinalvergleich (Groß-/Kleinschreibung und Kultur-Insensitive) durch.

Weitere Informationen

CompareOrdinal(String, String)

Gilt für:

Equals(String, StringComparison)

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Bestimmt, ob diese Zeichenfolge und ein angegebenes String -Objekt denselben Wert aufweisen. Ein Parameter gibt die Kultur-, Fall- und Sortierregeln an, die im Vergleich verwendet werden.

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

Parameter

value: String

Die Zeichenfolge, die mit dieser Instanz verglichen werden soll.

comparisonType: StringComparison

Einer der Enumerationswerte, die angibt, wie die Zeichenfolgen verglichen werden.

Gibt zurück

Boolean

true, wenn der Wert des value Parameters mit dieser Zeichenfolge identisch ist; andernfalls false.

Ausnahmen

ArgumentException

comparisonType ist kein StringComparison Wert.

Beispiele

Im folgenden Beispiel wird ein Zeichenfolgenarray erstellt, das aus einem Großbuchstaben "I", einem Kleinbuchstaben "i" und einem punktlosen "ı" besteht. Anschließend wird die Equals(String, StringComparison) Methode aufgerufen, um sie mithilfe der einzelnen möglichen StringComparison Enumerationswert zu vergleichen.

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

Hinweise

Der parameter comparisonType gibt an, ob der Vergleich die aktuelle oder invariante Kultur verwenden soll, die Groß- oder Kleinschreibung der beiden zu vergleichenden Zeichenfolgen berücksichtigt oder Wort- oder Ordnungssortierregeln verwendet werden soll.

Weitere Informationen

CompareOrdinal(String, String)

Gilt für:

Equals(String, String, StringComparison)

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Quelle:: String.Comparison.cs

Bestimmt, ob zwei angegebene String Objekte denselben Wert aufweisen. Ein Parameter gibt die Kultur-, Fall- und Sortierregeln an, die im Vergleich verwendet werden.

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

Parameter

a: String

Die erste zu vergleichende Zeichenfolge oder null.

b: String

Die zweite zu vergleichende Zeichenfolge oder null.

comparisonType: StringComparison

Einer der Enumerationswerte, die die Regeln für den Vergleich angibt.

Gibt zurück

Boolean

true, wenn der Wert des a Parameters dem Wert des b Parameters entspricht; andernfalls false.

Ausnahmen

ArgumentException

comparisonType ist kein StringComparison Wert.

Beispiele

Im folgenden Beispiel werden drei Zeichenfolgensätze verglichen, indem jedes Element der StringComparison-Aufzählung verwendet wird. Die Vergleiche verwenden die Konventionen der Kulturen Englisch (USA), Thai (Thailand) und Türkisch (Türkei). Beachten Sie, dass die Zeichenfolgen "a" und "a-" in der "th-TH" Kultur, aber nicht in den anderen, während "i" und "İ" in der "tr-TR" Kultur als gleichwertig betrachtet werden, wenn der Fall ignoriert wird, aber nicht in den anderen Kulturen.

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

Hinweise

Weitere Informationen

CompareOrdinal(String, String)

Gilt für:

Freigeben über

String.Equals Methode

Definition

Überlädt

Equals(Object)

Parameter

Gibt zurück

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Equals(String)

Parameter

Gibt zurück

Implementiert

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Equals(String, String)

Parameter

Gibt zurück

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Equals(String, StringComparison)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Equals(String, String, StringComparison)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen