Strings in C# .NET

//Ways of creating string;  
string name = "Abhishek"; //With help of Literals  
string surname = "Yadav";  
string fullName = name + surname; //Concatenating 2 strings   
Console.WriteLine("Full Name: {0}", fullName);  
Console.WriteLine("Enter your String:"); //Taking input from Keyboard;  
string text = Console.ReadLine();  
int marks = 65;  
string myMarks = marks.ToString(); // String created with ToString() method.

Instance String Methods
Method	Description
Clone()	Creates a new string. Same as Copy()
Contains(string value)	Returns true if string contains specified value.
Remove(int startIndex)	Removes the character from startIndex.
ToCharArray()	Returns an array of char of given string.
Replace(char old, char new)	Replace old letter/string with new specified one.
Insert(int startIndex, string newString)	Insert new string at given index.
SubString(int startIndex, int length)	Returns a new string from startIndex to given length.

Examples

//Static Methods:  
Console.WriteLine("================= Static Methods ================\n");  
Console.WriteLine("Comparing \"abhishek\" and \"Sunny\" {0}",string.Compare("abhishek","Sunny"));  
Console.WriteLine("Copying text value in new string: {0}",string.Copy(text));  
Console.WriteLine("Is \"Apple\" and \"apple\" are equal ??: {0}",string.Equals("Apple","apple"));  
Console.WriteLine("Is text is NULL ? : {0}",string.IsNullOrEmpty(text));  
//All Instance Methods:  
Console.WriteLine("\n================= Static Methods ================\n");  
string cloneText = (string)text.Clone();  
Console.WriteLine("Clone Text: {0}",cloneText);  
  
bool containText = text.Contains("e");  
Console.WriteLine("Is text contains given value?: {0}",containText);  
  
string removedText = text.Remove(2);  
Console.WriteLine("New string after Removing: {0}",removedText);  
  
if (text.Contains("e"))  
{  
    string replacedText = text.Replace("e","E");  
    Console.WriteLine("New String after Replacing character: {0}", replacedText);  
}  
  
string insertedText = text.Insert(3, " Added String ");  
Console.WriteLine("Inserted Text: {0}",insertedText);  
string subString = text.Substring(3, 8);  
Console.WriteLine("New string after SubString(): {0}",subString);

After running the code above you'll get the following output:

Until now, we saw Immutable Strings that are created by the System.String class.

Now, we'll see how to deal with Mutable Strings.

As we know, mutable strings are those strings whose content can be changed or modified in place; this can be done using the StringBuilder class.

C# StringBuilder

Syntax for creating a new string with the StringBuilder class:

StringBuilder str1 = new StringBuilder();
StringBuilder str2 = new StringBuilder(“Abhishek”);

Here, we've created 2 objects of StringBuilder. The first object, in other words str1, is created with an Empty string and the str2 object is created with an initial size of 8 characters.

Mutable Strings are also known as a “Dynamic String”. It stores character data in an array and can add, remove, replace and append characters without creating a new string object.

The StringBuilder class also provides some methods. Some of the methods are shown in the following table.

Method	Description
Append	Appends a string to the end of the StringBuilder's text.
Remove	Removes a range of character from StringBuilder's text.
Replace	Replace old letter/string with new specified one.
Clear	Removes all the character from the current StringBuilder instance.

Example

StringBuilder str1 = new StringBuilder("Welcome");  
str1.Append(" to");  
str1.Append(" C-Sharp");  
str1.Append("Corner");  
Console.WriteLine(str1);  

Output

In the above program, a StringBuilder object is created with initial size of 7 characters, using the Append() method, a string is appended to the str1 object. So, it's not creating a new string; instead, it modifies the string.

Performance

Performance wise the StringBuilder class is slightly faster than the String class. To check the performance in both of the ways (in other words System.String and StringBuilder), I tried to concatenate 20000 strings with the StringBuilder object and System.String using a for loop.

string normalStr = String.Empty;  
StringBuilder dynamicString = new StringBuilder();  
  
for (int i = 0; i < 20000; i++)  
{  
    normalStr = normalStr + "Abhishek" + i.ToString();  
}  
  
for (int i = 0; i < 20000; i++)  
{  
    dynamicString.Append("Abhishek" + i.ToString());  
}

In the code above, we've created a string literal and a StringBuilder object. In the first for loop, we are trying to concatenate a string 20000 times with a string literal and the same thing with a StringBuilder object as well in the second for loop.

After diagnosing both (using System.Diagnostics), we found the following output with a big difference the methods.

System.String took 4.4576779 seconds to concatenate 20000 strings
StringBuilder took only 0.0048251 seconds to concatenate 20000 strings.

Conclusion

You can create mutable and immutable strings in .NET using String and StringBuilder classes as per your requirements. Various methods are available to manipulate these strings. We learned how to create strings and how to manipulate those strings (mutable and immutable strings). We also checked the performance of the String class and the StringBuilder class.

I hope this article helps you to understand the concept of strings.

If there's any mistake in this article then please let me know. Please provide your valuable feedback and comments, that enable me to provide a better article the next time.