Пример #1
0
        private static void RemoveContiguousWhitespace(IntermediateNodeCollection nodes, TraversalDirection direction)
        {
            var position = direction == TraversalDirection.Forwards ? 0 : nodes.Count - 1;

            while (position >= 0 && position < nodes.Count)
            {
                var  node = nodes[position];
                bool shouldRemoveNode;
                bool shouldContinueIteration;

                switch (node)
                {
                case IntermediateToken intermediateToken:
                    shouldRemoveNode        = string.IsNullOrWhiteSpace(intermediateToken.Content);
                    shouldContinueIteration = shouldRemoveNode;
                    break;

                case HtmlContentIntermediateNode htmlContentIntermediateNode:
                    RemoveContiguousWhitespace(htmlContentIntermediateNode.Children, direction);
                    shouldRemoveNode        = htmlContentIntermediateNode.Children.Count == 0;
                    shouldContinueIteration = shouldRemoveNode;
                    break;

                case MarkupElementIntermediateNode _:
                case CSharpExpressionIntermediateNode _:
                case TagHelperIntermediateNode _:
                    // These node types may produce non-whitespace output at runtime
                    shouldRemoveNode        = false;
                    shouldContinueIteration = false;
                    break;

                case CSharpCodeIntermediateNode codeIntermediateNode:
                    shouldRemoveNode        = false;
                    shouldContinueIteration = false;
                    break;

                default:
                    shouldRemoveNode        = false;
                    shouldContinueIteration = true;     // Because other types of nodes don't produce output
                    break;
                }

                if (shouldRemoveNode)
                {
                    nodes.RemoveAt(position);
                    if (direction == TraversalDirection.Forwards)
                    {
                        position--;
                    }
                }

                position += direction == TraversalDirection.Forwards ? 1 : -1;

                if (!shouldContinueIteration)
                {
                    break;
                }
            }
        }