String.StartsWith Método

Definición

Espacio de nombres:: System

Ensamblados:: netstandard.dll, System.Runtime.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: netstandard.dll

Ensamblados:: mscorlib.dll, System.Runtime.dll

Ensamblado:: mscorlib.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Sobrecargas

Nombre	Description
StartsWith(Char)	Determina si esta instancia de cadena comienza con el carácter especificado.
StartsWith(String)	Determina si el principio de esta instancia de cadena coincide con la cadena especificada.
StartsWith(Rune)
StartsWith(Char, StringComparison)
StartsWith(String, StringComparison)	Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se compara con la opción de comparación especificada.
StartsWith(Rune, StringComparison)
StartsWith(String, Boolean, CultureInfo)	Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se compara con la referencia cultural especificada.

StartsWith(Char)

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Determina si esta instancia de cadena comienza con el carácter especificado.

public:
 bool StartsWith(char value);

public bool StartsWith(char value);

member this.StartsWith : char -> bool

Public Function StartsWith (value As Char) As Boolean

Parámetros

value: Char

Carácter que se va a comparar.

Devoluciones

Boolean

true es si value coincide con el principio de esta cadena; en caso contrario, falsees .

Comentarios

Este método realiza una comparación ordinal (sin distinción entre mayúsculas y minúsculas y sin distinción entre referencias culturales).

Se aplica a

StartsWith(String)

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Determina si el principio de esta instancia de cadena coincide con la cadena especificada.

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

public bool StartsWith(string value);

member this.StartsWith : string -> bool

Public Function StartsWith (value As String) As Boolean

Parámetros

value: String

Cadena que se va a comparar.

Devoluciones

Boolean

true es si value coincide con el principio de esta cadena; en caso contrario, falsees .

Excepciones

ArgumentNullException

value es null.

Ejemplos

En el ejemplo siguiente se define un StripStartTags método que usa el StartsWith(String) método para quitar etiquetas de inicio HTML desde el principio de una cadena. Tenga en cuenta que el StripStartTags método se llama de forma recursiva para asegurarse de que se quitan varias etiquetas de inicio HTML al principio de la línea. En el ejemplo no se quitan las etiquetas HTML incrustadas en una cadena.

using System;

public class Example
{
   public static void Main() {
      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 begins with a lesser than symbol, it should not be modified" };

      // Display the initial string array.
      Console.WriteLine("The original strings:");
      Console.WriteLine("---------------------");
      foreach (var s in strSource)
         Console.WriteLine(s);
      Console.WriteLine();

      Console.WriteLine("Strings after starting tags have been stripped:");
      Console.WriteLine("-----------------------------------------------");

      // Display the strings with starting tags removed.
     foreach (var s in strSource)
        Console.WriteLine(StripStartTags(s));
   }

   private static string StripStartTags(string item)
   {
      // Determine whether a tag begins the string.
      if (item.Trim().StartsWith("<")) {
         // Find the closing tag.
         int lastLocation = item.IndexOf( ">" );
         // Remove the tag.
         if (lastLocation >= 0) {
            item =  item.Substring( lastLocation + 1 );

            // Remove any additional starting tags.
            item = StripStartTags(item);
         }
      }

      return item;
   }
}
// The example displays the following output:
//    The original strings:
//    ---------------------
//    <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 begins with a lesser than symbol, it should not be modified
//
//    Strings after starting tags have been stripped:
//    -----------------------------------------------
//    This is bold text</b>
//    This is large Text</H1>
//    This has multiple tags</font></i></b>
//    This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified

let rec stripStartTags (item: string) =
    // Determine whether a tag begins the string.
    if item.Trim().StartsWith "<" then
        // Find the closing tag.
        let lastLocation = item.IndexOf ">"
        // Remove the tag.
        let item = 
            if lastLocation >= 0 then
                item.Substring( lastLocation + 1 )
            else 
                item

        // Remove any additional starting tags.
        stripStartTags item
    else
        item

