¿Hay un método de "Espacio(n)" en C#/.Net?

Question

Estoy convirtiendo un antiguo programa VB6 a C # (.Net 4.0) y en una rutina hace mucha manipulación y generación de cadenas. La mayoría del código VB6 nativo que utiliza tiene análogos en la clase de cadena C #, por ejemplo, Trim () . Pero parece que no puedo encontrar un reemplazo para Space ( n ) , donde aparentemente genera una cadena n espacios.

Al examinar la documentación de MSDN, parece que hay un método Space () para VB.Net, pero no pude encontrarlo mencionado fuera de un contexto de VB.Net. ¿Por qué es esto? Pensé que todos los lenguajes .Net comparten el mismo CLR.

¿C # o .Net tienen un método genérico de Espacio () que puedo usar en C # que simplemente estoy pasando por alto en algún lugar?

NB: Soy consciente de que escribir una sola línea para generar n-espacios es un cuestionario popular y un juego de barra de programadores para algunos lenguajes de programación, pero no estoy buscando consejos al respecto. Si no hay una forma nativa de hacer esto en C # /. Net, es bastante fácil escribir un método simple; Simplemente no quiero reinventar la rueda.

Answer 1

.NET tiene un conjunto de funciones de compatibilidad en el espacio de nombres Microsoft.VisualBasic para convertir el código antiguo de VB a .NET, una de ellas es una recreación de la función Space .

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

Sin embargo, recomiendo usar el new String('' '', 10) método new String('' '', 10) que mencionan las otras respuestas.

Answer 2

Generalmente, cuando alguien está usando la función de espacio en VB es porque están concatenando cadenas y necesitan un espacio o espacios a la derecha.

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)

Un enfoque simple para engañar a la función de Espacio cuando se transfiere el código es, obviamente, crear una función que lo imite en C #.

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

Desearía que el equipo de VB desechara las antiguas funciones de cadenas feas (que solían ser bonitas) de versiones anteriores de la especificación de lenguaje que se han simplificado en .NET y que funcionen en las geniales como Space. Mis disculpas al póster de la pregunta original mientras buscaba una función nativa en C # para la función VBs Space.

Answer 3

La clase de string tiene un constructor que le proporciona una cadena que consta de n copias de un carácter específico:

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

Answer 4

Yo siempre uso:

var myString = "".PadLeft(n);

Answer 5

Space existe en Microsoft.VisualBasic.dll . Esto parece estar "integrado" en VB.NET en lugar de C # por dos razones:

• Mientras que C # requiere el using sentencias, el compilador VB.NET permite que las importaciones automáticas se configuren (y Microsoft.VisualBasic está incluido en la configuración predeterminada).

• VB trata a los miembros del "módulo" como funciones globales (tenga en cuenta [StandardModuleAttribute] en la clase Strings ).

Pero sí, podría agregar una referencia a Microsoft.VisualBasic.dll y escribir:

using Microsoft.VisualBasic;

...

Strings.Space(n)

Por supuesto, la razón por la que existen estos métodos fue principalmente para evitar volver a capacitar a los desarrolladores de VB6. Si se está tomando el tiempo para convertir la aplicación, probablemente sería mejor que la reimplementara utilizando las características de .NET como cadenas de formato .

Answer 6

Utilice este constructor en System.String :

new String('' '', 10);

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

Aquí también hay un método de extensión que puede usar (aunque probablemente sea mejor usar el constructor String y guardar la llamada al método adicional):

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

Answer 7

//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");
        }
    }
}