C#: Limiter la longueur d'une chaîne de caractères? [dupliquer]

vous pouvez étendre la classe" string " pour vous permettre de retourner 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

limite10-le rapide

limit100 - Le brun rapide fox a sauté par dessus le chien paresseux.

vous ne pouvez pas. N'oubliez pas que foo est une variable de type string .

vous pouvez créer votre propre type, dire 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 string d'être définie à n'importe quelle référence string (ou null).

bien sûr, si vous avez une chaîne de caractères 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;
    }
}

Est-ce que cela vous aide dans quel que soit votre plus grand contexte?

S'il s'agit d'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;
     }
   }
}

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

notez que vous ne pouvez pas simplement utiliser foo.Substring (0, 5) par lui-même car il va lancer une erreur lorsque foo est inférieur à 5 caractères.

Voici une autre réponse alternative à cette question. Cette méthode d'extension fonctionne assez bien. Cela résout les problèmes de la chaîne est plus courte que la longueur maximale et aussi la longueur maximale étant négatif.

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 éliminer 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));
}

la seule raison pour laquelle je peux voir le but dans ce est pour le stockage DB. Si c'est le cas, pourquoi ne pas laisser le DB s'en charger et ensuite pousser l'exception en amont pour être traitée à la couche présentation?

Vous pouvez éviter les instruction si, si vous vous protégez à la longueur que vous souhaitez limiter.

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

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

nom1 aura Chris

nom2 aura Jay

non si déclaration nécessaire pour vérifier la longueur Avant d'utiliser la chaîne

vous pouvez essayer comme ceci:

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

foo = foo.Substrat (0,5);

Utiliser Supprimer () ...

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

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

// foo is now "12345"