Is er een “Space(n)”-methode in C#/.Net?

Ik converteer een oud VB6-programma naar C# (.Net 4.0) en in één routine doet het veel stringmanipulatie en generatie. De meeste native VB6-code die het gebruikt, heeft analogen in de C#-tekenreeksklasse, bijvoorbeeld Trim(). Maar ik kan geen vervanging vinden voor Space(n), waar het blijkbaar een string genereert nspaties.

Als ik de MSDN-documentatie doorneem, lijkt er een Space()-methode voor VB.Net te zijn, maar ik kon deze niet vinden buiten een VB.Net-context. Waarom is dit? Ik dacht dat alle .Net-talen dezelfde CLR delen.

Heeft C# of .Net een generieke Space()-methode die ik in C# kan gebruiken die ik ergens over het hoofd zie?

NB Ik ben me ervan bewust dat het schrijven van oneliners om n-spaties te genereren een populaire quizvraag is en een programmeerbar-spel voor sommige programmeertalen, maar ik ben niet op zoek naar advies daarover. Als er geen native manier is om dit in C#/.Net te doen, is het eenvoudig genoeg om een ​​eenvoudige methode te schrijven; Ik wil gewoon het wiel niet opnieuw uitvinden.


Antwoord 1, autoriteit 100%

Gebruik deze constructor op System.String:

new String(' ', 10);

http://msdn.microsoft.com /nl-nl/bibliotheek/xsa4321w(v=vs.110).aspx

Hier is ook een handige extensiemethode die je kunt gebruiken (hoewel het waarschijnlijk beter is om gewoon de string-constructor te gebruiken en de extra methodeaanroep op te slaan):

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

Antwoord 2, autoriteit 18%

De klasse stringheeft een constructor die je een string geeft die bestaat uit nkopieën van een gespecificeerd teken:

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

Antwoord 3, autoriteit 12%

Ik gebruik altijd:

var myString = "".PadLeft(n);

Antwoord 4, autoriteit 11%

.NET heeft een reeks compatibiliteitsfuncties in de Microsoft.VisualBasicnaamruimte voor het converteren van oude VB-code naar .NET, een daarvan is een herschept de Spacefunctie.

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

Ik raad echter aan om de new String(' ', 10)methode te gebruiken die de andere antwoorden noemen.


Antwoord 5, autoriteit 6%

Ik vond het antwoord van GregRos leuk, maar heb het een beetje aangepast om het meer declaratief te maken en niet zo afhankelijk van aanhalingstekens waar je per ongeluk in tekst zou kunnen glippen.

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

Antwoord 6, autoriteit 5%

Als iemand de spatiefunctie in VB gebruikt, is dat meestal omdat hij strings aaneenvoegt en een spatie of spaties aan de rechterkant nodig heeft.

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)

Een eenvoudige manier om de Space-functie te misleiden bij het overzetten van de code, is om duidelijk een functie te maken die deze in C# nabootst.

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

Ik zou willen dat het VB-team de oude lelijke (vroeger mooie) tekenreeksfuncties afkeurde van oudere versies van de taalspecificatie die gestroomlijnd zijn in .NET en werken in de coole zoals Space. Mijn excuses voor de originele vraagposter, aangezien je op zoek was naar een native functie in C # voor VBs Space-functie.


Antwoord 7

Strings. Ruimtebestaat in Microsoft.VisualBasic.dll. Dit lijkt om twee redenen “ingebouwd” in VB.NET in tegenstelling tot C#:

  • Terwijl C# using-instructies vereist, staat de VB.NET-compiler toe dat automatische imports worden geconfigureerd (en is Microsoft.VisualBasicopgenomen in de standaardconfiguratie).

  • VB behandelt “module”-leden als globale functies (let op de [StandardModuleAttribute]op de Stringsklasse).

Maar ja, je zou een verwijzing naar Microsoft.VisualBasic.dllkunnen toevoegen en schrijven:

using Microsoft.VisualBasic;
...
Strings.Space(n)

Natuurlijk was de reden dat deze methoden bestaan, voornamelijk om te voorkomen dat VB6-ontwikkelaars opnieuw worden opgeleid. Als u de tijd neemt om de toepassing te converteren, kunt u deze waarschijnlijk beter opnieuw implementeren met .NET-functies zoals tekenreeksen opmaken.


Antwoord 8

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

Other episodes