CODEWITHSUNDEEP
c#immutability
DNAInstant
DNAInstant

Reputation: 137

C# Changing a string after it has been created

Okay I know this question is painfully simple, and I'll admit that I am pretty new to C# as well. But the title doesn't describe the entire situation here so hear me out.

I need to alter a URL string which is being created in a C# code behind, removing the substring ".aspx" from the end of the string. So basically I know that my URL, coming into this class, will be something like "Blah.aspx" and I want to get rid of the ".aspx" part of that string. I assume this is quite easy to do by just finding that substring, and removing it if it exists (or some similar strategy, would appreciate if someone has an elegant solution for it if they've thought done it before). Here is the problem:

"Because strings are immutable, it is not possible (without using unsafe code) to modify the value of a string object after it has been created." This is from the MSDN official website. So I'm wondering now, if strings are truly immutable, then I simply can't (shouldn't) alter the string after it has been made. So how can I make sure that what I'm planning to do is safe?

Upvotes: 4

Views: 790

Answers (4)

McGarnagle
McGarnagle

Reputation: 102743

String immutability is not a problem for normal usage -- it just means that member functions like "Replace", instead of modifying the existing string object, return a new one. In practical terms that usually just means you have to remember to copy the change back to the original, like:

string x = "Blah.aspx";
x.Replace(".aspx", "");       // still "Blah.aspx"
x = x.Replace(".aspx", "");   // now "Blah"

The weirdness around strings comes from the fact that System.String inherits System.Object, yet, because of its immutability, behaves like a value type rather than an object. For example, if you pass a string into a function, there's no way to modify it, unless you pass it by reference:

void Test(string y)
{
    y = "bar";
}
void Test(ref string z)
{
    z = "baz";
}
string x = "foo";
Test(x);                 // x is still "foo"
Test(ref x);             // x is now "baz"

Upvotes: 5

DonBoitnott
DonBoitnott

Reputation: 11025

A String in C# is immutable, as you say. Meaning that this would create multiple String objects in memory:

String s = "String of numbers 0";
s += "1";
s += "2";

So, while the variable s would return to you the value String of numbers 012, internally it required the creation of three strings in memory to accomplish.

In your particular case, the solution is quite simple:

String myPath = "C:\\folder1\\folder2\\myFile.aspx";
myPath = Path.Combine(Path.GetDirectoryName(myPath), Path.GetFileNameWithoutExtension(myPath));

Again, this appears as if myPath has changed, but it really has not. An internal copy and assign took place and you get to keep using the same variable.

Also, if you must preserve the original variable, you could simply make a new variable:

String myPath = "C:\\folder1\\folder2\\myFile.aspx";
String thePath = Path.Combine(Path.GetDirectoryName(myPath), Path.GetFileNameWithoutExtension(myPath));

Either way, you end up with a variable you can use.

Note that the use of the Path methods ensures you get proper path operations, and not blind String replacements that could have unintended side-effects.

Upvotes: 2

Keith Payne
Keith Payne

Reputation: 3082

String.Replace() will not modify the string. It will create a new one. So the following code:

String myUrl = @"http://mypath.aspx";
String withoutExtension = myUrl.Replace(".aspx", "");

will create a brand-new string which is assigned to withoutExtension.

Upvotes: 1

Servy
Servy

Reputation: 203814

You don't change the string, you change the variable. Instead of that variable referring to a string such as "foo.aspx", alter it to point to a new string that has the value "foo".

As an analogy, adding one to the number two doesn't change the number two. Two is still just the same as it always way, you have changed a variable from referring to one number to refer to another.

As for your specific case, EndsWith and Remove make it easy enough:

if (url.EndsWith(".aspx"))
    url = url.Remove(url.Length - ".aspx".Length);

Note here that Remove is taking one string, an integer, and giving us a brand new string, which we need to assign back to our variable. It doesn't change the string itself.

Also note that there is a URI class that you can use for parsing URLs, and it will be able to handle all of the complex situations that can arise, including hashes, query parameters, etc. You should use that to parse out the aspects of a URL that you are interested in.

Upvotes: 6

Related Questions