Why is there no Char.Empty like String.Empty?

Is there a reason for this? I am asking because if you needed to use lots of empty chars then you get into the same situation as you would when you use lots of empty strings.

Edit: The reason for this usage was this:

myString.Replace ('c', '')

So remove all instances of 'c's from myString.

There's no such thing as an empty char. The closest you can get is '\0', the Unicode "null" character. Given that you can embed that within string literals or express it on its own very easily, why would you want a separate field for it? Equally, the "it's easy to confuse "" and " "" arguments don't apply for '\0'.

If you could give an example of where you'd want to use it and why you think it would be better, that might help...

> The reason for this usage was this: myString.Replace ('c', '') > So remove all instances of 'c' from myString.

To remove a specific char from a string you can use the string overload:

 myString = myString.Replace ("c", String.Empty);

Your statement

 myString.Replace ('c', '\0')

Won't remove any characters. It will just replace them with '\0' (End-Of-String, EOS), with varying consequences. Some string operations might stop when encountering an EOS but in .NET most actions will treat it like any other char. Best to avoid '\0' as much as possible.

A char, unlike a string, is a discrete thing with a fixed size. A string is really a container of chars.

So, Char.Empty doesn't really make sense in that context. If you have a char, it's not empty.

There's no such thing as an empty character. It always contains something. Even '\0' is a character.

Use Char.MinValue which works the same as '\0'. But be careful it is not the same as String.Empty.

You could use nullable chars.

char? c

If you don't need the entire string, you can take advantage of the delayed execution:

public static class StringExtensions
{
    public static IEnumerable<char> RemoveChar(this IEnumerable<char> originalString, char removingChar)
    {
        return originalString.Where(@char => @char != removingChar);
    }
}

You can even combine multiple characters...

string veryLongText = "abcdefghijk...";

IEnumerable<char> firstFiveCharsWithoutCsAndDs = veryLongText
            .RemoveChar('c')
            .RemoveChar('d')
            .Take(5);

... and only the first 7 characters will be evaluated :)

EDIT: or, even better:

public static class StringExtensions
{
    public static IEnumerable<char> RemoveChars(this IEnumerable<char> originalString,
        params char[] removingChars)
    {
        return originalString.Except(removingChars);
    }
}

and its usage:

        var veryLongText = "abcdefghijk...";
        IEnumerable<char> firstFiveCharsWithoutCsAndDs = veryLongText
            .RemoveChars('c', 'd')
            .Take(5)
            .ToArray(); //to prevent multiple execution of "RemoveChars"

myString = myString.Replace('c'.ToString(), "");

OK, this is not particularly elegant for removing letters, since the .Replace method has an overload that takes string parameters. But this works for removing carriage returns, line feeds, tabs, etc. This example removes tab characters:

myString = myString.Replace('\t'.ToString(), "");

Not an answer to your question, but to denote a default char you can use just

default(char)

which is same as char.MinValue which in turn is same as \0. One shouldn't use it for something like an empty string though.

The same reason there isn't an int.Empty. Containers can be empty, scalar values cannot. If you mean 0 (which is not empty), then use '\0'. If you mean null, then use null :)

A char is a value type, so its value cannot be null. (Unless it is wrapped in a Nullable container).

Since it can't be null, in contains some numeric code and each code is mapped to some character.

Doesn't answer your first question - but for the specific problem you had, you can just use strings instead of chars, right?:

myString.Replace("c", "")

There a reason you wouldn't want to do that?

If you look at the documentation for Replace(String, String) overload for String.Replace you can see in the remarks section that if the second argument is a null then it will remove all instances of what you specified. Therefore if you just use myString = myString.Replace("c", null); it will delete every c in the string.

You can also rebuild your string character by character, excluding the characters that you want to get rid of.

Here's an extension method to do this:

    static public string RemoveAny(this string s, string charsToRemove)
    {
        var result = "";
        foreach (var c in s)
            if (charsToRemove.Contains(c))
                continue;
            else
                result += c;

        return result;
    }

