StringTokenizer dla .NET Core

Sep 18 2020

Dzielenie łańcucha na tokeny jest bardziej złożonym tematem niż String.Split () chce nam wmówić. Istnieją co najmniej trzy wspólne zasady, zgodnie z którymi ciąg może być interpretowany i dzielony na tokeny.

Zasada 1: odpowiednik String.Split ()

Nie ma wiele do wspominania o tej polityce. Biorąc pod uwagę ciąg si separator d, podziel się sna segmenty rozdzielone d. Główną wadą jest to, że jeśli separator jest częścią co najmniej jednego z tokenów, odtworzenie pożądanych tokenów może być kosztowne.

Zasada 2: Unikaj znaków specjalnych

Znak jest deklarowany jako znak ucieczki e (zwykle ukośnik odwrotny \), w wyniku czego znak następujący po nim traci swoje specjalne znaczenie. Łańcuch tokena może wtedy wyglądać następująco:

token_1 token_2 very\ long \ token

co byłoby równoważne z

{ "token_1", "token_2", "very long token" }

Zasada 3: Umieść tokeny w cudzysłowie

Takie podejście jest używane na przykład w plikach CSV generowanych w programie MSExcel. Wszystko w cudzysłowie jest traktowane jako symbol. Jeśli cudzysłowy "są częścią tokena, są podwajane "". Łańcuch tokena może wtedy wyglądać następująco:

token_1,token_2,"token2,5"

co byłoby równoważne z

{ "token_1", "token_2", "token2,5" }

Kod

using System;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;

namespace Pillepalle1.ConsoleTelegramBot.Model.Misc
{
    public sealed class StringTokenizer
    {
        private string _sourceString = null;                            // Provided data to split

        #region Constructors
        /// <summary>
        /// Creates a new StringTokenizer
        /// </summary>
        /// <param name="dataInput">Data to be split into tokens</param>
        public StringTokenizer(string dataInput)
        {
            _sourceString = dataInput ?? string.Empty;
        }
        #endregion

        #region Interface
        /// <summary>
        /// Access tokens by index
        /// </summary>
        public string this[int index]
        {
            get
            {
                if (index >= this.Count)
                {
                    return String.Empty;
                }

                return _Tokens[index];
            }
        }

        /// <summary>
        /// How many tokens does the command consist of
        /// </summary>
        public int Count
        {
            get
            {
                return _Tokens.Count;
            }
        }

        /// <summary>
        /// Which strategy is used to split the string into tokens
        /// </summary>
        public StringTokenizerStrategy Strategy
        {
            get
            {
                return _strategy;
            }
            set
            {
                if (value != _strategy)
                {
                    _strategy = value;
                    _tokens = null;
                }
            }
        }
        private StringTokenizerStrategy _strategy = StringTokenizerStrategy.Split;

        /// <summary>
        /// Character used to delimit tokens
        /// </summary>
        public char Delimiter
        {
            get
            {
                return _delimiter;
            }
            set
            {
                if (value != _delimiter)
                {
                    _delimiter = value;
                    _tokens = null;
                }
            }
        }
        private char _delimiter = ' ';

        /// <summary>
        /// Character used to escape the following character
        /// </summary>
        public char Escape
        {
            get
            {
                return _escape;
            }
            set
            {
                if (value != _escape)
                {
                    _escape = value;

                    if (Strategy == StringTokenizerStrategy.Escaping)
                    {
                        _tokens = null;
                    }
                }
            }
        }
        private char _escape = '\\';

        /// <summary>
        /// Character used to surround tokens
        /// </summary>
        public char Quotes
        {
            get
            {
                return _quotes;
            }
            set
            {
                if (value != _quotes)
                {
                    _quotes = value;

                    if (Strategy == StringTokenizerStrategy.Quotation)
                    {
                        _tokens = null;
                    }
                }
            }
        }
        private char _quotes = '"';
        #endregion

        #region Predefined Regex
        private Regex Whitespaces
        {
            get
            {
                return new Regex("\\s+");
            }
        }
        #endregion

