Skip to main content
.NET Framework Class Library
StringStartsWith Method (String)

Determines whether the beginning of this string instance matches the specified string.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)
Syntax
Public Function StartsWith ( _
	value As [%$TOPIC/baketfxw_en-us_VS_110_1_0_0_0_0%] _
) As [%$TOPIC/baketfxw_en-us_VS_110_1_0_0_0_1%]
public [%$TOPIC/baketfxw_en-us_VS_110_1_0_1_0_0%] StartsWith(
	[%$TOPIC/baketfxw_en-us_VS_110_1_0_1_0_1%] value
)
public:
[%$TOPIC/baketfxw_en-us_VS_110_1_0_2_0_0%] StartsWith(
	[%$TOPIC/baketfxw_en-us_VS_110_1_0_2_0_1%]^ value
)
member StartsWith : 
        value:[%$TOPIC/baketfxw_en-us_VS_110_1_0_3_0_0%] -> [%$TOPIC/baketfxw_en-us_VS_110_1_0_3_0_1%]

Parameters

value
Type: SystemString

The string to compare.

Return Value

Type: SystemBoolean
true if value matches the beginning of this string; otherwise, false.
Exceptions
ExceptionCondition
ArgumentNullException

value is .

Remarks

This method compares value to the substring at the beginning of this instance that is the same length as value, and returns an indication whether they are equal. To be equal, value must be an empty string ( StringEmpty), must be a reference to this same instance, or must match the beginning of this instance.

This method performs a word (case-sensitive and culture-sensitive) comparison using the current culture.

Notes to Callers

As explained in Best Practices for Using Strings in the .NET Framework, we recommend that you avoid calling string comparison methods that substitute default values and instead call methods that require parameters to be explicitly specified. To determine whether a string begins with a particular substring by using the string comparison rules of the current culture, call the StartsWith(String, StringComparison) method overload with a value of StringComparisonCurrentCulture for its comparisonType parameter.

Examples

The following example defines a StripStartTags method that uses the StartsWith(String) method to remove HTML start tags from the beginning of a string. Note that the StripStartTags method is called recursively to ensure that multiple HTML start tags at the beginning of the line are removed. The example does not remove HTML tags embedded in a string.

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
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
using namespace System;

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;
}

int main()
{
   array<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("---------------------");
   for each (String^ 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. 
   for each (String^ s in strSource)
      Console::WriteLine(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
Version Information

.NET Framework

Supported in: 4.6, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

.NET for Windows Store apps

Supported in: Windows 8

Supported in: Windows Phone 8.1

Supported in: Windows Phone Silverlight 8.1

Supported in: Windows Phone Silverlight 8
Platforms

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.