Стратегия конкатенации неструктурированных строк

Когда у меня есть алгоритм, который может изменить его поведение в зависимости от дискретных элементов (например, токенов, действий и т.д.), Вы можете увидеть, может ли шаблон дизайна штата быть хорошим.

Шаблон немного подробный по сравнению с другими методами, но при необходимости он легко расширяется. Мы начинаем с абстрактного класса состояний: его цель - позволить вам перейти от одного состояния к другому, когда вступает в игру новый токен:

public abstract class State
{
    public static string[] operators = new string[] { "+", "-", "*", "/" };
    public List<string> Expressions { get; set; }
    public List<string> Tokens { get; set; }
    public abstract State Process(string token);
}

Каждое состояние, которое мы можем иметь, будет вытекать из этого; мы могли бы попытаться смоделировать их заранее: мы можем описать в основном два случая

• либо мы не заботимся о следующем токене, потому что предыдущий токен закончился оператором (или мы начинаем наше первое выражение)
• или мы хотим, чтобы следующий токен пришел, чтобы начать с оператора, если мы хотим продолжить выражение

Позвольте создать первое состояние:

public class WaitingForAnyTokenState : State
{
    public override State Process(string token)
    {
        return PushTokenToTokenList(token);
    }

    protected State PushTokenToTokenList(string token)
    {
        Tokens.Add(token);
        if (operators.Any(op => token.EndsWith(op)))
        {
            return new WaitingForAnyTokenState() { Expressions = Expressions, Tokens = Tokens };
        }
        return new WaitingForOperationState() { Expressions = Expressions, Tokens = Tokens };
    }
}

В принципе, мы говорим, что если токен закончил операцию, нам не WaitingForAnyTokenState следующий токен, поскольку он будет сложен в текущее выражение: мы возвращаем WaitingForAnyTokenState.

Наоборот, если мы не закончим операцию, то то, что происходит с текущим выражением, зависит от следующего токена. Если он начинается с операции, выражение продолжается. Если нет, текущее выражение заканчивается, и мы начинаем новый.

public class WaitingForOperationState : State
{
    public override State Process(string token)
    {
        CloseCurrentExpression(token);
        return PushTokenToTokenList(token); // let imagine the same method as above is accessible here
    }

    private void CloseCurrentExpression(string token)
    {
        if (!operators.Any(op => token.StartsWith(op)))
        {
            CombineTokensIntoExpression();
            Tokens = new List<string>();
        }
    }
}

Интересно, что следующий случай все еще решается так же, как и для первого государства. Единственное изменение - закрытие текущего выражения, если это необходимо.

Вот пример кода архитектуры, которую вы могли бы использовать:

private static void Main(string[] args)
{
    var ttea = new TokenToExpressionAggregator();
    foreach (var l in new string[] { "a+", "+1", "+c-", "d", "e", "+d", "z+", "a+" }) {
        ttea.Add(l);
    }
    ttea.EndAggregation();
    foreach (var expression in ttea.CurrentState.Expressions) {
        Console.WriteLine(expression);
    }
}

public class TokenToExpressionAggregator
{
    public State CurrentState { get; set; }
    public TokenToExpressionAggregator()
    {
        CurrentState = new InitialState();
    }
    public void Add(string token)
    {
        CurrentState = CurrentState.Process(token);
    }
    public void EndAggregation()
    {
        CurrentState = new FinalState(CurrentState);
    }
}

public abstract class State
{
    public static string[] operators = new string[] { "+", "-", "*", "/" };
    public List<string> Expressions { get; set; }
    public List<string> Tokens { get; set; }
    public abstract State Process(string token);

    protected State PushTokenToTokenList(string token)
    {
        Tokens.Add(token);
        if (operators.Any(op => token.EndsWith(op)))
        {
            return new WaitingForAnyTokenState() { Expressions = Expressions, Tokens = Tokens };
        }
        return new WaitingForOperationState() { Expressions = Expressions, Tokens = Tokens };
    }

    protected void CombineTokensIntoExpression()
    {
        Expressions.Add(string.Join(" ", Tokens.ToArray()));
    }
}

public class InitialState : WaitingForAnyTokenState
{
    public InitialState()
    {
        Expressions = new List<string>();
        Tokens = new List<string>();
    }
}

public class WaitingForAnyTokenState : State
{
    public override State Process(string token)
    {
        return PushTokenToTokenList(token);
    }
}

public class WaitingForOperationState : State
{
    public override State Process(string token)
    {
        CloseCurrentExpression(token);
        return PushTokenToTokenList(token);
    }

    private void CloseCurrentExpression(string token)
    {
        if (!operators.Any(op => token.StartsWith(op)))
        {
            CombineTokensIntoExpression();
            Tokens = new List<string>();
        }
    }
}

public class FinalState : State
{
    public FinalState(State state)
    {
        Expressions = state.Expressions;
        Tokens = state.Tokens;
        CombineTokensIntoExpression();
        Tokens = null;
    }

    public override State Process(string token)
    {
        return this;
    }
}

Это делает для подробного, но красноречивого кода; личный вкус и профессиональная среда могут протестовать. Но я обнаружил, что он помогает выразить функциональные переходы между вашими государствами. Это также более легко проверить, поскольку каждое государство мало и не зависит от предыдущих состояний.

Я предположил, что некоторые лимиты догадываются о некоторых неясных моментах вашего процесса (являются ли объединенные операторы недействительными?), И он не является полным (без скобок), но я думаю, что эта структура может помочь вам в виде потока токенов, который, как вам кажется,,