Correct String Initialization in C# 

I've been using String.Empty for years now. Because I can look at it an know "I 100% meant to put nothing here". If I see quotes, I end up asking myself if something should be there and was forgotten or is pending yet. So for me, it's far more readable with being explicit on intent.

Many thanks for sharing. Its a little irrelevant to this topic, but, this tutorial made me think about "string.IsNullOrEmpty". I am used to using "string.IsNullOrEmpty" in my codes just to make sure I am not facing with an error which has a root in a careless string initialization . I read somewhere, this not a good style of programming. now, I think, I gained a deeper insight into the null string vs empty string.

Actually, there is a difference between using double quotes ("") and string.Empty; The IL code generated is different: Using double quotes generates: ldstr "" whereas string.Empty gives: ldsfld string [mscorlib]System.String::Empty Which one is less efficient is hard to say. Something tells me that the latter is less efficient simple because of an additional level of indirection - one for the static class System.String, and one more for the field reference.

I also prefer string.empty, as other pointed out - it's explicitly saying that I didn't simply forget to put something there. I even like it in terms of how the IDE colors the two. string.empty is the normal blue color, nothing to see, normal, boring. empty quotes are the scary orange color of "things that I just type and hope to get right". I prefer not to have too many of those. they draw attention to themselves and will take focus away from actual string initialization with real values.

Thanks Tim!

This has been one of my most puzzling parts for a while. Many thanks

Very interesting! I've been inconsistent over my career when it came to string initialization. I'd say I mostly used String.Empty, mainly because it had the benefit of being self-documentary. For what that was worth, which was probably not much. I never, ever, initialized a string to null. It was against my religion, I guess. I've been retired since 2016, but still love C# and write the odd utility program now and then.

I agree it's personal preference - but there's two things that I think are worth noting: * string.Empty cannot be used as the value of an optional parameter, you must use "" for that. * Searchability: Yeah, chance of you needing this is low, but if you want to find all instances of empty string, looking for "" can return false positives and string.Empty lets you find all references, and likewise, if you're wanting to find all string literals in a code base, having all empty strings excluded is useful.

You do have to be careful when mapping strings to an Oracle database, since Oracle treats NULL and EMPTY as the same thing.

feels like this could have been a 3 min video

I prefer string.Empty. I think string.Empty is cleaner, and I also like that you can directly use the same empty string, rather than rely on the compiler to "fix" that for you. I use the same pattern for my own classes too. For example I created a Result class (and Result and Result) for general use as a return value to give information about success state and exceptions (optionally also return values). And when the implementer just wants to return a "success" message, he just has to use "Result.Succeeded". Internally the classes generate a singular static instance of the result that succeeded or failed, so it is provided when possible. In other cases an exception is returned, so there the static instances are not used. It's a neat convention... however I found that I had a slight issue with having to *not* use constructors for Result, only static methods which handle when instantiation was appropriate. There is also Array.Empty as a pendant for arrays, and I may have seen something similar elsewhere too. As of null or default, I prefer null. It's good to know when I am dealing with something nullable or non-nullable in the context of type parameters. I avoid using string str = "" for optional parameters, because 'null' has to mean something, and is supposed to be the opposite of *something*.

I personally prefer string.Empty and been using it a long time. When code reviewing other developers code it's much easier to see than it is to see " " -- See what I did there? Yes there is a space in the quote, which the reviewer could miss. Using string.Empty shows to anyone looking at the code your intention of using an empty string for the value, when " " could have been either mistyped, or maybe they forgot to set it e.g. country = "USA". Yes it's quicker to type "" than it is to type string.Empty, but personally I don't think speed is the issue when I have to spend ages looking for a bug and then find that the string is set to " "... Yes that has happened. I spent more time finding the bug, stepping through code etc than it would have taken the original developer to type string.Empty. Just my 2 pennies worth. The bigger question is - what is the point of ? on the string when strings have always been nullable ? string test1 = null; string? test2 = null; test1 & test2 are both null.

That's a really good explanation Sir. Wish more video like this. I'm a newbie and your channel help me a lot. Thanks!

Really usefull, will you be making in the future topics related to microservices using NET ?

This was very insightful, never would have considered the switch-case scenario as I primarily use string.Empty. What about `null!`, `string.Empty`, or `""` when initializing a (non-nullable) string field on a model?

