You Completely Misunderstand How Strings Work in C# 

This is my favourite kind of video -- revealing some underlying part of the language which is applicable everywhere

That was an awesome video! Would it be possible for you to create one that explains the differences between "const", "readonly", and "static readonly" and when to use each of them? Additionally, a video on data types, their memory sizes, and how they operate would be great as well. I am trying to gain a deeper understanding of programming in C# without delving into assembly, and your videos like this one have been incredibly helpful in achieving that goal.

This is why I like watching your videos, even when talking about basic stuff like strings I can learn something new and just know you respect our time and knowledge and teach all levels something new ... i didnt know the Intern function or even the name of that compiler feature(interning), i did know what its doing behind the scene though. This is a great reference for this topic, so big 10x🙏🏼

I watch your videos even if I think I know the answers. Sometimes I learn a lot other times a little. But it always something and it's worth it. Thanks.

This has seriously answered so many questions for me! Mainly around the change in the applications behaviour when you commented-out the final two lines towards the end of this example, and that the var nickChapas became null. I have experienced changes in an applications behaviour by adding and removing variables in other parts a method and always wondered why, now I know!! SO helpful, thanks for answering this age old question of mine. ❤ 🔥

This was an awesome and really educative video. This was the first time I'm actually hearing about string interning. I'm a junior C# Dev and am trying to take that next step by always thinking about performant code and knowing the implications of what I'm actually doing. Content like this are a gem. Super straight to the point and informative. Thanks Nick!

I had some optimisation work a few months back where I had to manually intern some strings we were allocating when parsing NMEA messages from sensors. I had absolutely no idea this was happening under the hood. If I had this insight back then it would of made my life a hell of a lot easier 😂 Great video by the way! You’re bringing to light topics that even most of us seniors struggle to grasp.

An important topic that's widely misunderstood. I've only forced interning one time, in an application that deals with 10's of millions of strings, many of which are short and many of which are identical. In this application, forced interning cut memory usage massively and also improved performance significantly. The documentation on String.Intern explains the runtime mechanism quite succinctly, but since most developers don't know it even exists, relatively few have read it, I suspect!

I knew about the general idea of immutable strings and the internal optimizations to reuse constants if possible because string constants work very similarly in most other languages too but I had no idea that it was called interning in C# and that you can manually force a string to be interned like this. It is really surprising how many really dangerous tools C# has that absolutely allow you to shoot yourself in both feet and knees at the same time. And it is even more surprising how rare these kinds of mistakes seem to be in production code especially compared to C++.

These lower level vids on the CLR are great since I don't use ASP at work, top tier stuff

Thank you so much Nick! I love your content so much, as you have such an amazing ability to explain complicated topics in a really logical, easy to understand way. I hope you won't mind if I make a tiny suggestion. For important terms like "interning", maybe you could flash the term as text on the screen so people can see it written? It can sometimes difficult to catch what is being said when you don't know the term already. I don't mean to say that you're difficult to understand, as your English is exceptionally good. It happens with native speakers as well. Thank you so much again for your fantastic content!

Very good video. Another helpful video would be to discuss why making strings immutable is a good idea and the huge issues/bugs that would occur if it wasn't. Of all the extremely clever/experienced C# developers I've met in the last 20+ years not one has been able to answer that question and struggle to understand the reasons why when I explain it to them!

Yep, basically I knew almost everything, but except what you show at 7:26. I did not expect those 2 WriteLines with those comparisons to actually make the difference for the compiler to intern the string or not. There's one thing I would like to note: When you declare const variables, the C# compiler does a literal copy-paste of the values just like a macro and generates IL that way. This is quite different from the other examples. A bit of trying on Sharplab with your examples demonstrates that well. And such, it looks like the actual interning is not done by just the C# compiler, but rather by the JIT compiler at runtime. Can you confirm this?

Loved it! Very informative

I wasn't aware of C# using const expressions like that. Pretty cool, and definitely something I need to remember for the future.

Thanks. I didn't know the CLR merged simular strings in some cases or that isInterned() even existed. Great to know!

Learnt a lot, as usual, thank you!

