.NET Formate uma string com espaços fixos

O método .NET String.Format permite o posicionamento de uma string em uma posição fixa dentro de uma string de comprimento fixo.

"A corda vai aqui"
"A corda vai aqui"
"A corda vai aqui"

Como isso é feito usando o .NET?

Editar - Tentei Format / PadLeft / PadRight até a morte. Eles não trabalham. Não sei porque. Acabei escrevendo minha própria função para fazer isso.

Editar - cometi um erro e usei dois pontos em vez de vírgula no especificador de formato. Deve ser "{0,20}".

Obrigado por todas as respostas excelentes e corretas.

Isso fornecerá exatamente as sequências solicitadas:

string s = "String goes here";
string lineAlignedRight  = String.Format("{0,27}", s);
string lineAlignedCenter = String.Format("{0,-27}",
    String.Format("{0," + ((27 + s.Length) / 2).ToString() +  "}", s));
string lineAlignedLeft   = String.Format("{0,-27}", s);

O primeiro e o último, pelo menos, são possíveis usando a seguinte sintaxe:

String.Format("{0,20}", "String goes here");
String.Format("{0,-20}", "String goes here");

No Visual Studio 2015, você também pode fazer isso com seqüências de caracteres interpoladas (é um truque do compilador, portanto, não importa qual versão da estrutura .net você segmentar).

string value = "String goes here";
string txt1 = $"{value,20}";
string txt2 = $"{value,-20}";

Você foi mostrado PadLefte PadRight. Isso preencherá os desaparecidos PadCenter.

public static class StringUtils
{
    public static string PadCenter(this string s, int width, char c)
    {
        if (s == null || width <= s.Length) return s;

        int padding = width - s.Length;
        return s.PadLeft(s.Length + padding / 2, c).PadRight(width, c);
    }
}

Nota para si mesmo: não se esqueça de atualizar seu próprio currículo: "Um dia, eu até consertei o código de Joel Coehoorn!" ;-D -Serge

tente isto:

"String goes here".PadLeft(20,' ');
"String goes here".PadRight(20,' ');

para o centro, pegue o comprimento da corda e remova com o caráter necessário

int len = "String goes here".Length;
int whites = len /2;
"String goes here".PadRight(len + whites,' ').PadLeft(len + whites,' ');

Obrigado pela discussão, este método também funciona (VB):

Public Function StringCentering(ByVal s As String, ByVal desiredLength As Integer) As String
    If s.Length >= desiredLength Then Return s
    Dim firstpad As Integer = (s.Length + desiredLength) / 2
    Return s.PadLeft(firstpad).PadRight(desiredLength)
End Function

1. StringCentering () usa dois valores de entrada e retorna uma string formatada.
2. Quando o comprimento de s é maior ou igual a deisredLength , a função retorna a sequência original.
3. Quando o comprimento de s for menor que o comprimento desejado , ele será preenchido nas duas extremidades.
4. Como o espaçamento entre caracteres é inteiro e não há meio espaço, podemos ter uma divisão desigual do espaço. Nesta implementação, a maior divisão vai para o ponto principal.
5. A função requer o .NET Framework devido a PadLeft () e PadRight () .
6. Na última linha da função, a ligação é da esquerda para a direita; portanto, o primeiro bloco é aplicado seguido pelo bloco de comprimento desejado .

Aqui está a versão do C #:

public string StringCentering(string s, int desiredLength)
{
    if (s.Length >= desiredLength) return s;
    int firstpad = (s.Length + desiredLength) / 2;
    return s.PadLeft(firstpad).PadRight(desiredLength);
}

Para ajudar no entendimento, a variável inteira firstpad é usada. s.PadLeft (firstpad) aplica o (número correto de) espaços em branco à esquerda. O PadRight mais à direita (comprimento desejado) tem uma ligação mais baixa finalizando aplicando espaços em branco à direita.

Aqui está uma versão do VB.NET que eu criei, inspirada na resposta de Joel Coehoorn, na edição de Oliver e no comentário de shaunmartin:

    <Extension()>
Public Function PadCenter(ByVal [string] As String, ByVal width As Integer, ByVal c As Char) As String

    If [string] Is Nothing Then [string] = String.Empty
    If (width <= [string].Length) Then Return [string]

    Dim padding = width - [string].Length
    Return [string].PadLeft([string].Length + (padding \ 2), c).PadRight(width, c)

End Function

<Extension()>
Public Function PadCenter(ByVal [string] As String, ByVal width As Integer) As String

    If [string] Is Nothing Then [string] = String.Empty
    If (width <= [string].Length) Then Return [string]

    Dim padding = width - [string].Length
    Return [string].PadLeft([string].Length + (padding \ 2)).PadRight(width)

End Function

Isso é configurado como uma extensão de string, dentro de um Módulo Público (da maneira que você faz Extensões no VB.NET, um pouco diferente de C #). Minha pequena alteração é que ela trata uma string nula como uma string vazia e preenche uma string vazia com o valor de largura (atende às minhas necessidades particulares). Esperemos que isso seja convertido facilmente em c # para quem precisar. Se houver uma maneira melhor de fazer referência às respostas, edições e comentários que mencionei acima, que inspiraram minha postagem, informe-me e o farei - eu sou relativamente novo na postagem e não consegui descobrir deixe um comentário (talvez ainda não tenha representante suficiente).

Publiquei um artigo do CodeProject que pode ser o que você deseja.

Consulte: Caminho AC # para largura indireta e formatação de estilo.

Basicamente, é um método, FormatEx, que age como String.Format, exceto que permite um modificador de alinhamento centralizado.

FormatEx("{0,c10}", value);

Significa centralizar o valor de varArgs [0] em um campo amplo de 10 caracteres; incline-se para a direita se for necessário um espaço de preenchimento extra.

FormatEx("{0,c-10}", value);

Significa centralizar o valor de varArgs [0] em um campo amplo de 10 caracteres; incline-se para a esquerda se for necessário um espaço de preenchimento extra.

Edit: Internamente, é uma combinação do PadCenter de Joel com algumas análises para reestruturar o formato e os varArgs para uma chamada para String.Format que faz o que você deseja.

-Jesse

parece que você deseja algo assim, que o colocará em um ponto fixo em um comprimento constante:

Dim totallength As Integer = 100
Dim leftbuffer as Integer = 5
Dim mystring As String = "string goes here"
Dim Formatted_String as String = mystring.PadLeft(leftbuffer + mystring.Length, "-") + String.Empty.PadRight(totallength - (mystring.Length + leftbuffer), "-")

Observe que isso terá problemas se mystring.length + leftbuffer exceder o comprimento total

/// <summary>
/// Returns a string With count chars Left or Right value
/// </summary>
/// <param name="val"></param>
/// <param name="count"></param>
/// <param name="space"></param>
/// <param name="right"></param>
/// <returns></returns>
 public static string Formating(object val, int count, char space = ' ', bool right = false)
{
    var value = val.ToString();
    for (int i = 0; i < count - value.Length; i++) value = right ? value + space : space + value;
    return value;
}