Jaka metoda w klasie String zwraca tylko pierwsze N ​​znaków?

Chciałbym napisać metodę rozszerzenia do Stringklasy, aby jeśli ciąg wejściowy był dłuższy niż podana długość N, wyświetlane były tylko pierwsze Nznaki.

Oto jak to wygląda:

public static string TruncateLongString(this string str, int maxLength)
{
    if (str.Length <= maxLength)
        return str;
    else
        //return the first maxLength characters                
}

Jakiej String.*()metody mogę użyć, aby uzyskać tylko pierwsze Nznaki str?

public static string TruncateLongString(this string str, int maxLength)
{
    if (string.IsNullOrEmpty(str))
        return str;
    return str.Substring(0, Math.Min(str.Length, maxLength));
}

string truncatedToNLength = new string(s.Take(n).ToArray());  

To rozwiązanie ma niewielką zaletę, ponieważ jeśli n jest większe niż s.Length, nadal robi to dobrze.

Możesz użyć LINQ str.Take(n)lub str.SubString(0, n), jeśli ten ostatni zgłosi ArgumentOutOfRangeExceptionwyjątek n > str.Length.

Pamiętać, że wersja LINQ zwraca IEnumerable<char>, więc trzeba by przekonwertować IEnumerable<char>do string: new string(s.Take(n).ToArray()).

Ilekroć muszę wykonywać operacje na łańcuchach w C #, tęsknię za starym dobrym Lefti Rightfunkcjami Visual Basic, które są znacznie prostsze w użyciu niż Substring.

Dlatego w większości moich projektów w języku C # tworzę dla nich metody rozszerzeń:

public static class StringExtensions
{
    public static string Left(this string str, int length)
    {
        return str.Substring(0, Math.Min(length, str.Length));
    }

    public static string Right(this string str, int length)
    {
        return str.Substring(str.Length - Math.Min(length, str.Length));
    }
}

Uwaga: część jest tam, ponieważ rzuca gdy długość ciągu wejściowego jest mniejszy niż żądanej długości, jak już wspomniano w niektórych komentarzach pod poprzednimi odpowiedziami.
Math.MinSubstringArgumentOutOfRangeException

Stosowanie:

string longString = "Long String";

// returns "Long";
string left1 = longString.Left(4);

// returns "Long String";
string left2 = longString.Left(100);

Po prostu:

public static String Truncate(String input,int maxLength)
{
   if(input.Length > maxLength)
      return input.Substring(0,maxLength);
   return input;
}

public static string TruncateLongString(this string str, int maxLength)
{
    return str.Length <= maxLength ? str : str.Remove(maxLength);
}

jeśli mówimy o sprawdzaniu poprawności, to dlaczego nie sprawdziliśmy, czy nie ma pozycji pustych. Jakieś konkretne powody?

Myślę, że poniżej sposób pomocy, ponieważ IsNullOrEmpty jest metodą zdefiniowaną przez system, a operatory trójskładnikowe mają cykliczną złożoność = 1, podczas gdy if () {} else {} ma wartość 2.

    public static string Truncate(string input, int truncLength)
    {
        return (!String.IsNullOrEmpty(input) && input.Length >= truncLength)
                   ? input.Substring(0, truncLength)
                   : input;
    }

Dodałem to do mojego projektu tylko dlatego, że tam, gdzie go używam, jest duża szansa, że ​​zostanie on użyty w pętlach, w projekcie prowadzonym online, dlatego nie chciałem żadnych awarii, gdybym mógł to zarządzać. Długość pasuje do kolumny, którą mam. To jest C # 7

Tylko jedna linia:

 public static string SubStringN(this string Message, int Len = 499) => !String.IsNullOrEmpty(Message) ? (Message.Length >= Len ? Message.Substring(0, Len) : Message) : "";

Metoda .NET Substring jest pełna niebezpieczeństw. Opracowałem metody rozszerzeń, które obsługują wiele różnych scenariuszy. Zaletą jest to, że zachowuje oryginalne zachowanie, ale po dodaniu dodatkowego parametru „true” następnie stosuje metodę rozszerzenia do obsługi wyjątku i zwraca najbardziej logiczne wartości, w oparciu o indeks i długość. Na przykład, jeśli długość jest ujemna i liczy się wstecz. Możesz zobaczyć wyniki testu z szeroką gamą wartości na skrzypcach pod adresem : https://dotnetfiddle.net/m1mSH9 . To da ci jasny obraz tego, jak rozwiązuje podciągi.

Zawsze dodaję te metody do wszystkich moich projektów i nigdy nie muszę się martwić o złamanie kodu, ponieważ coś się zmieniło, a indeks jest nieprawidłowy. Poniżej znajduje się kod.

    public static String Substring(this String val, int startIndex, bool handleIndexException)
    {
        if (!handleIndexException)
        { //handleIndexException is false so call the base method
            return val.Substring(startIndex);
        }
        if (string.IsNullOrEmpty(val))
        {
            return val;
        }
        return val.Substring(startIndex < 0 ? 0 : startIndex > (val.Length - 1) ? val.Length : startIndex);
    }

    public static String Substring(this String val, int startIndex, int length, bool handleIndexException)
    {
        if (!handleIndexException)
        { //handleIndexException is false so call the base method
            return val.Substring(startIndex, length);
        }
        if (string.IsNullOrEmpty(val))
        {
            return val;
        }
        int newfrom, newlth, instrlength = val.Length;
        if (length < 0) //length is negative
        {
            newfrom = startIndex + length;
            newlth = -1 * length;
        }
        else //length is positive
        {
            newfrom = startIndex;
            newlth = length;
        }
        if (newfrom + newlth < 0 || newfrom > instrlength - 1)
        {
            return string.Empty;
        }
        if (newfrom < 0)
        {
            newlth = newfrom + newlth;
            newfrom = 0;
        }
        return val.Substring(newfrom, Math.Min(newlth, instrlength - newfrom));
    }

Napisałem o tym na blogu w maju 2010 r. Pod adresem: http://jagdale.blogspot.com/2010/05/substring-extension-method-that-does.html

Częściowo ze względu na podsumowanie (z wyłączeniem rozwiązania LINQ), oto dwie jednowierszowe, które rozwiązują problem int maxLengthdopuszczenia wartości ujemnych, a także przypadku łańcucha zerowego:

1. SubstringSposób (z odpowiedzią Paul Ruane użytkownika ):

public static string Truncate(this string s, uint maxLength) =>
    s?.Substring(0, Math.Min(s.Length, (int)maxLength));

2. RemoveSposób (z odpowiedzią kbrimington użytkownika ):

public static string Truncate(this string s, uint maxLength) =>
    s?.Length > maxLength ? s.Remove((int)maxLength) : s;

substring(int startpos, int lenght);

string.Substring (0, n); // 0 - indeks początkowy in - liczba znaków