Comment Conditionnellement Format d'une Chaîne .Net?

Je voudrais faire une condition de formatage de chaînes de caractères. Je sais que vous pouvez faire un peu de mise en forme conditionnelle des nombres entiers et décimaux comme suit:

Int32 i = 0;
i.ToString("$#,##0.00;($#,##0.00);Zero");

Le code ci-dessus entraînerait dans un des trois formats si la variable est positif, négatif ou nul.

Je voudrais savoir si il existe un moyen d'utiliser des sections sur les arguments de la chaîne. Pour un béton, mais artificiel exemple, je serais à la recherche pour remplacer le "si" vérifier dans le code suivant:

string MyFormatString(List<String> items, List<String> values)
{
    string itemList = String.Join(", " items.ToArray());
    string valueList = String.Join(", " values.ToArray());

    string formatString;

    if (items.Count > 0)
    //this could easily be: 
    //if (!String.IsNullOrEmpty(itemList))
    {
        formatString = "Items: {0}; Values: {1}";
    }
    else
    {
        formatString = "Values: {1}";
    }

    return String.Format(formatString, itemList, valueList);
}

InformationsquelleAutor Adam Tegen | 2008-09-30

.net c#string string.format

34

Bien, vous pouvez simplifier un peu avec l'opérateur conditionnel:
```
string formatString = items.Count > 0 ? "Items: {0}; Values: {1}" : "Values: {1}";
return string.Format(formatString, itemList, valueList);
```
Ou même inclure dans la même déclaration:
```
return string.Format(items.Count > 0 ? "Items: {0}; Values: {1}" : "Values: {1}",
                     itemList, valueList);
```
Est-ce que vous êtes après? Je ne pense pas que vous pouvez avoir une seule chaîne de format qui inclut parfois bits et parfois ça ne marche pas.
- Je ne sais pas pourquoi cela a été voté en bas, étant donné qu'il fonctionne certes... Tous les électeurs de soins pour m'éclairer? C'est toujours agréable de savoir pourquoi les gens n'aiment pas les réponses - elle la rend plus facile pour les rendre meilleurs à l'avenir.
- La Religion probablement.... j'avais suppose que l'utilisation de l'opérateur ternaire
- Simplifier? Absolument lol. À l'aide de ternaire if dans ce contexte est absolument étrange. 1. Que faire si il y a un troisième cas? 2. Que pensez-vous atteindre par cette approche - 2 lignes de code plus court?
- Si il y a plus de deux cas, je regarderais exactement ce que ces cas ont été. J' à utiliser une instruction switch. Mais j'ai vraiment cela comme une façon de plus simple que d'utiliser des if/else. Si vous n'êtes pas terriblement à l'aise avec l'opérateur conditionnel, c'est très bien - mais je suis clairement pas le seul à penser que ça simplifie le code, étant donné que la majorité des réponses suggèrent la même chose. Ce qui vous fait penser que c'est "absolument " bizarre"? (Il ne s'appelle pas "ternaire si", par le chemin - c'est l'opérateur conditionnel.)
- Skeet: êtes-vous de ceux qui ont 24" de large à écran affiche? 😉 Concernant ternaire si, à la lecture de wiki: "Depuis cet opérateur est souvent le seul opérateur ternaire dans la langue, il est parfois appelé simplement "l'opérateur ternaire", même si elle est plus précisément appelé l'opérateur conditionnel". Ternaire si est tout à fait légal et compréhensible.
- opérateur ternaire" est assez mauvais à mon avis; ternaire "si" est le pire de l'OMI. Pourquoi ne pas simplement utiliser le nom qu'il a été donné dans la spécification du langage? Comme il arrive, il travail, j'ai deux grands écrans... mais j'ai régulièrement le code sur un netbook trop, et toujours trouver de l'opérateur conditionnel utile et plus lisible qu'un inutile if déclaration. À l'aide d'un conditionnel donne l'extra indice pour le lecteur que tous ce qui change, c'est l'évaluation d'une expression unique.
- Skeet: Seriez-vous d'accord que f(x) est toujours mieux que f(g(x))?
- J'avais besoin d'un exemple plus spécifique - en particulier, si le fait de f(g(x)) travail exige f plus complexe. Si les deux f(x) et f(g(x)) de travail pour toutes les valeurs de x, puis g doit être une fonction d'identification. En supposant que ce n'est pas de quoi vous parlez, vous avez besoin de clarifier ce que vous voulez dire.
- Skeet: je parle de func(new A(new B())), un.b.c.d.e.f() et les autres vs absolument stupide et explicite approche où chaque ligne de code est aussi simple que possible: b = new B(); a = new A(b); func(a); Pour moi, c'est absolument la même impression(une ? b : c)
- Vous n'avez donc jamais plus d'une expression par instruction, et ne jamais utiliser l'opérateur conditionnel à tous? Sonne comme une recette pour le code ennuyeux pour moi. Il y a une place pour la division de choses (j'ai juste répondu à une autre question, le long de ces lignes, là où en faire trop dans l'une expression rend difficile à diagnostiquer un problème), mais il y a aussi un équilibre à avoir. Vous devez vous vraiment la haine LINQ, pourquoi vous êtes encouragés à utiliser la composition à la chaîne un tas d'activités...
- Skeet: ne pas mélanger les Dsl et je-peut-écrire-un-compilateur-dans-un-seul-ligne. Je suis un grand fan de Stimuler l'Esprit (il ne l'est pas .NET, tout de même) et j'ai passé 3 mois pour réaliser ma propre version, juste pour comprendre comment il fonctionne. Ce sont des choses différentes.
- Donc, le chaînage des propriétés d'ensemble est un gros no-no, mais le chaînage des appels de méthode est bien? Me semble étrange. Je pense que nous allons être d'accord d'être en désaccord - votre position semble extrême pour moi. Il y a un équilibre à trouver, et je n'ai certainement jamais suggéré que c'est une super idée de faire un énorme quantités en une seule déclaration, - mais ici, nous avons trois expressions simples et un simple appel de méthode, de sorte qu'il semble tout à fait bien de les combiner entre eux via l'opérateur conditionnel.
- Cette technique fonctionne très bien pour la mise en forme ItemTemplate de texte dans des Formulaires Web conditionnelle. Jamais pensé à placer l' ? opérateur à l'intérieur d'une Chaîne.Fonction Format avant.
- Ce qui est bien pratique. Le seul ennuyeux, gotcha est que la coloration syntaxique l'habitude de travailler, au moins sur Visual Studio 2013.
InformationsquelleAutor Jon Skeet