let 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 begins with a lesser than symbol, it should not be modified" |]

// Display the initial string array.
printfn "The original strings:"
printfn "---------------------"
for s in strSource do
    printfn $"{s}"
printfn ""

printfn "Strings after starting tags have been stripped:"
printfn "-----------------------------------------------"

// Display the strings with starting tags removed.
for s in strSource do
    printfn $"{stripStartTags s}"

// The example displays the following output:
//    The original strings:
//    ---------------------
//    <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 begins with a lesser than symbol, it should not be modified
//
//    Strings after starting tags have been stripped:
//    -----------------------------------------------
//    This is bold text</b>
//    This is large Text</H1>
//    This has multiple tags</font></i></b>
//    This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified

Public Class Example
   Public Shared Sub Main()
      Dim strSource() As String = { "<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 begins with a lesser than symbol, it should not be modified" }

      ' Display the initial string array.
      Console.WriteLine("The original strings:")
      Console.WriteLine("---------------------")
      For Each s In strSource
         Console.WriteLine(s)
      Next 
      Console.WriteLine()

      Console.WriteLine("Strings after starting tags have been stripped:")
      Console.WriteLine("-----------------------------------------------") 

      ' Display the strings with starting tags removed.
      For Each s In strSource
         Console.WriteLine(StripStartTags(s))
      Next 
   End Sub 

   Private Shared Function StripStartTags(item As String) As String
      ' Determine whether a tag begins the string.
      If item.Trim().StartsWith("<") Then
         ' Find the closing tag.
         Dim lastLocation As Integer = item.IndexOf(">")
         If lastLocation >= 0 Then
            ' Remove the tag.
            item = item.Substring((lastLocation + 1))
            
            ' Remove any additional starting tags.
            item = StripStartTags(item)
         End If
      End If
      
      Return item
   End Function 
End Class 
' The example displays the following output:
'    The original strings:
'    ---------------------
'    <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 begins with a lesser than symbol, it should not be modified
'    
'    Strings after starting tags have been stripped:
'    -----------------------------------------------
'    This is bold text</b>
'    This is large Text</H1>
'    This has multiple tags</font></i></b>
'    This has <i>embedded</i> tags.</b>
'    <This line simply begins with a lesser than symbol, it should not be modified

Comentarios

Este método se value compara con la subcadena al principio de esta instancia que tiene la misma longitud valueque y devuelve una indicación de si son iguales. Para ser igual, value debe ser una cadena vacía (String.Empty), debe ser una referencia a esta misma instancia o debe coincidir con el principio de esta instancia.

Este método realiza una comparación de palabras (con distinción entre mayúsculas y minúsculas y con distinción entre referencias culturales) mediante la referencia cultural actual.

Notas a los autores de las llamadas

Como se explica en Procedimientos recomendados para usar cadenas, se recomienda evitar llamar a métodos de comparación de cadenas que sustituya los valores predeterminados y, en su lugar, llame a métodos que requieren que se especifiquen explícitamente los parámetros. Para determinar si una cadena comienza con una subcadena determinada mediante las reglas de comparación de cadenas de la referencia cultural actual, indique su intención explícitamente llamando a la sobrecarga del StartsWith(String, StringComparison) método con un valor de CurrentCulture para su comparisonType parámetro. Si no necesita una comparación con reconocimiento lingüístico, considere la posibilidad de usar Ordinal.

Consulte también

EndsWith(String)

Se aplica a

StartsWith(Rune)

Source:: String.Comparison.cs

public:
 bool StartsWith(System::Text::Rune value);

public bool StartsWith(System.Text.Rune value);

member this.StartsWith : System.Text.Rune -> bool

Public Function StartsWith (value As Rune) As Boolean

Parámetros

value: Rune

Devoluciones

Boolean

Se aplica a

