Jak ograniczyć tekst w Eval

Question

Mam hiperłącze z właściwością nawigacja ustawiony tak:

NavigateUrl='<%# Eval("My Text") %>' 

Jak mogę ograniczyć ciąg do 140 znaków? Próbowałem tego Eval ("Mój tekst"). ToString(). Substring (0,140), ale jeśli długość ciągu jest mniejsza niż 140 znaków, zgłasza wyjątek.

Answer 1

a jednak inna możliwość:

Eval("My Text").ToString().PadRight(140).Substring(0,140).TrimEnd() 

Edit:

lubię LINQ też:

Eval("My Text").ToString().Take(140).Aggregate("", (x,y) => x + y) 

Answer 2

Można spróbować metody obciąć jak pokazano tutaj:

C# Truncate String

przekonwertować go na metodę rozszerzenia poprzez dodanie słowa kluczowego this przed parametru source. Jest to podejście bardziej zawiłe, ale może mieć znaczenie w przypadkach, gdy trzeba go gdzieś indziej ponowne ...

W twoim przypadku, trzeba:

NavigateUrl='<%# Eval("My Text").ToString().Truncate(140) %>' 

Kompletna aplikacji testowej konsoli:

using System; 

namespace ConsoleApplication2 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      string test1 = "A really big string that has more than 140 chars. This string is supposed to be trunctaded by the Truncate extension method defined in class StringTool."; 

      Console.WriteLine(test1.Truncate(140)); 

      Console.ReadLine(); 
     } 
    } 

    /// <summary> 
    /// Custom string utility methods. 
    /// </summary> 
    public static class StringTool 
    { 
     /// <summary> 
     /// Get a substring of the first N characters. 
     /// </summary> 
     public static string Truncate(this string source, int length) 
     { 
      if (source.Length > length) 
      { 
       source = source.Substring(0, length); 
      } 
      return source; 
     } 

     /// <summary> 
     /// Get a substring of the first N characters. [Slow] 
     /// </summary> 
     public static string Truncate2(this string source, int length) 
     { 
      return source.Substring(0, Math.Min(length, source.Length)); 
     } 
    } 
} 

wyjściowa:

A really big string that has more than 140 chars. This string is supposed to be 
trunctaded by the Truncate extension method defined in class 

Answer 3

Cholera Lubię LINQ:

string.Concat('<%# Eval("My Text") %>'.ToString().Where((char, index) => index < 140)) 

Answer 4

go używać (:

< % # Eval("MyText").ToString().Length <= 30 ? Eval("MyText") : Eval("MyText").ToString().Substring(0, 30)+"..." % > 

Answer 5

podobne do Odpowiedź Leniela, ale z niespodzianką .... Czasami lubię dołączać elipsę, aby zademonstrować, że wyświetlony ciąg znaków został obcięty.

/// <summary> 
    /// Converts the value of the specified string to a truncated string representation 
    /// </summary> 
    /// <param name="source">The specified string</param> 
    /// <param name="length">Integer specifying the maximum number of characters to retain from the specified string.</param> 
    /// <param name="appendEllipsis">Determines whether or not to append an ellipsis to the truncated result. If the specified string is shorter than the length parameter the ellipsis will not be appended in any event.</param> 
    /// <returns>A truncated string representation of the specified string.</returns> 
    public static String Truncate(this String source, int length, bool appendEllipsis = false) 
    { 
     if (source.Length <= length) 
      return source; 

     return (appendEllipsis) 
      ? String.Concat(source.Substring(0, length), "...") 
      : source.Substring(0, length); 
    }