String.EndsWith Metodo

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Determina se la fine di questa istanza di stringa corrisponde a una stringa specificata.

Overload

EndsWith(String, Boolean, CultureInfo)	Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante le impostazioni cultura specificate.
EndsWith(String, StringComparison)	Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante l'opzione di confronto specificata.
EndsWith(Char)	Determina se la fine di questa istanza di stringa corrisponde al carattere specificato.
EndsWith(String)	Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata.

EndsWith(String, Boolean, CultureInfo)

Origine:

String.Comparison.cs

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante le impostazioni cultura specificate.

C#

public bool EndsWith (string value, bool ignoreCase, System.Globalization.CultureInfo? culture);

Parametri

value

String

Stringa da confrontare con la sottostringa alla fine di questa istanza.

ignoreCase

Boolean

true per ignorare la distinzione tra maiuscole e minuscole durante il confronto; in caso contrario, false.

culture

CultureInfo

Informazioni relative alle impostazioni cultura che determinano le modalità di confronto fra questa istanza e il parametro value. Se culture è null, verranno usate le impostazioni cultura correnti.

Restituisce

Boolean

true se il parametro value corrisponde alla fine di questa stringa; in caso contrario, false.

Eccezioni

ArgumentNullException

value è null.

Esempio

Nell'esempio seguente viene determinato se una stringa si verifica alla fine di un'altra stringa. Il EndsWith metodo viene chiamato più volte usando la distinzione tra maiuscole e minuscole e culture diverse che influiscono sui risultati della ricerca.

C#

// This code example demonstrates the 
// System.String.EndsWith(String, ..., CultureInfo) method.

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

class Sample 
{
    public static void Main() 
    {
        string msg1 = "Search for the target string \"{0}\" in the string \"{1}\".\n";
        string msg2 = "Using the {0} - \"{1}\" culture:";
        string msg3 = "  The string to search ends with the target string: {0}";
        bool result = false;
        CultureInfo ci;

        // Define a target string to search for.
        // U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        string capitalARing = "\u00c5";

        // Define a string to search. 
        // The result of combining the characters LATIN SMALL LETTER A and COMBINING 
        // RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
        // LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
        string xyzARing = "xyz" + "\u0061\u030a";

        // Display the string to search for and the string to search.
        Console.WriteLine(msg1, capitalARing, xyzARing);

        // Search using English-United States culture.
        ci = new CultureInfo("en-US");
        Console.WriteLine(msg2, ci.DisplayName, ci.Name);

        Console.WriteLine("Case sensitive:");
        result = xyzARing.EndsWith(capitalARing, false, ci);
        Console.WriteLine(msg3, result);

        Console.WriteLine("Case insensitive:");
        result = xyzARing.EndsWith(capitalARing, true, ci);
        Console.WriteLine(msg3, result);
        Console.WriteLine();

        // Search using Swedish-Sweden culture.
        ci = new CultureInfo("sv-SE");
        Console.WriteLine(msg2, ci.DisplayName, ci.Name);

        Console.WriteLine("Case sensitive:");
        result = xyzARing.EndsWith(capitalARing, false, ci);
        Console.WriteLine(msg3, result);

        Console.WriteLine("Case insensitive:");
        result = xyzARing.EndsWith(capitalARing, true, ci);
        Console.WriteLine(msg3, result);
    }
}

/*
This code example produces the following results (for en-us culture):

Search for the target string "Å" in the string "xyza°".

Using the English (United States) - "en-US" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: True

Using the Swedish (Sweden) - "sv-SE" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: False

*/

Commenti

Questo metodo confronta il value parametro con la sottostringa alla fine di questa stringa che corrisponde alla stessa lunghezza valuedi e restituisce un valore che indica se sono uguali. Per essere uguale, value deve essere un riferimento a questa stessa istanza o corrispondere alla fine di questa stringa.

Questo metodo esegue un confronto tra parole (sensibili alle impostazioni cultura) usando le maiuscole e le impostazioni cultura specificate.

Vedi anche

• InvariantCulture

EndsWith(String, StringComparison)

Origine:

