web-dev-qa-db-fra.com

C #: Limiter la longueur d'une chaîne?

Je me demandais simplement comment je pouvais limiter la longueur d'une chaîne en C #.

string foo = "1234567890";

Disons que nous avons ça. Comment puis-je limiter foo à 5 personnages?

c#arraysstringlimit
42
Lemmons

Les chaînes en C # sont immuables et, dans un certain sens, cela signifie qu'elles ont une taille fixe.
Cependant, vous ne pouvez pas contraindre une variable de chaîne n'accepter que des chaînes de n caractères. Si vous définissez une variable de chaîne, vous pouvez lui attribuer toute chaîne . Si la troncature des chaînes (ou les erreurs de jet) est une partie essentielle de votre logique métier, envisagez de le faire dans les paramètres de propriété de votre classe spécifique (c'est ce que Jon a suggéré, et c'est le moyen le plus naturel de créer des contraintes sur les valeurs dans .NET).

Si vous voulez simplement vous assurer que votre temps n'est pas trop long (par exemple, en le passant en tant que paramètre à un code hérité), tronquez-le manuellement:

const int MaxLength = 5;


var name = "Christopher";
if (name.Length > MaxLength)
    name = name.Substring(0, MaxLength); // name = "Chris"
68
Dan Abramov

Vous pouvez étendre la classe "string" pour vous permettre de renvoyer une chaîne limitée.

using System;

namespace ConsoleApplication1
{
   class Program
   {
      static void Main(string[] args)
      {
         // since specified strings are treated on the fly as string objects...
         string limit5 = "The quick brown fox jumped over the lazy dog.".LimitLength(5);
         string limit10 = "The quick brown fox jumped over the lazy dog.".LimitLength(10);
         // this line should return us the entire contents of the test string
         string limit100 = "The quick brown fox jumped over the lazy dog.".LimitLength(100);

         Console.WriteLine("limit5   - {0}", limit5);
         Console.WriteLine("limit10  - {0}", limit10);
         Console.WriteLine("limit100 - {0}", limit100);

         Console.ReadLine();
      }
   }

   public static class StringExtensions
   {
      /// <summary>
      /// Method that limits the length of text to a defined length.
      /// </summary>
      /// <param name="source">The source text.</param>
      /// <param name="maxLength">The maximum limit of the string to return.</param>
      public static string LimitLength(this string source, int maxLength)
      {
         if (source.Length <= maxLength)
         {
            return source;
         }

         return source.Substring(0, maxLength);
      }
   }
}

Résultat:

limite5 - Le q
limit10 - Le rapide
limit100 - Le renard brun rapide a sauté par-dessus le chien paresseux.

34
Michael

Tu ne peux pas. Gardez à l'esprit que foo est un variable de type string.

Vous pouvez créer votre propre type, par exemple BoundedString, et avoir:

BoundedString foo = new BoundedString(5);
foo.Text = "hello"; // Fine
foo.Text = "naughty"; // Throw an exception or perhaps truncate the string

... mais vous ne pouvez pas empêcher une variable de chaîne d'être définie sur une référence de chaîne (ou null).

Bien sûr, si vous avez une chaîne propriété, vous pouvez le faire:

private string foo;
public string Foo
{
    get { return foo; }
    set
    {
        if (value.Length > 5)
        {
            throw new ArgumentException("value");
        }
        foo = value;
    }
}

Cela vous aide-t-il dans votre plus grand contexte?

16
Jon Skeet

Si ceci est dans une propriété de classe, vous pouvez le faire dans le setter:

public class FooClass
{
   private string foo;
   public string Foo
   {
     get { return foo; }
     set
     {
       if(!string.IsNullOrEmpty(value) && value.Length>5)
       {
            foo=value.Substring(0,5);
       }
       else
            foo=value;
     }
   }
}
6
jmservera

string shortFoo = foo.Length > 5 ? foo.Substring(0, 5) : foo;

Notez que vous ne pouvez pas simplement utiliser foo.Substring (0, 5) tout seul, car une erreur sera générée lorsque foo contient moins de 5 caractères.

5
TTT

Voici une autre réponse alternative à ce problème. Cette méthode d'extension fonctionne assez bien. Ceci résout les problèmes de longueur de chaîne plus courte que la longueur maximale et de longueur négative également.

public static string Left( this string str, int length ) {
  if (str == null)
    return str;
  return str.Substring(0, Math.Min(Math.Abs(length), str.Length));
}

Une autre solution serait de limiter la longueur à des valeurs non négatives et de simplement supprimer les valeurs négatives.

public static string Left( this string str, int length ) {
  if (str == null)
    return str;
  return str.Substring(0, Math.Min(Math.Max(0,length), str.Length));
}
3
Archangel33

Vous pouvez éviter la déclaration if si vous la définissez à la longueur souhaitée.

string name1 = "Christopher";
string name2 = "Jay";
int maxLength = 5;

name1 = name1.PadRight(maxLength).Substring(0, maxLength);
name2 = name2.PadRight(maxLength).Substring(0, maxLength);

name1 aura Chris

name2 aura Jay

Aucune instruction si nécessaire pour vérifier la longueur avant d'utiliser la sous-chaîne

2
Chris Ward

Vous pouvez essayer comme ça:

var x= str== null 
        ? string.Empty 
        : str.Substring(0, Math.Min(5, str.Length));
2
Rahul Tripathi

La seule raison pour laquelle je peux voir le but de cette opération est le stockage de base de données. Si tel est le cas, pourquoi ne pas laisser la base de données la gérer, puis envoyer l’exception en amont pour qu’elle soit traitée au niveau de la couche de présentation?

2
Aaron McIver

Utilisez Remove () ...

string foo = "1234567890";
int trimLength = 5;

if (foo.Length > trimLength) foo = foo.Remove(trimLength);

// foo is now "12345"
0
Sunsetquest