I am developing a system for runtime macro executions in an automatic test environment. Macros are defined in an xml and are for configuring multiple devices/DUTs for a specific use case. The xml parsing of these macros is outside of the scope of this question.

For building the macros in code I created the code shown below. In this example, there is no 'Macro' class, but rather a collection of 'Statement's. This can be regarded as the same thing.

A macro consists out of statements and some statements are only to be executed under certain conditions (e.g. IfStatement).

For execution of the statements a context object is passed between the statements and the conditions. This context can then be used/modified by the statements and checked by the conditions.

For this I use 2 interfaces: IStatement and ICondition:

• Each Statement implements IStatement - having an Execute(object context) method - and tries to cast the context (of type object) to one or more interfaces which the statement needs. Some statements do not actually need the context (e.g. DelayStatement)

• The same goes for the Conditions, they implement ICondition - having an IsTrue(object context) method - and cast the context to expected interfaces. Some conditions do not need the context (e.g. True, False), but implement the interface explicitly.

There is a Core project, that defines the basics of the macros, but this can be extended for more specific projects. The context object can vary per project and can even have a different type (e.g. Context, SpecificContext). More statements/conditions can be added per project.

I have a couple of questions about this:

• Is the way of passing context a good way for a use case like this? Should the statement/condition 'know' about the context it is going to receive/expect? Or should that be the responsibility of the caller?
• If so, what is a better approach for this?
• Should I define multiple interfaces for Statements that require context, and statements that do not? Same goes for conditions.
• If this context-passing is a design pattern, what is the name of it?

Some notes:

• I can create an interface IContext, that has at least the Arguments, Messages, and Result to reduce some castings.
• There are more statements/conditions than shown below, this is just a sandbox.
• I started out using the Visitor pattern and no common Execute(object)/IsTrue(object) method, but stumbled upon problems in the stage of the Specific projects where I did not know how to properly extend the Core.Visitor. In this case, only the Visitor knew about the specific Context class/object and knew which methods to invoke on the Statements/Conditions (e.g: it knew that a True condition does not need context, but for the SendI2CToDevice, it only provided the Device by invoking a specific method)

Many thanks!

using ContextPassing.Core;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ContextPassing.Client
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Please write a random text and press enter.");
            string randomText = Console.ReadLine();
            Console.Clear();

            Console.WriteLine("Do you want to send the the text to the DUT/Device ? (y for yes)");
            string printInput = Console.ReadKey().KeyChar.ToString();
            Console.Clear();

            Console.WriteLine("If previous answer was yes, do you want to add a delay before sending it to the DUT/Device ? (y for yes)");
            string addDelay = Console.ReadKey().KeyChar.ToString();
            Console.Clear();

            var statements = new List<IStatement>();

            statements.Add(new SetFieldStatement { FieldName = "RandomText", Value = randomText });
            statements.Add(new SetFieldStatement { FieldName = "SendInput", Value = printInput });
            statements.Add(new SetFieldStatement { FieldName = "AddDelay", Value = addDelay });

            var printInputIfStatement = new IfStatement() { Condition = new FieldCondition { FieldName = "SendInput", Value = "y" } };

            var elseif = new ElseIf { Condition = new FieldCondition { FieldName = "SendInput", Value = "k" } };
            elseif.Statements.Add(new LogStatement { Message = "This is an easter egg." });

            printInputIfStatement.ElseIfs.Add(elseif);
            printInputIfStatement.Else.Add(new LogStatement { Message = "Input was not sent." });

            var addDelayIfStatement = new IfStatement() { Condition = new FieldCondition { FieldName = "AddDelay", Value = "y" } };

            addDelayIfStatement.Statements.Add(new DelayStatement() { Time = TimeSpan.FromSeconds(1) });

            printInputIfStatement.Statements.Add(addDelayIfStatement);

            printInputIfStatement.Statements.Add(new LogFieldStatement() { FieldName = "RandomText" });

            printInputIfStatement.Statements.Add(new ContextPassing.Specific.SendI2cBytesToDevice() { Bytes = Encoding.ASCII.GetBytes(randomText) });


            statements.Add(printInputIfStatement);

            var context = new ContextPassing.Specific.SpecificContext();
            context.Device = new ContextPassing.Specific.Device();
            new StatementExecutor().Execute(statements, context);

            Console.WriteLine("*** Execution complete - Message overview: ***");

            foreach (string msg in (context as IMessageContainer).Messages)
            {
                Console.WriteLine(msg);
            }

            Console.WriteLine("***");

            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}


namespace ContextPassing.Core
{
    public interface IArgumentContainer
    {
        IEnumerable<object> Arguments { get; }
    }

    public interface IFieldContainer
    {
        IDictionary<string, object> Fields { get; }
    }

    public interface IMessageContainer
    {
        ICollection<string> Messages { get; }
    }

    public class Context : IArgumentContainer, IMessageContainer, IFieldContainer
    {
        public Collection<object> Arguments { get; } = new Collection<object>();
        public Collection<string> Messages { get; } = new Collection<string>();
        public Dictionary<string, object> Fields { get; } = new Dictionary<string, object>();
        object Result { get; set; }
        IEnumerable<object> IArgumentContainer.Arguments => Arguments;
        ICollection<string> IMessageContainer.Messages => Messages;
        IDictionary<string, object> IFieldContainer.Fields => Fields;
    }

