How to get a list of mutable strings?

问题

I have the following piece of code

  List<String> l = new List<String>();
  String s = "hello";
  l.Add(s);
  s = "world";

When I set up some breakpoints and go through the program, after executing the last line, the value in the list is still hello instead of world.

Shouldn't it equal world ? Isn't a string an object, and am I not just inserting a pointer into the list? Later on if I change the string to point to a different value ("world"), why is my list still referencing the old value?

How can I get my desired effect ? Thanks a lot!

回答1:

Strings are immutable so that won't work. When you attempt to set into it, you actually drop the pointer to the old string and create a new one under the hood.

To get the desired effect, create a class that wraps a string:

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

    public SortOfMutableString(string s)
    { 
        Value = s;
    }

    public static implicit operator string(SortOfMutableString s)
    {
        return s.Value;
    }

    public static implicit operator SortOfMutableString(string s)
    {
        return new SortOfMutableString(s);
    }
}

And use this in your list. Then references will point to the class, but you can contain the string value inside. To make it even better, override implicit casting to and from string so you don't even need to see that you are talking to a SortOfMutableString.

Refer to Jon Skeet's answer for undoubtedly a very accurate explanation about string's in C#, I'm not even going to bother!

Alternative class names:

PseudoMutableString
ICantBelieveItsNotMutable
HappyAndReferenceableString

回答2:

You're changing the s reference to refer to a different String instance.
Strings are immutable; it is impossible to change the existing instance that you added to the list.

Instead, you can create a mutable StringHolder class with a writable String property.

回答3:

No, it shouldn't equal world. The value of the variable s is a reference. When you call l.Add(s), that reference is passed by value to the list. So the list now contains a reference to the string "hello".

You now change the value of s to a reference to the string "world". That doesn't change the list at all.

It's important to distinguish between three very different concepts:

A variable (which has a name and a value)
A reference (a value which allows you to navigate to an object, or null)
An object

So in particular, the list doesn't know anything about the variable s - it knows about the value which was passed into Add; that value happened to be the value of s at the time Add was called, that's all.

You may find these articles helpful:

Values and references
Parameter passing in C#

回答4:

No, there are two different references involved. One called s and one that's at List[0]. When you say l.Add(s) you are setting the list reference to the same address as s, but then when you assign s to "world", then s will point to the new string, leaving List[0] pointing to the old string.

If you really want to do something like what you are asking, you'd need to wrap the string in another object that contains a string, so that s and List[0] both refer to that object, and then that object's reference to a string can change and both will see it.

 public class StringWrapper
 {
     public string TheString { get; set; }
 }

Then you can do:

 var s = new StringWrapper { TheString = "Hello" };
 var l = new List<StringWrapper>();
 l.Add(s);
 s.TheString = "World";

And now l[0].TheString will be world too. This works because in this case we are not changing the reference in List[0] or s, but they contents of the object referred to by s and List[0].

回答5:

A variable is an object reference, not an object itself. s = "world" says "make s refer to the string "World") - it does not in any way affect the string "hello" that s was previously referring to. Furthermore, strings in C# are always immutable. You can, however, make the first list element (which currently refers to "hello") refer to a different string: l[0] = "world".

回答6:

The other two answers here did a great job of saying why what you tried didnt' work, but you were looking for a solution for your desired effect. Wrap a string (property) inside of an object. Then you can change that string and it will be reflected in the collection.

来源：https://stackoverflow.com/questions/6913435/how-to-get-a-list-of-mutable-strings

标签

string

reference