I knew about all of this except for the Intern methods. Those are interesting. I never actually read about this, but when I was in school we dove deep into JAVA and we learned how strings works so when I learned C# at school it was mainly to build websites and they didn't go deep into that. I just assumed it was the same how strings worked and I always treated them this way. StringBuilder is always my friend when working with any kind of strings. I've seen a lot of junior and mid-level devs just doing lots of concats and wondering why their code uses so much memory. lol

Very very useful, thank you nick!

Thank you! It was very useful!

Excellent video! Thank you!

thanks Nick, I've never thought that the compiler cannot intern string concatenation until the originating parts are marked as constant, I always supposed it worked even without "const", i've never stopped reflecting on it until now even if i was well aware of the behavior of concatenating string with other types (i've discovered it in the hard way long time ago). For some reason i have assumed it wrong for i don't know which reason. Even if it is normal that every other type before being concatenated is transformed with ToString implicitly and therefore at the end it is always two strings! Also, I was sure that with "const" the trick works, but i've wrongly extended my mental model to string variables that are not const :| thanks again.

I knew all that because I read Pro Mem management book. What I learned later was the use of string pools. I knew that interning strings is a rare case that you have to be careful about. But once I saw the proper use of string pools with parsers: mindblown.

I did not know about string interning. Nice to know what optimizations are available strings.

Thanks for making this video. Please keep making videos.

Just thought I'd mention it for completeness, but Trim and Concat don't always make new allocations. A Trim that removes 0 characters will return the original string. Likewise a Concat that only adds nulls or empty strings will also return the original string. The only exception to the latter is doing a concat on 2 nulls; the result is string.empty. I've worked on projects that massively benefit from these optimisations, as the developers of yore decided to null guard most things string related by concatenating an empty string.

Very informative !

If the reference being the same for difference variables made you nervous too, you should know that they get different references when the value gets changed by virtue of the immutable nature of strings forcing a new object to be created when the value is reassigned.

Thank you, awesome video. I had a question about string.Empty. I was thinking that instead of setting "" we always should use string.Empty, but according to this video it seems we don't need it. Does string.Empty will work with the same behavior? For example: string myEmptyString=""; string mysecondEmptyString=string.Empty Does it allocate two strings in memory (1 for string.Empty and 2 for "")?

I love hearing these videos about string, because they do indeed cause the most heap trouble. It makes me wonder if there is a super secret way where you can make an array and then mutate it through some unsafe API :o ;)

I knew most of this, the only thing I never realized is that if the strings being concatenated are const the concatenated result will be interned as well. I should have known though, since creating const strings by concatenating other const strings is allowed and C# generally tries to evaluate expressions with consts and literals at compile time.

Turns out I did understand how string interning works, after all. (This hasn't changed since .NET v1, or since I can recall.) Was expecting maybe to learn some details eg. length-prefixing and null-termination.. UTF-16 vs UTF-8 in-memory representation.. how surrogate pairs are handled. Conversion during interop. Case-insensitive comparison in various locale contexts. (Maybe ideas for followup videos, if you haven't covered that already.)

Hey Nick. What materials do you browse to know such a things? It is awesome

Another reason why its a good idea it const all your string literals. Good video!

You should definitely mention the Flyweight pattern in this video.

Thank you that's great to know. So instead of comparing strings we should check if the reference is the same, for performance reasons? Wouldnt this be considered a hack? And why string comparison does not do the same internally instead of comparing every char (if I got it right)?

Great stuff, i was awere of it but didn't know the two methods. Could you please show the IL where compiler interns the string? What is startup time penalty for that? The

In full Net Framework, string interning is actually shared across applications, so it was strongly discouraged to manually Intern strings which would never be released, even after your application ends. That's less of a problem with Net Core (Net 5+) since the runtime is isolated to the application, but you should still be careful, because once they are interned, the strings will never be released until your application ends.

Very interesting!

Java has a string compacting garbage collector, where if the sweep notices that 2 strings are the same, it updates them to the same (disposable) reference, and only keeps one of them.

That is a really interesting nuance in that the addition of 'const' allows the interning optimisation to occur. I'm surprised that 'nickChapsas' would not need to be marked as constant as well though.

