How to Create Dynamic Strings In C#

Introduction

As we all know, strings are immutable, because, after a string is stored in the memory, the memory, which is allocated for the string, cannot change.

If the string changed, a new memory location is needed to store the changed string. In these circumstances, we use the StringBuilder class with a string type.

For example, let’s look at the example given below:

Int amount=26;
String s1=”My age is ”;
S1=string.concat (s1,amount.ToString());

In the code given above, s1 is created and changed, so the old and new s1 will be stored temporarily in memory. The old s1 will be cleared from the memory by a garbage collection process. If our application frequently changes the string, then obviously we may hold large memory in use, while waiting for the next garbage collection to clean up the memory.

Concatenating Strings

The string.Concat method creates a new string and concatenates it with the result of the ToString method and then stores the result in the new memory location, which is then linked to s .

This means that we have two strings when we only need one. Also, in a real-time scenario, we may work with multiple strings. Let’s say that we had a situation where we had to concatenate the strings in a loop. This situation can be both a performance and memory problem.

Thus, to overcome this issue, we need to implement the String.Builderclass in the System.Text namespace.

When to Use the StringBuilder Class

If we concatenate the string in a for loop, where a large number of strings are stored in memory, then it is recommended to use the StringBuilder class.

StringBuilder also acts as a collection class. It allocates an initial value of 16 characters and, if your string becomes larger than this, it automatically grows to accommodate the string size.

We can implement StringBuilder as shown below:

int amount =21;
StringBuilder sb= new StringBuilder("My Balance is ");
sb.append(amount);

The code given above contains only one string, which is referenced by sb.

Methods of the StringBuilder Class

There are 5 important methods in the StringBuilder class:

1. Append
2. AppendFormat
3. Insert
4. Remove
5. Replace

Append

This method places an item at the end of the current StringBuilder class.

AppendFormat

This method specifies a format for the object.

Insert

Places the object at a specific index.

Remove

As the name indicates, it removes the characters.

Replace

As the name indicates, it replaces the characters.

Examples of Each Method

Let us create an object, as shown below:

StringBuilder sb= new StringBuilder(“ABCD”); 

APPEND

1. The way of to Append: Append(“EF”);  
2. Output: ABCDEF 

APPEND FORMAT

1. Way to apply append format. AppendFormat (“{0:n}”,1100);  
2. Output: ABCDEF1,100.00 

INSERT

1. Way to insert something into an object: Insert(2,”Z”);  
2. Output: ABZCDEF1,100.00 

REMOVE

1. Way to remove something from the object: Remove(7,6); 
2. Output: ABZCDEF00 

REPLACE

1. Way to replace something in an object: Replace(“0”,”x”);  
2. Output: ABZCDEFXX 

Interview Question

After executing the code given below, how can you preserve computer memory?

for (int i = 0; i < 1000; i++) {
 s = s.Concat(s, i.ToString());
}

Answer

StringBuilder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
 s.Append(i);
}

Thanks for reading this article. Sharing is caring.