Est-ce que le nombre maximal de caractères peut être défini dans les chaînes de format C # comme dans C printf?

N'ai pas trouver comment faire. Ce que j'ai trouvé était plus ou moins sur les lignes de ce (http://blog.stevex.net/string-formatting-in-csharp/):

Il n'y a vraiment pas de mise en forme au sein d'une chaîne, au-delà de l'alignement. L'alignement fonctionne pour n'importe quel argument étant imprimé dans une Chaîne de caractères.Le Format de l'appel.
L'Échantillon Génère

String.Format(“->{1,10}<-”, “Hello”);  //gives "->     Hello<-" (left padded to 10)
String.Format(“->{1,-10}<-”, “Hello”); //gives "->Hello     <-" (right padded to 10)

source d'informationauteur char m

  1. 7

    Ce que vous voulez n'est pas "nativement" pris en charge par le C# mise en forme de chaîne, comme le String.ToString méthodes de l'objet string juste retour de la chaîne elle-même.

    Lorsque vous appelez 

    string.Format("{0:xxx}",someobject);

    si someobject met en œuvre la IFormattable interface, la surcharge ToString(string format,IFormatProvider formatProvider) méthode est appelée, avec "xxx" comme format paramètre.

    Donc, au plus, ce n'est pas un défaut dans la conception de .NET mise en forme de chaîne, mais juste un manque de fonctionnalité dans la classe string.

    Si vous en avez vraiment besoin, vous pouvez utiliser l'une des solutions de contournement proposées, ou créer votre propre classe de mise en œuvre de IFormattable interface.

  2. 0

    Ne pouvez pas vous venez de demander la longueur des arguments en utilisant le paramètre plutôt que sur le format?

    Chaîne.Format("->{0}<-", toFormat.PadRight(10)); //->Bonjour <-

    Ou écrire votre propre formateur pour vous permettre de faire cela?

  3. 0

    Pourquoi ne pas simplement utiliser Substr pour limiter la longueur de votre chaîne?

    String s = "abcdefghijklmnopqrstuvwxyz";
String.Format("Character limited: {0}", s.Substr(0, 10));
  4. 0

    J'ai écrit un module de formatage personnalisé qui met en œuvre un "L" spécificateur de format utilisé pour définir la largeur maximale. C'est utile quand on a besoin de contrôler la taille de notre sortie formatée dire lorsqu'ils sont destinés à une colonne de base de données ou Dynamics CRM champ.

    public class StringFormatEx : IFormatProvider, ICustomFormatter
{
///<summary>
///ICustomFormatter member
///</summary>
public string Format(string format, object argument, IFormatProvider formatProvider)
{
#region func-y town
Func<string, object, string> handleOtherFormats = (f, a) => 
{
var result = String.Empty;
if (a is IFormattable) { result = ((IFormattable)a).ToString(f, CultureInfo.CurrentCulture); }
else if (a != null) { result = a.ToString(); }
return result;
};
#endregion
//reality check.
if (format == null || argument == null) { return argument as string; }
//perform default formatting if arg is not a string.
if (argument.GetType() != typeof(string)) { return handleOtherFormats(format, argument); }
//get the format specifier.
var specifier = format.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture);
//perform extended formatting based on format specifier.
switch(specifier)
{
case "L": 
return LengthFormatter(format, argument);
default:
return handleOtherFormats(format, argument);
}
}
///<summary>
///IFormatProvider member
///</summary>
public object GetFormat(Type formatType)
{
if (formatType == typeof(ICustomFormatter))
return this;
else
return null;
}
///<summary>
///Custom length formatter.
///</summary>
private string LengthFormatter(string format, object argument)
{
//specifier requires length number.
if (format.Length == 1)
{
throw new FormatException(String.Format("The format of '{0}' is invalid; length is in the form of Ln where n is the maximum length of the resultant string.", format));
}
//get the length from the format string.
int length = int.MaxValue;
int.TryParse(format.Substring(1, format.Length - 1), out length);
//returned the argument with length applied.
return argument.ToString().Substring(0, length);
}
}

    Utilisation est

    var result = String.Format(
new StringFormatEx(),
"{0:L4} {1:L7}",
"Stack",
"Overflow");
Assert.AreEqual("Stac Overflo", result);
  5. 0

    Ce n'est pas une réponse sur la façon d'utiliser des chaînes de caractères.format, mais une autre façon de raccourcissement d'une chaîne à l'aide de méthodes d'extension. De cette façon, vous avez la possibilité d'ajouter de la longueur maximum de la chaîne directement, même sans chaîne.format.

    public static class ExtensionMethods
{
///<summary>
/// Shortens string to Max length
///</summary>
///<param name="input">String to shortent</param>
///<returns>shortened string</returns>
public static string MaxLength(this string input, int length)
{
if (input == null) return null;
return input.Substring(0, Math.Min(length, input.Length));
}
}

    exemple d'utilisation:

    string Test = "1234567890";
string.Format("Shortened String = {0}", Test.MaxLength(5));
string.Format("Shortened String = {0}", Test.MaxLength(50));
Output: 
Shortened String = 12345
Shortened String = 1234567890