The coolest thing about this was that commenting out lines later in the execution of the program actually affected the result of lines further up, sort of like a backwards cause & effect situation.

About the last bit with IsInterned at 07:20 . Is it really because the compiler is "smart" that we get a True for reference or equality checks? My thought here is that because we gave the compiler the explicit value "NickChapsas" in the equality/ref checks (lines 8-9), then it stored and interned that string. Then, when calling IsInterned(nick + chapsas), we get something because of that interned explicit string value. Later when lines 8-9 are commented out, the compiler has no reason to intern the value "NickChapsas" because of what you already said earlier in the video

Very nice video, thanks for the dirty details. That 'IsIntern' functionality seems extremely dangerous to me.

I feel like you have missed a very important fact about interning in this, and that is that the query string still needed to be allocated to get the interned value. So you're not saving allocations in the short term, just long term memory usage. This can easily trip people up, where they think the allocation made with the string ops is somehow being avoided

For sure

I knew about string interning but I actually thought it was a CLR thing, not a compiler thing. So I would have swear all strings, including runtime composed strings were interned (and I have 20 years of c# behind me...😬)

3:14 Isn't it an optimization by the compiler? If not, then both "Nicks" would be stored in the dll/exe.

Cool, interning is new for me.

Nice video. But I don't like your first example with TrimEnd. Just because TrimEnd creates a new string, doesn't showcase that strings are immutable. It would be better to show what strings are allocated in memory after doing string2 += someOtherString, but you would probably have to fiddle with GC.

5:51 Is that true though? == operator in C# is a different implementation than Equals() method. Not sure if they're implemented differently for strings though, but I guess that part is a bit missleading

@nickchapsas What about string.Empty? I was always told to use that over "". But it makes the code much worse to read imho. Is it also interned? If yes, does it still make sense to use string.Empty?

Wait, what you did tell about intern and memory bloat? Doesnt it garbage collect those strings after scope ends?

I have to ask how you discover these caveats. Reading the official docs, seeing something interesting, then playing around?

Why are they immutable? can you make a video on it?

This is a great vid. To bad youtube does not allow for 0.9x playback speed.

Title is untrue for me, though I was surprised the same string content can be at two different memory location. Not sure were I got the info that strings would always have the same address when equal.

Proud to be the first one to view the video and comment on it. @Nick I deserve a reward of some sorts. :D. As always a big fan of your video. :D

Interesting.

It would be great if interning worked more generally on any immutable type.

Hello Nick chipsas can you help with me how to use loops to datagridview columns in c# 👍

Can you explain how your string pool is better than this Intern mechanism?

tbh IsInterned not returning boolean is kind of surprise

Ah yes, I am sometimes confused about strings because they are reference types but also immutable, so I forget what they really are.

Nick Chapsas name of the channel. Nick and Chapsas values for variables named nick and chapsas. I was almost expecting that he would eventually create a var named myVar... Such egomania...

If you want Junior to fail an interview, just ask him - why the lines of code return true. HaHa, Classic! )))

quantum effects

here's a comment for your engagement. Cheers!

**applause**

Wrong. I only partially misunderstood how strings work in C#.

This string magic immediately disappears if you upcast string to object like so: (Object)s2 == (Object)s1 \\false

The world is full of miracles, if you don't read the docs :D So clickbait title!

It should rather bei called PriorityBag, because it does not preserve any ordering at all.

nou

Another episode from the series: Why you shouldn't be a software engineer.... because you might not know something. I got it... fine.

You underestimate me with your video title you smug twit 😂(jk, I like your content, and I tolerate your condescending titles). To be fair I didn't know about IsInterned, can't think I'd use it really though. I think an idea for an interesting follow-on(ish) episode could be string.Create

So string pooling was a lie 😒. Thought all strings are pooled, then later, if there isn't any reference, it will be garbage collected.

SPOILER ALERT: if you ever heard of strings interning, in c#. java or anywhere else, you understand it just fine o_O. Nice content, but a terrible title

I am one of those who thought the string interning is happening by default. I need to dig deeper into it.