String.Comparison.cs

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante l'opzione di confronto specificata.

C#

public bool EndsWith (string value, StringComparison comparisonType);

Parametri

value

String

Stringa da confrontare con la sottostringa alla fine di questa istanza.

comparisonType

StringComparison

Uno dei valori di enumerazione che determina la modalità di confronto fra questa stringa e value.

Restituisce

Boolean

true se il parametro value corrisponde alla fine di questa stringa; in caso contrario, false.

Eccezioni

ArgumentNullException

value è null.

ArgumentException

comparisonType non è un valore di StringComparison.

Esempio

Nell'esempio seguente viene determinato se una stringa termina con una determinata sottostringa. I risultati sono interessati dalla scelta delle impostazioni cultura, se il caso viene ignorato e se viene eseguito un confronto ordinale.

C#

// This example demonstrates the 
// System.String.EndsWith(String, StringComparison) method.

using System;
using System.Threading;

class Sample 
{
    public static void Main() 
    {
        string intro = "Determine whether a string ends with another string, " +
                   "using\n  different values of StringComparison.";

        StringComparison[] scValues = {
            StringComparison.CurrentCulture,
            StringComparison.CurrentCultureIgnoreCase,
            StringComparison.InvariantCulture,
            StringComparison.InvariantCultureIgnoreCase,
            StringComparison.Ordinal,
            StringComparison.OrdinalIgnoreCase };

        Console.WriteLine(intro);

        // Display the current culture because the culture-specific comparisons
        // can produce different results with different cultures.
        Console.WriteLine("The current culture is {0}.\n", 
                       Thread.CurrentThread.CurrentCulture.Name);
        
        // Determine whether three versions of the letter I are equal to each other. 
        foreach (StringComparison sc in scValues)
        {
            Console.WriteLine("StringComparison.{0}:", sc);
            Test("abcXYZ", "XYZ", sc);
            Test("abcXYZ", "xyz", sc);
            Console.WriteLine();
        }
    }

    protected static void Test(string x, string y, StringComparison comparison)
    {
        string resultFmt = "\"{0}\" {1} with \"{2}\".";
        string result = "does not end";

        if (x.EndsWith(y, comparison))
            result = "ends";
        Console.WriteLine(resultFmt, x, result, y);
    }
}

/*
This code example produces the following results:

Determine whether a string ends with another string, using
  different values of StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.CurrentCultureIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

StringComparison.InvariantCulture:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.InvariantCultureIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

StringComparison.Ordinal:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.OrdinalIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

*/

Commenti

Il EndsWith metodo confronta il value parametro con la sottostringa alla fine di questa stringa e restituisce un valore che indica se sono uguali. Per essere uguale, value deve essere un riferimento a questa stessa stringa, deve essere la stringa vuota ("") o deve corrispondere alla fine di questa stringa. Il tipo di confronto eseguito dal metodo dipende dal EndsWith valore del comparisonType parametro.

Vedi anche

• StringComparison

EndsWith(Char)

Origine:

String.Comparison.cs

Determina se la fine di questa istanza di stringa corrisponde al carattere specificato.

C#

public bool EndsWith (char value);

Parametri

value

Char

Carattere da confrontare con il carattere alla fine di questa istanza.

Restituisce

Boolean

true se value corrisponde alla fine di questa istanza; in caso contrario, false.

Commenti

Questo metodo esegue un confronto ordinale (distinzione tra maiuscole e minuscole e cultura-insensibili).

EndsWith(String)

Origine:

String.Comparison.cs

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata.

C#

public bool EndsWith (string value);

Parametri

value

String

Stringa da confrontare con la sottostringa alla fine di questa istanza.

Restituisce

Boolean

true se value corrisponde alla fine di questa istanza; in caso contrario, false.

Eccezioni

ArgumentNullException

value è null.

Esempio

L'esempio seguente indica se ogni stringa in una matrice termina con un punto (".").

C#

using System;

