Home/ Questions/Q 8491041
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-10T22:18:02+00:00

With this code: void SomeMethod(string str) { string tmpStr = … Read some value

  • 0

With this code:

 void SomeMethod(string str)
 {
      string tmpStr = ... Read some value from file ... 

      if( !tmpStr.Empty() ) 
           str = tmpStr;

 }

When I call this method with a simple string just created inside the main subroutine: 

 string localString = "";
 SomeMethod( localString );

The value that I get back in localString is an empty event when I see in debug that in the method SomeMethod the variable tmpStr is not empty and the variable str in the method is full with chars.

If I change the SomeMethod signature to be:

SomeMethod(ref string str)

I see the right result.

But string is a reference type, so why do I need in this case to send it with ref?
and why I get the result that I expected only when I call: 

SomeMethod(string str)
Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    It’s not just that the string is immutable, but also that while string is a reference type, a reference itself is not. That is, you are passing the string by reference, but the reference itself is passed by value.

    Thus, for reference types, you can modify the object that is referred to by the parameter (as long as it’s modifiable), but you cannot modify what the argument refers to unless you pass it by reference.

    So, when you try to change what the string variable refers to:

    str = tmpStr;

    It changes what str refers to locally, but does not affect what the original argument localString refers to.

    Think of it this way, let’s say that the argument localString refers to an object at location 1000:

    localString 
+---------------+                      1000
|      1000     |   -----------------> +---------------+
+---------------+                      | Count: 1      |
                                       | Value: ""     |
                                       +---------------+

    Then when we pass localString to the method, it creates a copy of the reference (as str) and updates the reference count…

    localString 
+---------------+                      1000
|      1000     |   -----------------> +---------------+
+---------------+                      | Count: 2      |
                                       | Value: ""     |
str                                    +---------------+
+---------------+                        ^
|      1000     |   ---------------------+
+---------------+

    Then, when you assign str to a new string, it modifies the reference str but not localString:

    localString
+---------------+                      1000
|      1000     |   -----------------> +---------------+
+---------------+                      | Count: 1      |
                                       | Value: ""     |
str                                    +---------------+
+---------------+                          2500
|      2500     |   ---------------------> +---------------+
+---------------+                          | Count: 1      |
                                           | Value: ...    |
                                           +---------------+

    So your modification of str only changed what str refers to, not the original refernce localString, if you want to change that, then you pass by reference, which means that str is a reference back to the original argument (much like a ptr to a ptr):

    localString
+---------------+                      1000
|      2500     |  ------------------> +---------------+
+---------------+                      | Count: 2      |
        ^                              | Value: ""     |
str     |                              +---------------+
+---------------+       
|               |       
+---------------+

    Now, when you change str it changes the refernce localString as well:

    localString
+---------------+                      1000
|      1000     |  -----+              +---------------+
+---------------+       |              | Count: 0      |
        ^               |              | Value: ""     |
str     |               |              +---------------+
+---------------+       |                  2500
|               |       +----------------> +---------------+
+---------------+                          | Count: 1      |
                                           | Value: ...    |
                                           +---------------+

    And then, of course, the original string (assuming nothing else refers to it as in this example) can be garbage collected…

    So, if you really want to modify the string parameter, pass it by ref or out, or you can return the new mutated version, or store in an instance member (though pass-by-instance-member is a higher order of coupling and can cause other issues…).

    • 0