String.empty v.s. string.null

Thanks Brandon,

 

Great reply! Two more comments,

1.

In your pseudo code of Empty property, each time a new instance is returned, right? So, references to String.Empty are pointing to different memory locations, right?

2.

"And since the property is a read-only property, there is no chance of modifying it and messing anything else up in the application." -- if the property is not read-only, what actions you could do to analyze?

 

regards,

George

Hi Dave,

 

I am interested in your solution -- "With 3.5, you can declare and use pointers (just like C++) inside an unsafe block. Theoretically, initialise a couple of pointers to strings which are initialised to String.Empty." Could you show your code please? So that all of us could learn from you.

 

regards,

George

Good point Dave, I sometimes forget just how powerful unsafe code can be in C#. I should try that

Whether it points to the same location in memory could probably be checked by someone running the latest version of the .NET framework.
With 3.5, you can declare and use pointers (just like C++) inside an unsafe block. Theoretically, initialise a couple of pointers to strings which are initialised to String.Empty. Then send those addresses to output.

I'm still on 2.0. So I cannot help. 

That's actually a pretty good question and I'm inclined to say yes. Seeing as how a static member is basically a Singleton member of a non-static class, like string, String.Empty would be a "global" property and the string object is a reference type (versus a value type for most numerical data objects) then all references to it would point to the same location in memory. Maybe that's why I was always taught to use String.Empty instead of just "" because using "" allocates new memory while String.Empty does not. I could be wrong though, but following what I know about static classes and properties I wanna say that this theory is correct.

Of course the property could also look likes something crazy, like this:

public unsafe static string Empty
{
   get
   {
      char tempChar = ' ';
      return new string(&tempChar);
   }
}

Its hard to say what goes on in there... this is why Im going back and learning C++ so I can get a better understanding of the C# language.

And since the property is a read-only property, there is no chance of modifying it and messing anything else up in the application.

Thanks Brandon!

 

Great! I found Empty is a static member of String class, so, it means all string type variables initialized with String.Empty are pointing to the same thing?

 

regards,

George

A null string is a string that has not been initialized. It is a string variable that hasn't even been given some memory to store data. This will create a null string:

string myString; //Without initializing it, will create a null string.

An empty string is a string that has been initialized and given some memory, but it just doesn't contain any characters (except a null terminator at the end, but you don't see that) so as far as the compiler and you are concerned, it is a string with a length of 0.

string myString = String.Empty; //Will create an empty string.

If you want to check for both a null and empty string, use the static method proved by the String class:

if (String.IsNullOrEmpty(myString))
{
   //do something
}