public class Example
{
   public static void Main()
   {
      String[] strings = { "This is a string.", "Hello!", "Nothing.", 
                           "Yes.", "randomize" };
      foreach (var value in strings) {
         bool endsInPeriod = value.EndsWith(".");
         Console.WriteLine("'{0}' ends in a period: {1}", 
                           value, endsInPeriod);
      }                            
   }
}
// The example displays the following output:
//       'This is a string.' ends in a period: True
//       'Hello!' ends in a period: False
//       'Nothing.' ends in a period: True
//       'Yes.' ends in a period: True
//       'randomize' ends in a period: False

Nell'esempio seguente viene definito un StripEndTags metodo che usa il EndsWith(String) metodo per rimuovere i tag finali HTML dalla fine di una riga. Si noti che il StripEndTags metodo viene chiamato ricorsivamente per assicurarsi che più tag finali HTML alla fine della riga vengano rimossi.

C#

using System;

public class EndsWithTest {
    public static void Main() {

        // process an input file that contains html tags.
        // this sample checks for multiple tags at the end of the line, rather than simply
        // removing the last one.
        // note: HTML markup tags always end in a greater than symbol (>).

        string [] strSource = { "<b>This is bold text</b>", "<H1>This is large Text</H1>",
                "<b><i><font color=green>This has multiple tags</font></i></b>",
                "<b>This has <i>embedded</i> tags.</b>",
                "This line simply ends with a greater than symbol, it should not be modified>" };

        Console.WriteLine("The following lists the items before the ends have been stripped:");
        Console.WriteLine("-----------------------------------------------------------------");

        // print out the initial array of strings
        foreach ( string s in strSource )
            Console.WriteLine( s );

        Console.WriteLine();

        Console.WriteLine("The following lists the items after the ends have been stripped:");
        Console.WriteLine("----------------------------------------------------------------");

        // print out the array of strings
        foreach (var s in strSource)
            Console.WriteLine(StripEndTags(s));
    }

    private static string StripEndTags( string item ) {

        bool found = false;

        // try to find a tag at the end of the line using EndsWith
        if (item.Trim().EndsWith(">")) {

            // now search for the opening tag...
            int lastLocation = item.LastIndexOf( "</" );

            // remove the identified section, if it is a valid region
            if ( lastLocation >= 0 ) {
                found = true;
                item =  item.Substring( 0, lastLocation );
            }
        }

        if (found)
           item = StripEndTags(item);

        return item;
    }
}
// The example displays the following output:
//    The following lists the items before the ends have been stripped:
//    -----------------------------------------------------------------
//    <b>This is bold text</b>
//    <H1>This is large Text</H1>
//    <b><i><font color=green>This has multiple tags</font></i></b>
//    <b>This has <i>embedded</i> tags.</b>
//    This line simply ends with a greater than symbol, it should not be modified>
//
//    The following lists the items after the ends have been stripped:
//    ----------------------------------------------------------------
//    <b>This is bold text
//    <H1>This is large Text
//    <b><i><font color=green>This has multiple tags
//    <b>This has <i>embedded</i> tags.
//    This line simply ends with a greater than symbol, it should not be modified>

Commenti

Questo metodo confronta value la sottostringa alla fine di questa istanza che corrisponde alla stessa lunghezza di valuee restituisce un'indicazione se sono uguali. Per essere uguale, value deve essere un riferimento a questa stessa istanza o corrisponde alla fine di questa istanza.

Questo metodo esegue un confronto tra maiuscole e minuscole e sensibili alle impostazioni cultura usando le impostazioni cultura correnti.

Note per i chiamanti

Come illustrato in Procedure consigliate per l'uso di stringhe, è consigliabile evitare di chiamare metodi di confronto stringa che sostituisci i valori predefiniti e chiamare i metodi che richiedono parametri da specificare in modo esplicito. Per determinare se una stringa termina con una determinata sottostringa usando le regole di confronto stringa delle impostazioni cultura correnti, segnalare in modo esplicito l'intenzione chiamando l'overload del metodo con un valore di CurrentCulture per il EndsWith(String, StringComparison) relativo comparisonType parametro. Se non è necessario un confronto con riconoscimento linguistico, prendere in considerazione l'uso di Ordinal.

Vedi anche

• StartsWith(String)
• Compare(String, String)