StartsWith(Char, StringComparison)

Source:: String.Comparison.cs

public:
 bool StartsWith(char value, StringComparison comparisonType);

public bool StartsWith(char value, StringComparison comparisonType);

member this.StartsWith : char * StringComparison -> bool

Public Function StartsWith (value As Char, comparisonType As StringComparison) As Boolean

Parámetros

value: Char

comparisonType: StringComparison

Devoluciones

Boolean

Se aplica a

StartsWith(String, StringComparison)

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se compara con la opción de comparación especificada.

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

public bool StartsWith(string value, StringComparison comparisonType);

[System.Runtime.InteropServices.ComVisible(false)]
public bool StartsWith(string value, StringComparison comparisonType);

member this.StartsWith : string * StringComparison -> bool

[<System.Runtime.InteropServices.ComVisible(false)>]
member this.StartsWith : string * StringComparison -> bool

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

Parámetros

value: String

Cadena que se va a comparar.

comparisonType: StringComparison

Uno de los valores de enumeración que determina cómo se compara esta cadena y value .

Devoluciones

Boolean

true es si esta instancia comienza por value; de lo contrario, falsees .

Atributos: ComVisibleAttribute

Excepciones

ArgumentNullException

value es null.

ArgumentException

comparisonType no es un StringComparison valor.

Ejemplos

En el ejemplo siguiente se busca la cadena "the" al principio de una cadena más larga que comienza con la palabra "The". Como se muestra en la salida del ejemplo, se produce un error en una llamada al StartsWith(String, StringComparison) método que realiza una comparación sin distinción entre referencias culturales, pero que distingue mayúsculas de minúsculas y no coincide con la cadena, mientras que una llamada que realiza una comparación que no distingue entre mayúsculas y minúsculas coincide con la cadena.

using System;

public class Example
{
   public static void Main()
   {
      String title = "The House of the Seven Gables";
      String searchString = "the";
      StringComparison comparison = StringComparison.InvariantCulture;
      Console.WriteLine("'{0}':", title);
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison));

      comparison = StringComparison.InvariantCultureIgnoreCase;
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison));
   }
}
// The example displays the following output:
//       'The House of the Seven Gables':
//          Starts with 'the' (InvariantCulture comparison): False
//          Starts with 'the' (InvariantCultureIgnoreCase comparison): True

open System

let title = "The House of the Seven Gables"
let searchString = "the"
let comparison = StringComparison.InvariantCulture
printfn $"'{title}':"
printfn $"   Starts with '{searchString}' ({comparison:G} comparison): {title.StartsWith(searchString, comparison)}"

let comparison2 = StringComparison.InvariantCultureIgnoreCase
printfn $"   Starts with '{searchString}' ({comparison2:G} comparison): {title.StartsWith(searchString, comparison2)}"
// The example displays the following output:
//       'The House of the Seven Gables':
//          Starts with 'the' (InvariantCulture comparison): False
//          Starts with 'the' (InvariantCultureIgnoreCase comparison): True

Module Example
   Public Sub Main()
      Dim title As String = "The House of the Seven Gables"
      Dim searchString As String = "the"
      Dim comparison As StringComparison = StringComparison.InvariantCulture
      Console.WriteLine("'{0}':", title)
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison))

      comparison = StringComparison.InvariantCultureIgnoreCase
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison))
   End Sub
End Module
' The example displays the following output:
'    'The House of the Seven Gables':
'       Starts with 'the' (InvariantCulture comparison): False
'       Starts with 'the' (InvariantCultureIgnoreCase comparison): True

En el ejemplo siguiente se determina si una cadena comienza con una subcadena determinada. Inicializa una matriz de cadenas bidimensionales. El primer elemento de la segunda dimensión contiene una cadena y el segundo elemento contiene la cadena que se va a buscar al principio de la primera cadena. Los resultados se ven afectados por la elección de la referencia cultural, si se omite el caso y si se realiza una comparación ordinal. Tenga en cuenta que, cuando la instancia de cadena contiene una ligadura, las comparaciones que distinguen la referencia cultural con sus caracteres consecutivos coinciden correctamente.

