using System;

using System.Collections.Generic;

​

    public enum NumberOfConvertedObjs {

        One,

        Multiple,

    }

    public interface IErrorHandler{

        void TypeError(/*...*/);

        void CardinalityError(string safName, NumberOfConvertedObjs expected, int actual);

        // ....

    }

    public static class IConvertedObjectExtensions {

        public static void VisitAs<T>(this IConvertedObject convObj, Action<T> specificSingleObjHandler, Action<IEnumerable<CSModelObject>> multipleObjectHandler, IErrorHandler eH) {

            convObj.Visit(

                o => {

                    if(o is T correctTyped){

                        specificSingleObjHandler(correctTyped);

                    }

                    else {

                        eH.TypeError();

                    }

                },

                objList => {

                    multipleObjectHandler(objList);

                }

            );

        }

        public static void VisitAsSingle<T>(this IConvertedObject convObj, Action<T> specificSingleObjHandler, IErrorHandler eH) {

            convObj.Visit(

                o => {

                    if(o is T correctTyped){

                        specificSingleObjHandler(correctTyped);

                    }

                    else {

                        eH.TypeError();

                    }

                },

                objList => {

                    eH.CardinalityError(convObj.Name, NumberOfConvertedObjs.One, objList.Count());

                }

            );

        }

    }

​

​

public class Program

{

    public class CSModelObject{

    }

    public interface IConvertedObject{

        void Visit(Action<CSModelObject> singleObjHandler, Action<IEnumerable<CSModelObject>> multipleObjectHandler);

        TOut Visit<TOut>(Func<CSModelObject,TOut> singleObjHandler, Func<IEnumerable<CSModelObject>,TOut> multipleObjectHandler);

    }

    public class SingleConvertedObj : IConvertedObject {

        CSModelObject _val;

        public SingleConvertedObj(CSModelObject val) {_val = val;}

        public void Visit(Action<CSModelObject> singleObjHandler, Action<IEnumerable<CSModelObject>> multipleObjectHandler){

            singleObjHandler(_val);

        }

        public TOut Visit<TOut>(Func<CSModelObject,TOut> singleObjHandler, Func<IEnumerable<CSModelObject>,TOut> multipleObjectHandler){

            return singleObjHandler(_val);

        }

    }

    public class MultipleConvertedObj : IConvertedObject {

        IEnumerable<CSModelObject> _val;

        public MultipleConvertedObj(IEnumerable<CSModelObject> val) {_val = val;}

        public void Visit(Action<CSModelObject> singleObjHandler, Action<IEnumerable<CSModelObject>> multipleObjectHandler){

            multipleObjectHandler(_val);

        }

        public TOut Visit<TOut>(Func<CSModelObject,TOut> singleObjHandler, Func<IEnumerable<CSModelObject>,TOut> multipleObjectHandler){

            return multipleObjectHandler(_val);

        }

    }

    public static void Main()

    {

        Dictionary<string,IConvertedObject> context = new Dictionary<string,IConvertedObject>();

        // add the single case, most places use this...

        var singleModelObject = new CSModelObject();

        context.Add("A", new SingleConvertedObj(singleModelObject));

        // add multiple objects under same name EG. multiple beams

        var multipleObjs = new List<CSModelObject>() {new CSModelObject(), new CSModelObject()};

        context.Add("B", new MultipleConvertedObj(multipleObjs));

        // here is the magic, some other object references a name, and we have to handle both cases

        // checking if the key is valid is omitted for simplicity here.

        // I want a single object, the other case is not valid:

        // also, this shows how to just get back the value we want

        var convertedObj = context["A"];

        // ez a fiddle-ben nem megy, mert valami régi language versiont használnak, de nálunk mennie kell.

        /*if(convertedObj.Visit(

                o => o,

                oList => null

            ) is CSModelObject singleObj

        )

        {

            Console.WriteLine("Hurray! a single obj! " + singleObj.ToString());

        }

        else{

            Console.WriteLine("errorHandling, only single obj is acceptable here!");

        }

        */

        // In case I can handle both possibilities

        convertedObj.Visit(

            o => Console.WriteLine("do something with single obj"),

            oList => {

                foreach(var item in oList)

                    Console.WriteLine("do something with all objs in a list");

            }

        );

    }

    public class TK{

        public string Date{get;set;}

    }

}