        #region Implementation Details
        /// <summary>
        /// Formats and splits the tokens by delimiter allowing to add delimiters by quoting
        /// </summary>
        private List<string> _SplitRespectingQuotation()
        {
            string data = _sourceString;

            // Doing some basic transformations
            data = Whitespaces.Replace(data, " ");

            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
            // Initialisation
            List<string> l = new List<string>();
            char[] record = data.ToCharArray();

            StringBuilder property = new StringBuilder();
            char c;

            bool quoting = false;

            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
            // Scan character by character
            for (int i = 0; i < record.Length; i++)
            {
                c = record[i];

                // Quotation-Character: Single -> Quote; Double -> Append
                if (c == Quotes)
                {
                    if (i == record.Length - 1)
                    {
                        quoting = !quoting;
                    }
                    else if (Quotes == record[1 + i])
                    {
                        property.Append(c);
                        i++;
                    }
                    else
                    {
                        quoting = !quoting;
                    }
                }

                // Delimiter: Escaping -> Append; Otherwise append
                else if (c == Delimiter)
                {
                    if (quoting)
                    {
                        property.Append(c);
                    }
                    else
                    {
                        l.Add(property.ToString());
                        property.Clear();
                    }
                }

                // Any other character: Append
                else
                {
                    property.Append(c);
                }
            }

            l.Add(property.ToString());                         // Add last token

            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
            // Checking consistency
            if (quoting) throw new FormatException();          // All open quotation marks closed

            return l;
        }

        /// <summary>
        /// Splits the string by declaring one character as escape
        /// </summary>
        private List<string> _SplitRespectingEscapes()
        {
            string data = _sourceString;

            // Doing some basic transformations
            data = Whitespaces.Replace(data, " ");

            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
            // Initialisation
            List<string> l = new List<string>();
            char[] record = data.ToCharArray();

            StringBuilder property = new StringBuilder();
            char c;

            bool escaping = false;

            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
            // Scan character by character
            for (int i = 0; i < record.Length; i++)
            {
                c = record[i];

                if (escaping)
                {
                    property.Append(c);
                    escaping = false;
                    continue;
                }

                if (c == Escape)
                {
                    escaping = true;
                }
                else if (c == Delimiter)
                {
                    l.Add(property.ToString());
                    property.Clear();
                }
                else
                {
                    property.Append(c);
                }
            }

            return l;
        }

        /// <summary>
        /// Splits the string by calling a simple String.Split
        /// </summary>
        private List<string> _SplitPlain()
        {
            return new List<string>(Whitespaces.Replace(_sourceString, " ").Split(Delimiter));
        }

        /// <summary>
        /// Backer for tokens
        /// </summary>
        private List<string> _Tokens
        {
            get
            {
                if (null == _tokens)
                {
                    switch (Strategy)
                    {
                        case (StringTokenizerStrategy.Quotation): _tokens = _SplitRespectingQuotation(); break;
                        case (StringTokenizerStrategy.Escaping): _tokens = _SplitRespectingEscapes(); break;

                        default: _tokens = _SplitPlain(); break;
                    }
                }

                return _tokens;
            }
        }
        private List<string> _tokens = null;
        #endregion
    }

    public enum StringTokenizerStrategy
    {
        Split,
        Quotation,
        Escaping
    }
}

Odpowiedzi

7 TheRubberDuck Sep 19 2020 at 01:42

Nie jestem pewien, czy to należy do klasy - przynajmniej nie do jednej!

Cofnij się o krok i zobacz, co łączy, a co oddziela każdą „strategię”. Wszystkie muszą przekształcić ciąg wejściowy w listę tokenów na podstawie ogranicznika zmiennej. Istnieją jednak właściwości, które są używane tylko przez jedną z trzech opcji, a większość logiki podziału jest unikalna dla jej strategii.

Sugestia 1: Trzy „samodzielne” funkcje.