    public class StatementExecutor
    {
        public void Execute(IEnumerable<IStatement> statements, object context)
        {
            foreach (IStatement statement in statements)
            {
                statement.Execute(context);
            }
        }
    }

    public interface IStatement
    {
        void Execute(object context);
    }

    public interface ICondition
    {
        bool IsTrue(object context);
    }

    public class True : ICondition
    {
        public bool IsTrue() => true;
        public bool IsTrue(object context) => IsTrue();
    }

    public class False : ICondition
    {
        public bool IsTrue() => false;
        public bool IsTrue(object context) => throw new NotImplementedException();
    }

    public class Not : ICondition
    {
        ICondition Condition { get; set; }
        public bool IsTrue(object context) => !Condition.IsTrue(context);
    }

    public class Or : ICondition
    {
        Collection<ICondition> Conditions { get; } = new Collection<ICondition>();
        public bool IsTrue(object context) => Conditions.Any(x => x.IsTrue(context));
    }


    public class FieldCondition : ICondition
    {
        public string FieldName { get; set; }
        public object Value { get; set; }
        public bool IsTrue(object context)
        {
            var fieldContainer = context as IFieldContainer;

            if (fieldContainer is null)
                throw new InvalidOperationException("Context needs to be an IFieldContainer.");

            return fieldContainer.Fields[FieldName].Equals(Value);
        }
    }


    public class IfStatement : IStatement
    {
        public Collection<IStatement> Statements { get; } = new Collection<IStatement>();
        public Collection<ElseIf> ElseIfs { get; } = new Collection<ElseIf>();
        public Collection<IStatement> Else { get; set; } = new Collection<IStatement>();

        public ICondition Condition { get; set; }

        public void Execute(object context)
        {
            if (Condition.IsTrue(context))
            {
                foreach (IStatement statement in Statements)
                    statement.Execute(context);

                return;
            }

            foreach (ElseIf elseIf in ElseIfs)
            {
                if (elseIf.Condition.IsTrue(context))
                {
                    foreach (IStatement statement in elseIf.Statements)
                        statement.Execute(context);

                    return;
                }
            }

            if (Else != null)
            {
                foreach (IStatement statement in Else)
                    statement.Execute(context);
            }            
        }
    }

    public class ElseIf
    {
        public ICondition Condition { get; set; }
        public Collection<IStatement> Statements { get; } = new Collection<IStatement>();
    }

    public class SetFieldStatement : IStatement
    {
        public string FieldName { get; set; }
        public object Value { get; set; }

        public void Execute(object context)
        {
            var fieldsContainer = context as IFieldContainer;

            if (fieldsContainer is null)
                throw new InvalidOperationException("Context needs to be an IFieldContainer.");

            fieldsContainer.Fields[FieldName] = Value;
        }
    }

    public class LogStatement : IStatement
    {
        public string Message { get; set; }
        public void Execute(object context)
        {
            var msgsContainer = context as IMessageContainer;

            if (msgsContainer is null)
                throw new ArgumentException("Context needs to be an IMessageContainer.");

            msgsContainer.Messages.Add(Message);
        }
    }

    public class LogFieldStatement : IStatement
    {
        public string FieldName { get; set; }
        public void Execute(object context)
        {
            var fieldContainer = context as IFieldContainer; 
            var msgsContainer = context as IMessageContainer;

            if (fieldContainer is null)
                throw new InvalidOperationException("Context needs to be an IFieldContainer.");
            if (msgsContainer is null)
                throw new ArgumentException("Context needs to be an IMessageContainer.");

            msgsContainer.Messages.Add($"Field {FieldName} its value is: {fieldContainer.Fields[FieldName]}");
        }
    }

    public class DelayStatement : IStatement
    {
        public TimeSpan Time { get; set; } = TimeSpan.FromSeconds(1);

        public void Execute()
        {
            Thread.Sleep(Time);
        }

        // This statement does not need any context.
        void IStatement.Execute(object context) => Execute();
    }
}

namespace ContextPassing.Specific
{
    public class Device
    {
        public void SendI2cBytes(byte[] bytes) => Console.WriteLine($"Sending bytes bleep bloep blaap: {BitConverter.ToString(bytes)}");
        public bool IsConnected => true;
    }

    public interface IDeviceContainer
    {
        Device Device { get; }
    }

    public class SpecificContext : ContextPassing.Core.Context, IDeviceContainer
    {
        public Device Device { get; set; } = new Device();
    }

    public class IsConnected : ICondition
    {
        public bool IsTrue(object context)
        {
            var dc = context as IDeviceContainer;
            if (dc is null)
                throw new ArgumentException("Context should be a device container.");

            return dc.Device.IsConnected;
        }
    }

    public class SendI2cBytesToDevice : IStatement
    {
        public byte[] Bytes;

        public void Execute(object context)
        {
            var dc = context as IDeviceContainer;
            if (dc is null)
                throw new ArgumentException("Context should be a device container.");

            dc.Device.SendI2cBytes(Bytes);
        }
    }
}



```