using System;

public class Example
{
   public static void Main()
   {
      string[,] strings = { {"ABCdef", "abc" },                    
                            {"ABCdef", "abc" },  
                            {"œil","oe" },
                            { "læring}", "lae" } };
      for (int ctr1 = strings.GetLowerBound(0); ctr1 <= strings.GetUpperBound(0); ctr1++)
      {
            foreach (string cmpName in Enum.GetNames(typeof(StringComparison)))
            { 
               StringComparison strCmp = (StringComparison) Enum.Parse(typeof(StringComparison), 
                                                      cmpName);
               string instance = strings[ctr1, 0];
               string value = strings[ctr1, 1];
               Console.WriteLine("{0} starts with {1}: {2} ({3} comparison)", 
                                 instance, value, 
                                 instance.StartsWith(value, strCmp), 
                                 strCmp); 
            }
            Console.WriteLine();   
      }   
   }
}
// The example displays the following output:
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       œil starts with oe: True (CurrentCulture comparison)
//       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
//       œil starts with oe: True (InvariantCulture comparison)
//       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
//       œil starts with oe: False (Ordinal comparison)
//       œil starts with oe: False (OrdinalIgnoreCase comparison)
//       
//       læring} starts with lae: True (CurrentCulture comparison)
//       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
//       læring} starts with lae: True (InvariantCulture comparison)
//       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
//       læring} starts with lae: False (Ordinal comparison)
//       læring} starts with lae: False (OrdinalIgnoreCase comparison)

open System

let strings =
    array2D 
      [ [ "ABCdef"; "abc" ]
        [ "ABCdef"; "abc" ]
        [ "œil"; "oe" ]
        [ "læring}"; "lae" ] ]

for ctr1 = strings.GetLowerBound 0 to strings.GetUpperBound 0 do
    for cmpName in Enum.GetNames typeof<StringComparison> do
        let strCmp = Enum.Parse(typeof<StringComparison>, cmpName) :?> StringComparison
        let instance = strings[ctr1, 0]
        let value = strings[ctr1, 1]
        printfn $"{instance} starts with {value}: {instance.StartsWith(value, strCmp)} ({strCmp} comparison)"
    printfn ""
// The example displays the following output:
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//
//       œil starts with oe: True (CurrentCulture comparison)
//       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
//       œil starts with oe: True (InvariantCulture comparison)
//       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
//       œil starts with oe: False (Ordinal comparison)
//       œil starts with oe: False (OrdinalIgnoreCase comparison)
//
//       læring} starts with lae: True (CurrentCulture comparison)
//       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
//       læring} starts with lae: True (InvariantCulture comparison)
//       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
//       læring} starts with lae: False (Ordinal comparison)
//       læring} starts with lae: False (OrdinalIgnoreCase comparison)

Module Example
   Public Sub Main()
      Dim strings(,) As String = { {"ABCdef", "abc" },                    
                                   {"ABCdef", "abc" },  
                                   {"œil","oe" },
                                   { "læring}", "lae" } }
      For ctr1 As Integer = strings.GetLowerBound(0) To strings.GetUpperBound(0)
            For Each cmpName As String In [Enum].GetNames(GetType(StringComparison)) 
               Dim strCmp As StringComparison = CType([Enum].Parse(GetType(StringComparison), 
                                                      cmpName), StringComparison)
               Dim instance As String = strings(ctr1, 0)
               Dim value As String = strings(ctr1, 1)
               Console.WriteLine("{0} starts with {1}: {2} ({3} comparison)", 
                                 instance, value, 
                                 instance.StartsWith(value, strCmp), 
                                 strCmp) 
            Next
            Console.WriteLine()   
      Next   
   End Sub
