Is there a "Space(n)" method in C#/.Net?

I'm converting an ancient VB6 program to C# (.Net 4.0) and in one routine it does lots of string manipulation and generation. Most of the native VB6 code it uses have analogues in the C# string class, e.g., Trim(). But I can't seem to find a replacement for Space(n), where it apparently generates a string n spaces.

Looking through the MSDN documentation, there seems to be a Space() method for VB.Net but I couldn't find it mentioned outside of a VB.Net context. Why is this? I thought all the .Net languages share the same CLR.

Does C# or .Net have a generic Space() method I can use in C# that I'm just overlooking somewhere?

N.B. I'm aware that writing one-liners to generate n-spaces is a popular quiz-question and programmers' bar-game for some programming languages, but I'm not looking for advice on that. If there's no native way to do this in C#/.Net it's easy enough to write a simple method; I just don't want to reinvent the wheel.

Use this constructor on System.String:

new String(' ', 10);

http://msdn.microsoft.com/en-us/library/xsa4321w(v=vs.110).aspx

Here's a neat extension method you can use, as well (although it's probably better just to use the String constructor and save the extra method call):

public static class CharExtensions
{
	public static string Repeat(this char c, int count)
	{
		return new String(c, count);
	}
}
...
string spaces = ' '.Repeat(10);

The string class has a constructor that gives you a string consisting of n copies of a specified character:

// 32 spaces
string str = new string(' ', 32);

I always use:

var myString = "".PadLeft(n);

.NET has a set of compatibility functions in the Microsoft.VisualBasic namespace for converting old VB code to .NET, one of them is a recreates the Space function.

var myString = Microsoft.VisualBasic.Strings.Space(10); //Or just Strings.Space(10); if you do "using Microsoft.VisualBasic;" at the top of your file.

However I reccomend using the new String(' ', 10) method the other answers mention.

I liked GregRos's answer but modified it a bit to make it more declarative and not so dependent on quotation marks where you could accidentally slip in text.

var myString = string.Empty.PadLeft(n);

Usually, when someone is using the space function in VB it is because they're concatenating strings and need a space or spaces to the right.

Dim strConcatVB6 As String
strConcatVB6 = "Someone" & Space(1) & "Help" & Space(1) & "Out!"
Dim strConcatNet As String = String.Concat("Someone", Space(1), "Help", Space(1), "Out!")
Debug.WriteLine(strConcatVB6)
Debug.WriteLine(strConcatNet)

A simple approach to trick the Space function when porting the code is to obviously create a function that mimics it in C#.

Func<int, string> Space = (n) => ("".PadRight(n));
string strConcat = string.Concat("Somebody", Space(1), "Help", Space(1), "Out!");
MessageBox.Show(strConcat);

I wish the VB team would deprecate the old ugly (used to be pretty) string functions from older versions of the language specification that have been streamlined in .NET and work in the cool ones like Space. My apologies to the original question poster as you were looking for a native function in C# for VBs Space function.

Strings.Space exists in Microsoft.VisualBasic.dll. This appears to be "built-in" in VB.NET as opposed to C# because of two reasons:

• While C# requires using statements, the VB.NET compiler allows automatic imports to be configured (and Microsoft.VisualBasic is included in the default configuration).

• VB treats "module" members as global functions (note the [StandardModuleAttribute] on the Strings class).

But yes, you could add a reference to Microsoft.VisualBasic.dll and write:

using Microsoft.VisualBasic;

...

Strings.Space(n)

Of course, the reason these methods exist was mainly to avoid retraining VB6 developers. If you're taking the time to convert the application, you would probably be better off reimplementing it using .NET features like format strings.

//Author: Puffgroovy
//Email: [email protected]
//
// Usage - CustomFunctions cf = new CustomFunctions();
// String strMessage = "Error Found - " + cf._DoubleQuote() + e.Message + cf._Space(23) + cf._DoubleQuote();
//


using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Threading.Tasks;


namespace DHHS_CustomFunctions
{
    class CustomFunctions
    {
        /// <summary>
        /// Same as the VB.NET Space Function
        /// </summary>
        /// <param name="intNumberOfSpaces"></param>
        /// <returns>String</returns>
        public string _Space(int intNumberOfSpaces)
        {
            return new String(' ', intNumberOfSpaces);
        }

        /// <summary>
        /// New Line Character
        /// </summary>
        /// <returns></returns>
        public string _NewLine()
        {
            return ("\n");
        }

        /// <summary>
        /// Double Quote Character
        /// </summary>
        /// <returns></returns>
        public string _DoubleQuote()
        {
            return ("\"");
        }

        /// <summary>
        /// SingleQuote Character
        /// </summary>
        /// <returns></returns>
        public string _SingleQuote()
        {
            return ("\'");
        }

        /// <summary>
        /// Calls Environment.Exit(0);
        /// </summary>
        public void _Quit()
        {
            Environment.Exit(0);
        }

        /// <summary>
        /// Returns the backslash character
        /// </summary>
        /// <returns></returns>
        public string _Backslash()
        {

            return ("\\");
        }

        /// <summary>
        /// Returns a null character
        /// </summary>
        /// <returns></returns>
        public string _Null()
        {

            return ("\0");
        }

        /// <summary>
        /// Bell. Same as Alert
        /// </summary>
        /// <returns></returns>
        public string _Bell()
        {

            return ("\a");
        }

        /// <summary>
        /// Alert. Same as Bell
        /// </summary>
        /// <returns></returns>
        public string _Alert()
        {

            return ("\a");
        }

        /// <summary>
        /// Backspace Character
        /// </summary>
        /// <returns></returns>
        public string _Backspace()
        {

            return ("\b");
        }

        /// <summary>
        /// Form Feed Character
        /// </summary>
        /// <returns></returns>
        public string _FormFeed()
        {

            return ("\f");
        }

        /// <summary>
        /// Carriage Return Character
        /// </summary>
        /// <returns></returns>
        public string _CarriageReturn()
        {

            return ("\r");`enter code here`
        }

        /// <summary>`enter code here`
        /// Vertical Tab Character
        /// </summary>
        /// <returns></returns>
        public string _VerticleTab()
        {

            return ("\v");
        }
    }
}