using System;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    public static void Main()

    {

        Element element = new MultiCompositeElement(

            new LeafElementA(),

            new BinaryCompositeElement(

                new LeafElementA(), new LeafElementA()),

            new LeafElementB()

        );      

        Console.WriteLine("element before: \r\n" + element.ToString());

        IVisitor visitor = new AToBVisitor();

        visitor.Visit(element);

        visitor = new AddOneMoreVisitor();

        visitor.Visit(element);

        Console.WriteLine("element after: \r\n" + element.ToString());

    }

    // Element base class

    public abstract class Element

    {

        internal abstract Element Accept(IVisitor visitor);

    }

    // Visitor interface

    public interface IVisitor

    {

        Element Visit(Element element);

        Element VisitNonRecursive(Element element);

​

        Element VisitNonRecursive(LeafElementA leafElementA);

​

        Element VisitNonRecursive(LeafElementB leafElementB);

​

        Element VisitNonRecursive(MultiCompositeElement multiCompositeElement);

​

        Element VisitNonRecursive(BinaryCompositeElement binaryCompositeElement);

    }

    // Visitor base class

    public abstract class VisitorBase: IVisitor

    {

        public virtual Element Visit(Element element)

        {

            element = element.Accept(this);

            return element;

        }

​

        public virtual Element VisitNonRecursive(Element element)

        {

            return element;

        }

​

        public virtual Element VisitNonRecursive(LeafElementA leafElementA)

        {

            return VisitNonRecursive(leafElementA as Element);

        }

​

        public virtual Element VisitNonRecursive(LeafElementB leafElementB)

        {

            return VisitNonRecursive(leafElementB as Element);

        }

​

        public virtual Element VisitNonRecursive(MultiCompositeElement multiCompositeElement)

        {

            return VisitNonRecursive(multiCompositeElement as Element);

        }

​

        public virtual Element VisitNonRecursive(BinaryCompositeElement binaryCompositeElement)

        {

            return VisitNonRecursive(binaryCompositeElement as Element);

        }

    }

    // Concrete elemets

    public class LeafElementA : Element

    {

        internal override Element Accept(IVisitor visitor)

        {

            return visitor.VisitNonRecursive(this);

        }

        public override string ToString() {

            return "LeafElementA";

        }

    }

    public class LeafElementB : Element

    {

        internal override Element Accept(IVisitor visitor)

        {

            return visitor.VisitNonRecursive(this);

        }

        public override string ToString() {

            return "LeafElementB";

        }

    }

    // Implementation of Element that contains exactly two other Elements

    public class BinaryCompositeElement : Element

    {

        public BinaryCompositeElement(Element left, Element right)

        {

            Left = left;

            Right = right;

        }

​

        public Element Left { get; private set; }

​

        public Element Right { get; private set; }

​

        internal override Element Accept(IVisitor visitor)

        {

            // Recursively visit the children

            Left = visitor.Visit(Left);

            Right = visitor.Visit(Right);

​

            // And non-recursively visit this

            return visitor.VisitNonRecursive(this);

        }

        public override string ToString() {

            return "BinaryCompositeElement[\r\nLeft = " + Left + "\r\nRight = " + Right + "\r\n]";

        }

    }

    // Implementation of Element that contains multiple other Elements

    public class MultiCompositeElement : Element

    {

        public MultiCompositeElement(params Element[] containedElements)

        {

            ContainedElements = containedElements.ToList();

        }

​

        public ICollection<Element> ContainedElements { get; private set; } 

​

        internal override Element Accept(IVisitor visitor)

        {

            ContainedElements = ContainedElements

                // Recursively visit each child

                .Select(visitor.Visit)

                .ToList();

​

            // And non-recursively visit this

            return visitor.VisitNonRecursive(this);

        }

        public override string ToString() {

            string children = string.Join(", ", ContainedElements);

            return "MultiCompositeElement[\r\nContainedElements = [\r\n  " + children + "\r\n  ]\r\n]";

        }

    }

    // Concrete visitors

    // Implementation of Visitor that adds a LeafElementA to any composite element

    public class AddOneMoreVisitor : VisitorBase

    {

        public override Element VisitNonRecursive(MultiCompositeElement multiCompositeElement)

        {

            multiCompositeElement.ContainedElements.Add(new LeafElementA());

            return multiCompositeElement;

        }

​

        public override Element VisitNonRecursive(BinaryCompositeElement binaryCompositeElement)

        {

            var result = new MultiCompositeElement(

                binaryCompositeElement.Left,

                binaryCompositeElement.Right,

                new LeafElementA()

            );

            return result;

        }

    }

        // This visitor just converts every LeafElementA into a LeafElementB

    public class AToBVisitor : VisitorBase

    {

        public override Element VisitNonRecursive (LeafElementA leafElementA)

        {

            return new LeafElementB();

        }

    }

}