End Module
' The example displays the following output:
'       ABCdef starts with abc: False (CurrentCulture comparison)
'       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
'       ABCdef starts with abc: False (InvariantCulture comparison)
'       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
'       ABCdef starts with abc: False (Ordinal comparison)
'       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
'       
'       ABCdef starts with abc: False (CurrentCulture comparison)
'       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
'       ABCdef starts with abc: False (InvariantCulture comparison)
'       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
'       ABCdef starts with abc: False (Ordinal comparison)
'       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
'       
'       œil starts with oe: True (CurrentCulture comparison)
'       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
'       œil starts with oe: True (InvariantCulture comparison)
'       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
'       œil starts with oe: False (Ordinal comparison)
'       œil starts with oe: False (OrdinalIgnoreCase comparison)
'       
'       læring} starts with lae: True (CurrentCulture comparison)
'       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
'       læring} starts with lae: True (InvariantCulture comparison)
'       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
'       læring} starts with lae: False (Ordinal comparison)
'       læring} starts with lae: False (OrdinalIgnoreCase comparison)

Comentarios

El StartsWith método compara el value parámetro con la subcadena al principio de esta cadena y devuelve un valor que indica si son iguales. Para ser igual, value debe ser una referencia a esta misma cadena, debe ser la cadena vacía ("") o debe coincidir con el principio de esta cadena. El tipo de comparación realizado por el StartsWith método depende del valor del comparisonType parámetro . La comparación puede usar las convenciones de la referencia cultural actual (StringComparison.CurrentCulture y StringComparison.CurrentCultureIgnoreCase) o la referencia cultural invariable (StringComparison.InvariantCulture y StringComparison.InvariantCultureIgnoreCase), o puede constar de una comparación de caracteres por carácter de puntos de código (StringComparison.Ordinal o StringComparison.OrdinalIgnoreCase). La comparación también puede distinguir entre mayúsculas y minúsculas (StringComparison.CurrentCulture, StringComparison.InvariantCultureo StringComparison.Ordinal), o puede omitir mayúsculas de minúsculas (StringComparison.CurrentCultureIgnoreCase, StringComparison.InvariantCultureIgnoreCase, StringComparison.OrdinalIgnoreCase).

Consulte también

StringComparison

Se aplica a

StartsWith(Rune, StringComparison)

Source:: String.Comparison.cs

public:
 bool StartsWith(System::Text::Rune value, StringComparison comparisonType);

public bool StartsWith(System.Text.Rune value, StringComparison comparisonType);

member this.StartsWith : System.Text.Rune * StringComparison -> bool

Public Function StartsWith (value As Rune, comparisonType As StringComparison) As Boolean

Parámetros

value: Rune

comparisonType: StringComparison

Devoluciones

Boolean

Se aplica a

StartsWith(String, Boolean, CultureInfo)

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Source:: String.Comparison.cs

Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se compara con la referencia cultural especificada.

public:
 bool StartsWith(System::String ^ value, bool ignoreCase, System::Globalization::CultureInfo ^ culture);

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

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

member this.StartsWith : string * bool * System.Globalization.CultureInfo -> bool

Public Function StartsWith (value As String, ignoreCase As Boolean, culture As CultureInfo) As Boolean

Parámetros

value: String

Cadena que se va a comparar.

ignoreCase: Boolean

true para pasar por alto mayúsculas y minúsculas durante la comparación; de lo contrario, false.

culture: CultureInfo

Información cultural que determina cómo se compara esta cadena y value . Si culture es null, se usa la referencia cultural actual.

Devoluciones

Boolean

true es si el value parámetro coincide con el principio de esta cadena; de lo contrario, falsees .

Excepciones

ArgumentNullException

value es null.

Ejemplos