Naprawdę musiałbyś umieścić je w klasie statycznej lub zrobić coś specjalnego z delegatami / lambdami, ale ostatecznie niewiele można zyskać z posiadania jednej dużej klasy.

  public static IList<string> SplitRespectingQuotation(string sourceString, char delimiter = ' ', char quote = '"') { ... }
  public static IList<string> SplitRespectingEscapes(string sourceString, char delimiter = ' ', char escape = '\') { ... }
  public static IList<string> SplitPlain(string sourceString, char delimiter = ' ') { ... }

Jeśli chcesz, aby dane wyjściowe przekazywały parametry wejściowe, możesz stworzyć znacznie lżejszą klasę, która to robi. Jego właściwości byłyby readonly; jeśli chcesz je zmienić i ponownie obliczyć, po prostu ponownie wywołaj funkcję. W końcu to właśnie robisz w swojej obecnej klasie!

Kolejny plus: jeśli i kiedy wymyślisz nową strategię podziału, możesz po prostu utworzyć nową funkcję bez wpływu na inne. Wszystkie są niezależnie testowalne, edytowalne i usuwalne.

Sugestia 2: Trzy konkretne klasy, które rozszerzają abstrakcyjną klasę bazową.

Podoba mi się to, co zrobiłeś z tą _Tokenswłaściwością: pozwala odroczyć obliczenia, dopóki naprawdę ich nie potrzebujesz, co jest pomocne w przypadkach, gdy tego nie zrobisz. Ponadto jednym z przypadków użycia, które obsługuje (który nie jest obsługiwany przez funkcje „samodzielne”) jest zmiana np. Znaku ucieczki i automatyczne „unieważnienie” wyniku.

Aby zachować to zachowanie, możesz przeciągnąć wspólne elementy do abstrakcyjnej klasy bazowej, jak poniżej:

public abstract class StringTokenizer
{
  public string SourceString { get; }

  public StringTokenizer(string dataInput)
  {
    SourceString = dataInput ?? string.Empty;
  }

  public string this[int index] => index >= this.Count ? String.Empty : Tokens[index];

  public int Count => Tokens.Count;

  public char Delimiter
  {
    get { return _delimiter; }
    set
    {
      if (value != _delimiter)
      {
         _delimiter = value;
         InvalidateResult();
      }
    }
  }
  private char _delimiter = ' ';

  public IEnumerable<string> Tokens
  {
    get
    {
      if (_tokens is null)
      {
        _tokens = ComputeTokens();
      }
      return _tokens;
    }
  }
  private List<string> _tokens = null;

  protected abstract List<string> ComputeTokens();

  protected void InvalidateResult()
  {
    _tokens = null;
  }
}

Istotne zmiany:

Brak rzeczywistej logiki podziału. Każda strategia zapewni własną.
Brak właściwości specyficznych dla strategii. Nie ma potrzeby, aby strategia oparta na ucieczce miała właściwość dla postaci cytowanej i odwrotnie.
Zamiast bezpośredniego ustawiania _tokens = nullwłaściwości powinny wywoływać InvalidateResult. Pozwala to _tokensna privatezachowanie logiki zawartej w klasie bazowej.
Tokensjest publiczny i jest IEnumerable. Umożliwia to konsumentom korzystanie foreach, ale zniechęca do bezpośredniej modyfikacji.

Klasa bazowa ma teraz dokładnie jedno zadanie: implementację ComputeTokens. Jeśli w tym celu musi utworzyć właściwości, może to zrobić w oparciu o własną logikę specyficzną dla strategii. Jeśli te właściwości muszą unieważnić wcześniej obliczone tokeny po zmianie, mogą wywołać InvalidateResult.

Oto przybliżony przykład tego, jak wyglądałaby podklasa strategii:

public sealed class EscapeStringTokenizer : StringTokenizer
{
  public EscapeStringTokenizer (string dataInput) : base(dataInput) { }

  public char Escape
  {
    get { return _escape; }
    set
    {
      if (value != _escape)
      {
         _escape = value;
         InvalidateResult();
      }
    }
  }

  protected override List<string> ComputeTokens()
  {
    // Actual logic omitted
  }
}

Inne obserwacje

Zezwalasz na określenie separatora, ale zawsze zagęszczasz spacje. Gdybym podzielił się "a,a and b,b"z ogranicznikiem ",", spodziewałbym się {"a", "a and b", "b"}powrotu - ale faktycznie dostałbym {"a", "a and b", "b"}.
Jeśli separator itp. Można odczytać publicznie, dlaczego nie ujawnić również ciągu źródłowego? Zobacz SourceStringmoją klasę abstrakcyjną powyżej.
Uważam, że (stosunkowo nowe) metody dostępu do właściwości z wyrażeniem są ogólnie lepsze dla prostych właściwości. Zobacz Countw mojej klasie abstrakcyjnej powyżej.
Nie sądzę, aby możliwe było przypadkowe przypisanie nullzmiennej jako warunku instrukcji if. Dzieje się tak, ponieważ x = nullszacuje się, że jest tego samego typu x, co, który musi być a bool(a zatem nie dopuszcza wartości null), aby był prawidłowym warunkiem. Jeśli nadal chcesz tego uniknąć x == null, możesz powiedzieć x is null.
Jak wspominali inni, nie należy poprzedzać właściwości przedrostkiem _. Nie służy do rozróżniania między publicznym a prywatnym, ale między zmiennymi lokalnymi a polami klas. Osobiście jednak nawet nie używam _w tym przypadku, ale zamiast tego wolę w this.razie potrzeby. Ale ogólnie będziesz musiał być elastyczny w tym zakresie i upewnić się, że postępujesz zgodnie z dowolnym wzorcem, który jest już ustalony w istniejącym zespole lub projekcie.
Jak wspominali inni, używaj varprzy deklarowaniu zmiennych, kiedy tylko jest to możliwe. Każde dobre IDE będzie w stanie powiedzieć ci typ po najechaniu kursorem na zmienną, a jego nazwa powinna ci powiedzieć, do czego służy, nawet bez typu.
W tej notatce unikaj nazw takich jak ci l. ijest w porządku, ponieważ jest idiomatyczny jako zmienna pętli / indeksu, ale inne wymagają dodatkowego kontekstu do zrozumienia. Znaki kodu źródłowego są tanie, więc zapłać za dodatkową czytelność, używając currentChari finishedTokens.
Nie musisz tłumaczyć źródła stringna char[]; możesz już uzyskać dostęp do znaków w stringindeksie.

9 Heslacher Sep 18 2020 at 16:53

Nie powinieneś mieć Whitespaceswłaściwości tylko do pobierania, ale jako readonlypola prywatnego i powinieneś skompilować to wyrażenie regularne, ponieważ używasz go dość często.
Używanie regionjest traktowane jako anty-wzorzec
Przedrostki używaj tylko w przypadku pól prywatnych. Nie używaj ich jako metod lub właściwości.
Jeśli typ zmiennej jest jasny po prawej stronie przypisania, należy użyć varzamiast konkretnego typu.
Kod robi wiele, chociaż _sourceStringmoże być string.Emptyspowodowane tym, że przekazany argument ctor dataInputmoże być nulllub string.Empty. Wolałbym wrzucić wyjątek w ctor.

Zamiast przypisywać zmienną do innej, a następnie manipulować zmienną wynikową, możesz to zrobić w jednej linii, jak np

string data = Whitespaces.Replace(_sourceString, " ");

zamiast

string data = _sourceString;

// Doing some basic transformations
data = Whitespaces.Replace(data, " ");

Jeśli potrzebujesz tylko dostępu do pojedynczych elementów tablicy i nie musisz patrzeć w przyszłość, powinieneś preferować pętlę foreachover a for.

5 AlexanderPetrov Sep 18 2020 at 19:51

lImię jednoliterowe wydaje mi się złe.
Myślę, że do wyjątku należy dodać wiadomość opisującą przyczynę błędu.
Domyślnie wszystkie spacje są usuwane z danych. Ale mogą być potrzebne w tokenach. Możesz skorzystać z dodatkowej opcji, aby to określić.

1 Benj Sep 20 2020 at 00:13

Dziękuję wszystkim za wspaniałe opinie. Zaadoptowałem większość zmian w moim kodzie, który jest hostowany jako FOShttps://github.com/pillepalle1/dotnet-pillepalle1 gdzie otrzyma dalsze utrzymanie.

Na razie spakowałem logikę podziału na trzy statyczne metody rozszerzające. Dodatkowo, zgodnie z sugestią therubberduck, zbudowałem otoki, aby opcjonalnie zachować komfort automatycznego unieważniania tokena

Sugestie, które wdrożyłem

Nazewnictwo zmiennych Nazwy zmiennych, takie jak lzostały zastąpione nazwami bardziej opisowymi
Dodano komunikaty o wyjątkach
Modyfikacja zawartości tokena została całkowicie usunięta z metod rozszerzających i opcjonalnie dostępna w opakowaniach
Regiony zostały całkowicie usunięte
Używanie var, gdy jest to uzasadnione / możliwe
Pętle preferujących foreachna forpętli i iteracji nad sourceStringzamiast przekształcając go char[]najpierw
Inputstring Rzucanie ArgumentNullExceptionzamiast konwertowania nullnaString.Empty
Dzielenie CSV zgodnie z RFC4180

Przyjąłbym więcej zmian, ale niektóre sugestie (np. Dotyczące Whitespaceswłaściwości treści i wyrażeń) stały się nieaktualne w nowej implementacji.

StringTokenizer dla .NET Core

Zasada 1: odpowiednik String.Split ()

Zasada 2: Unikaj znaków specjalnych

Zasada 3: Umieść tokeny w cudzysłowie

Kod

Odpowiedzi

Nie jestem pewien, czy to należy do klasy - przynajmniej nie do jednej!

Sugestia 1: Trzy „samodzielne” funkcje.

Sugestia 2: Trzy konkretne klasy, które rozszerzają abstrakcyjną klasę bazową.

Inne obserwacje

Sugestie, które wdrożyłem

Sugestie nie wdrożyłem

Kod

Statyczne metody tokenizatora

Klasa bazowa abstrakcyjnego opakowania

Opakowanie do zwykłej tokenizacji

Opakowanie do tokenizacji ofert

Opakowanie do tokenizacji ucieczki