I disagree that it comes down to just preference. What is ""? Is it an empty string, or a string you forgot to fill? Using string.Empty shows clearly that you intended it to be empty.

Thank you for starting my morning with a quick overview before clocking in!

I’d bet lots of people watch these videos on their phones but the text is so small I have trouble reading it. There was so much unused space to the right and below Tim’s code, zooming in would have helped.

string test5 = null!; Always usefull

Coming from VBA, sticking with ' string1 = "" ' created a lot of clean and reusable evaluations for my solutions (e.g. "if len(string1) = 0 then...." ). This basic functional logic opened a lot of doors for me, and was one of my first personal conventions; instantiating strings = "" was one of the main catalysts that lead me to a real programming career in C#/SQL. One of my oldest, poorly named functions (escapeApostrophes) essentially doubles up apostrophes if they exist (for database reasons), or converts null strings to empty strings - the issue with the name is with how often it is used, I should have named it something much shorter!! :-p

I Usually initialize my string with "null"; just to mess with people.

string is a class. Why is the code not: string test = new string("abc")

But what is the difference if we declare string a = null. Between: (if a != null){} and (if a is not null). I like the latter, but heard its not good for strings.

Diving into the generated IL would have been great here to show the proof. It would have also been great to dive into the differences and origins of “string” versus “String” in C#/DotNet.

var text = string.Empty i always use this lol

If I'm understanding you correctly - the the compiler sees that there are two constants "" that it will behind the scenes just create a single constant and only use that single reference throughout?

You still may want to explain the difference between string.Empty and String.Empty. Also, you never need to initialize a string explicitly with null, because the compiler will do this for you. So there is still more to say on this topic.

Hi, please, can you do a video on creating AI apps in Blazor that use Pinecone as a database for infinite memory for GPT3

I'm glad to hear you not parroting the old, now useless, advice to use string.Empty instead of "". Another thing to consider with initializing strings as to whether you use null or an empty string to represent the concept of "no data present" is, when possible, to consider not creating the object/structure until you have the data present and you can initialize the strings to a meaningful value. Not always possible of course, but when it is it removes the need to check whether the string is null/empty and take a different course of action if so. The more little fiddly bits like that you can get out of your code the happier you'll be ;)

the C# -- if you included some evaluations-- of IsNullOrEmpty()

Thank you for your explanation!

Is this also default? string? test6;

As for String.Empty vs "", my take has always been to use String.Empty wherever you can, since it's platform independent. So, if there's a hypothetical future where a new platform defines empty strings differently (Oracle SQL?), you're already covered. Te save reaso you'd use Environment.Newline. ...Defensive programming, and all that jazz.

Why did you use string? type. What is question mark character for?

I'm still ambivalent about what to use. On the one hand string test = ""; is recognised in multible c-like languages as as empty string (and for many developers it's easy to understand as it was you've seen the most) but on the other hand string.Empty is more in line with the use of the String.IsNullOrEmpty method. I use them both interchangeably. If I see test = ""; in code I won't change it but if I write new code I tend to use string.Empty.

Thanks Tim. It's given me food for thought, but I'm still unsure about what is the best method. On a similar note, years ago I got into the habit of declaring strings as "String" type, rather than "string". I can't remember what made me do this, though. What are your thoughts on this?

String.empty == "" ? True:false;

Is it a good practice to initalize a variable to empty after using in C#?

ty so much

Thank you very much Tim!!

I was taught years ago that using String.Empty for initialization was used to explicitly state an empty string, rather than a "" (double quote) being used and was that empty string an accident and should it have had an actual value

Is there an access path on the horizon? The courses are very good but they are really expensive and one can't do with the free stuff only.

In the case of test 2 and 3 its is not a matter of preference IMO if test3 allows more functionality via switch cases. That definately puts it in the "Reasons to use over string.Empty"

Great video!! Tanks for sharing!

I don't understand what's the point to initialised a string with null or default. At some point the variable will have a value so it can be initialised with "" or string.empty, doesn't it ? Thank you for the vidéo

Thanks Tim :)

1:00 you can use Alt + up/down arrows to move line up/down. Please use such shortcuts and maybe even sometimes point it out, so you not only teach us the primary topic of the video, but also how to use IDE efficiently

What if it is a "string?" as opposed to a "string"? Is it recommended to initialize the variable instead just declaring it?

Stupid question but is string nullable by default so that we can write 'string' instead of 'string?' ?

I love this Playlist, go ahead 🤍