It's not slick or fancy, but it works well.

Use like this:

string newString = "My_String".RemoveAny("_"); //yields "MyString"

If you want to eliminate the empty char in string, the following will work. Just convert to any datatype representation you want.

private void button1_Click(object sender, EventArgs e)
{

    Int32 i;

    String name;

    Int32[] array_number = new int[100];

    name = "1 3  5  17   8    9    6";

    name = name.Replace(' ', 'x');

    char[] chr = name.ToCharArray();


    for (i = 0; i < name.Length; i++)
    {
        if ((chr[i] != 'x'))
        {
            array_number[i] = Convert.ToInt32(chr[i].ToString());
            MessageBox.Show(array_number[i].ToString());
        }
    }
}

In terms of C# language, the following may not make much sense. And this is not a direct answer to the question. But following is what I did in one of my business scenarios.

char? myCharFromUI = Convert.ToChar(" ");
string myStringForDatabaseInsert = myCharFromUI.ToString().Trim();
if (String.IsNullOrEmpty(myStringForDatabaseInsert.Trim()))
{
    Console.Write("Success");
}

The null and white space had different business flows in my project. While inserting into database, I need to insert empty string to the database if it is white space.

I know this one is pretty old, but I encountered an issue recently with having to do multiple replacements to make a file name safe. First, in the latest .NET string.Replace function null is the equivalent to empty character. Having said that, what is missing from .Net is a simple replace all that will replace any character in an array with the desired character. Please feel free to reference the code below (runs in LinqPad for testing).

// LinqPad .ReplaceAll and SafeFileName
void Main()
{

	("a:B:C").Replace(":", "_").Dump();						// can only replace 1 character for one character => a_B_C
	("a:B:C").Replace(":", null).Dump();					// null replaces with empty => aBC
	("a:B*C").Replace(":", null).Replace("*",null).Dump();	// Have to chain for multiples 
	
	// Need a ReplaceAll, so I don't have to chain calls
	
	
	("abc/123.txt").SafeFileName().Dump();
	("abc/1/2/3.txt").SafeFileName().Dump();
	("a:bc/1/2/3.txt").SafeFileName().Dump();
	("a:bc/1/2/3.txt").SafeFileName('_').Dump();
	//("abc/123").SafeFileName(':').Dump(); // Throws exception as expected

}


static class StringExtensions
{

	public static string SafeFileName(this string value, char? replacement = null)
	{
		return value.ReplaceAll(replacement, ':','*','?','"','<','>', '|', '/', '\\');
	}
	
	public static string ReplaceAll(this string value, char? replacement, params char[] charsToGo){
	
		if(replacement.HasValue == false){
				return string.Join("", value.AsEnumerable().Where(x => charsToGo.Contains(x) == false));
		}
		else{
				
			if(charsToGo.Contains(replacement.Value)){
				throw new ArgumentException(string.Format("Replacement '{0}' is invalid.  ", replacement), "replacement");
			}
		
			return string.Join("", value.AsEnumerable().Select(x => charsToGo.Contains(x) == true ? replacement : x));
		}
		
	}
	
}

If you want to remove characters that satisfy a specific condition, you may use this:

string s = "SoMEthInG";
s = new string(s.Where(c => char.IsUpper(c)).ToArray());

(This will leave only the uppercase characters in the string.)

In other words, you may "use" the string as an IEnumerable<char>, make changes on it and then convert it back to a string as shown above.

Again, this enables to not only remove a specific char because of the lambda expression, although you can do so if you change the lambda expression like this: c => c != 't'.

How about BOM, the magical character Microsoft adds to start of files (at least XML)?

public static string QuitEscChars(this string s) 
{
    return s.Replace(((char)27).ToString(), "");
}

here is how we do it : myString.Replace ('''.ToString(), "");

use

myString.Replace ("c", "")

Easiest way to blanket remove a character from string is to Trim it

cl = cl.Trim(' ');

Removes all of the spaces in a string