En el ejemplo siguiente se determina si una cadena se produce al principio de otra cadena. El StartsWith método se llama varias veces mediante distinción entre mayúsculas y minúsculas, insensibilidad entre mayúsculas y minúsculas y referencias culturales diferentes que influyen en los resultados de la búsqueda.

// This code example demonstrates the 
// System.String.StartsWith(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 aRingXYZ = "\u0061\u030a" + "xyz";

// Clear the screen and display an introduction.
    Console.Clear();

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

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

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

    Console.WriteLine("Case insensitive:");
    result = aRingXYZ.StartsWith(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 = aRingXYZ.StartsWith(capitalARing, false, ci);
    Console.WriteLine(msg3, result);

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

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

Search for the target string "Å" in the string "a°xyz".

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

*/

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

open System
open System.Globalization
 
[<EntryPoint>]
let main _ =
    let msg1 = "Search for the target string \"{0}\" in the string \"{1}\".\n"
    let msg2 = "Using the {0} - \"{1}\" culture:"
    let msg3 = "  The string to search ends with the target string: {0}"

    // Define a target string to search for.
    // U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    let 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).
    let aRingXYZ = "\u0061\u030a" + "xyz"

    // Clear the screen and display an introduction.
    Console.Clear()

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

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

    printfn "Case sensitive:"
    let result = aRingXYZ.StartsWith(capitalARing, false, ci)
    Console.WriteLine(msg3, result)

    printfn "Case insensitive:"
    let result = aRingXYZ.StartsWith(capitalARing, true, ci)
    Console.WriteLine(msg3, result)
    printfn ""

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

    printfn "Case sensitive:"
    let result = aRingXYZ.StartsWith(capitalARing, false, ci)
    Console.WriteLine(msg3, result)

    printfn "Case insensitive:"
    let result = aRingXYZ.StartsWith(capitalARing, true, ci)
    Console.WriteLine(msg3, result)
    0
(*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).

Search for the target string "Å" in the string "a°xyz".

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

*)

' This code example demonstrates the 
' System.String.StartsWith(String, ..., CultureInfo) method.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim msg1 As String = "Search for the target string ""{0}"" in the string ""{1}""." & vbCrLf
        Dim msg2 As String = "Using the {0} - ""{1}"" culture:"
        Dim msg3 As String = "  The string to search ends with the target string: {0}"
        Dim result As Boolean = False
        Dim ci As CultureInfo
        
        ' Define a target string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim capitalARing As String = "Å"
        
        ' 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).
        Dim aRingXYZ As String = "å" & "xyz"
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        
        ' Display the string to search for and the string to search.
        Console.WriteLine(msg1, capitalARing, aRingXYZ)
        
        ' Search using English-United States culture.
        ci = New CultureInfo("en-US")
        Console.WriteLine(msg2, ci.DisplayName, ci.Name)
        
        Console.WriteLine("Case sensitive:")
        result = aRingXYZ.StartsWith(capitalARing, False, ci)
        Console.WriteLine(msg3, result)
        
        Console.WriteLine("Case insensitive:")
        result = aRingXYZ.StartsWith(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 = aRingXYZ.StartsWith(capitalARing, False, ci)
        Console.WriteLine(msg3, result)
        
        Console.WriteLine("Case insensitive:")
        result = aRingXYZ.StartsWith(capitalARing, True, ci)
        Console.WriteLine(msg3, result)
    
    End Sub
End Class

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'Search for the target string "Å" in the string "a°xyz".
'
'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
'

Comentarios

Este método compara el value parámetro con la subcadena al principio de esta cadena que tiene la misma longitud valueque y devuelve un valor que indica si son iguales. Para ser igual, value debe ser una cadena vacía (String.Empty), debe ser una referencia a esta misma instancia o debe coincidir con el principio de esta instancia.

Este método realiza una comparación mediante el uso de mayúsculas y minúsculas y referencias culturales especificados.

Se aplica a

Comentarios

¿Le ha resultado útil esta página?