Store a reference to a string

Question

I have a class that has 3 string properties. I want to store these in a list so that when I make changes to the strings of the list they also get updated in the class.

This would be easy to do if I was using class object, but string seems to behave differently. It seems to make a copy of the object for the list rather then have a pointer to the object. How am I supposed to do this is C#? If this is not possible is there a better way?

Answer 1

The problem with strings is that they are immutable. In other words, you can never change a string once it is created.

Thus, if you want to 'change' a string, you must remove the original from the List, and store the result back into the list. Example:

string a = "abcdefg";
List<String> list = new List<String>();
list.add(a);

a = a.Substring(0, 5);

That code does nothing because the string a is pointing to never changes. It just points to a new string.

Answer 2

In .NET, strings are immutable. If you change the string, you are in fact creating a new one and modifying the reference.

I would consider using a StringBuilder object to address your problem.

Answer 3

You're looking for a mutable string of some kind. There are a lot of ways to create a class that behaves the way you want it.

The easiest way would be to use a StringBuilder object instead of a string. You just have to be careful to not make new StringBuilder objects, but rather alter the existing one. Depending on what you need, this may not be the best option.

Alternatively you can create your own wrapper class for String that you can manipulate freely. The downside is you may have to write a lot of stub methods that call down to the inner string depending on how you want to use it. It would be easier to just expose a read/write string property. This has the advantage of letting you define exactly what behaviours you want, but will take longer to write in the first place. Again, you'll have to make sure to not create new instances of the wrapper class, but rather just alter the class's internal string.

Answer 4

Wrap your string into a custom class, this will allow you to share it amongst a number of different locations. You could also choose to store Char arrays instead.

Answer 5

Since strings are immutable, the simplest work-around is to instead store the reference to a string array with one element. Replacing that element will then be noticed by anyone with a reference to the array.

Answer 6

Strings in C# are immutable, so you cannot change a string in C# - you can only create new strings.

You could rather store a class that has a string member

class StringHolder {
  public StringHolder(string s) { str = s;} 
  public string str;
}
...
List<StringHolder> l1 = new List<StringHolder>();
List<StringHolder> l2 = new List<StringHolder>();
List<StringHolder> l3 = new List<StringHolder>();

StringHolder h = new StringHolder("Test\n");
l1.add(h);
l2.add(h);
l3.add(h);

h.str = h.str.Replace("\n","");

Now all lists refer to the same StringHolder and will naturally see the same string.

Another option is to store StringBuilder objects in your lists instead of a String.

Answer 7

Strings are immutable. You can change a reference to point to another string but you cannot modify a string such that other references to it change value as well (except by unsafe, completely dangerous reflective code)

What you want to do is deal with this either through using a mutable alternative, (such as a StringBuilder) or via explicit indirection. I'll show you the latter:

public class Props
{
    private readonly string[] data = new string[2];

    pubic string Foo { get { return data[0]; } }
    pubic string Bar { get { return data[1]; } }

    public IList<string> ModifyValueButNoInsertsList { get { return data;} }
}

Really you should consider actually using string[] rather than IList in this situation as it makes it clear inserts are forbidden, only alterations of the values. Since string[] implements IList<string> this is unlikely to be a problem

Answer 8

class StringHolder
{
    public string Value { get; set; }
}

Keep a list of those instead of just strings. Then you can get/set the Value property to update the string value.

Answer 9

As a side note (like several have mentioned), if you're doing some heavy processing with strings, use the StringBuilder class. Because of the immutable nature of strings, changing/concatenation of them in loops or what have you - will cause a lot of overhead.

StringBuilder is your friend.