Pas dans la Corde.Format(), mais vous pouvez utiliser le C#'s inline opérateurs, tels que:

return items.Count > 0 
       ? String.Format("Items: {0}; Values: {1}", itemList, valueList)
       : String.Format("Values: {0}", valueList);

Cela permettrait de ranger le code.

InformationsquelleAutor Chris Wenham

Tandis que ne pas répondre à l'OP, directement, ce ne tombent dans la propriété ainsi.

J'ai souvent besoin de chaînes de format avec une certaine mesure, à l'unité, mais dans le cas où je n'ai pas de données, je ne veux pas de sortie du tout. - Je l'utiliser avec différents types nullables:

///<summary>
///Like String.Format, but if any parameter is null, the nullOutput string is returned.
///</summary>
public static string StringFormatNull(string format, string nullOutput, params object[] args)
{
    return args.Any(o => o == null) ? nullOutput : String.Format(format, args);
}

Par exemple, si je suis mise en forme des températures comme "20°C", mais la rencontre d'une valeur null, il permet d'imprimer une autre chaîne, au lieu de "°C".

double? temp1 = 20.0;
double? temp2 = null;

string out1 = StringFormatNull("{0}°C", "N/A", temp1); //"20°C"
string out2 = StringFormatNull("{0}°C", "N/A", temp2); //"N/A"

InformationsquelleAutor JYelton

2
```
string.Format(  (items.Count > 0 ? "Items: {0}; " : "") + "Values {1}"
              , itemList
              , valueList); 
```
- Pourriez-vous m'indiquer la documentation qui indique le peu sur, commençant à 0 et n'ayant pas d'numéros manquants?
- Je me trompe--j'ai été de le confondre avec l'obligation pour tous de l'espace réservé valeurs sont inférieures à la longueur de la liste d'arguments. Les arguments Null sont très bien comme elles sont transformées en chaînes vides.
InformationsquelleAutor Mark Cidade
1

Ne le faites pas. Je n'ai aucune idée de ce que sont les objets et les valeurs dans le code, mais je crois que, cette paire pourrait être traitée comme une entité quelconque. Définir cette entité en tant que classe, et de remplacer son ToString() méthode pour retourner tout ce que vous voulez. Il n'y a absolument rien de mal à avoir if pour décider de la façon de format de cette chaîne de caractères en fonction d'un contexte.

InformationsquelleAutor Andrey Agibalov
1

Ce n'est probablement pas ce que vous cherchez, mais que diriez -...
```
formatString = (items.Count > 0) ? "Items: {0}; Values: {1}" : "Values: {1}";
```
InformationsquelleAutor Kon
0

J'espère que ce pourrait le faire:
```
return String.Format(items.ToString(itemList + " ;;") + "Values: {0}", valueList);
```
Malheureusement, il semble que l' .La méthode ToString() n'aime pas le vide négatif et nul options ou de ne pas avoir un # ou 0 partout. Je vais laisser ici, dans le cas des points de quelqu'un d'autre pour une meilleure réponse.

InformationsquelleAutor Joel Coehoorn

Vous devez vous connecter pour publier un commentaire.