using System;

using System.Reflection;

using System.Collections.Generic;

​

public class Maybe<TSomething>

{

    private readonly TSomething? value;

    public bool IsPresent { get; }

​

    private Maybe(TSomething value, bool isPresent)

    {

        this.value = value;

        this.IsPresent = isPresent;

    }

​

    public static readonly Maybe<TSomething> Empty = new(default!, false);

​

    public static Maybe<TSomething> Of(TSomething value) => value != null ? new Maybe<TSomething>(value, true) : Empty;

​

    public TSomething GetOrThrow() =>

        IsPresent ? value! : throw new ArgumentNullException(nameof(value));

​

    public TSomething GetOrDefault(TSomething defaultValue = default!) =>

        IsPresent ? value ?? defaultValue : defaultValue;

}

​

public class Either<TLeft, TRight>

{

    public Maybe<TLeft> Left { get; }

    public Maybe<TRight> Right { get; }

​

    public Either(TLeft value)

    {

        Left = Maybe<TLeft>.Of(value);

        Right = Maybe<TRight>.Empty;

    }

​

    public Either(TRight value)

    {

        Left = Maybe<TLeft>.Empty;

        Right = Maybe<TRight>.Of(value);

    }

​

    public Either(Maybe<TLeft> left, Maybe<TRight> right)

    {

        if (!left.IsPresent && !right.IsPresent)

            throw new ArgumentOutOfRangeException(nameof(right));

​

        Left = left;

        Right = right;

    }

​

    public TMapped Map<TMapped>(

        Func<TLeft, TMapped> mapLeft,

        Func<TRight, TMapped> mapRight

    )

    {

        if (Left.IsPresent)

            return mapLeft(Left.GetOrThrow());

​

        if (Right.IsPresent)

            return mapRight(Right.GetOrThrow());

​

        throw new Exception("That should never happen!");

    }

​

    public void Switch(

        Action<TLeft> onLeft,

        Action<TRight> onRight

    )

    {

        if (Left.IsPresent)

        {

            onLeft(Left.GetOrThrow());

            return;

        }

​

        if (Right.IsPresent)

        {

            onRight(Right.GetOrThrow());

            return;

        }

​

        throw new Exception("That should never happen!");

    }

}

​

public class BaseEvent

{

    private readonly string _nameEvent;

​

    protected BaseEvent(string nameEvent)

    {

        _nameEvent = nameEvent;

    }

    public virtual string GetNameLogEvent() => _nameEvent.ToLower();

}

​

public enum TestType {

    MINE,

    WAREHOUSE,

    ELEVATOR

}

​

public class TestData : BaseEvent

{

    public TestType testType { get; set; }

    public double costInCash { get; set; }

    public int newLevel { get; set; }

    public int perUpgradeLevel { get; set; }

​

    public TestData(

        string nameEvent,

        TestType testType,

        double costInCash,

        int newLevel,

        int perUpgradeLevel

    ) : base(nameEvent)

    {

        this.testType = testType;

        this.costInCash = costInCash;

        this.newLevel = newLevel;

        this.perUpgradeLevel = perUpgradeLevel;

    }

}

​

public static class Helpers {

    public static bool IsNumber(this object value)

    {

        return value is sbyte

                || value is byte

                || value is short

                || value is ushort

                || value is int

                || value is uint

                || value is long

                || value is ulong

                || value is float

                || value is double

                || value is decimal;

    }

}

​

class Program {

    static void Main(string[] args) {

        var levelUpgradeData = new TestData(

            "StorageUpgrade",

            TestType.WAREHOUSE,

            45.0d,

            20,

            10

        );

​

        var dictionary = new Dictionary<string, Either<string, double>>();

        Type myType = levelUpgradeData.GetType();

        PropertyInfo[] props = myType.GetProperties();

        foreach (var prop in props)

        {           

            object propValue = prop.GetValue(levelUpgradeData, null);

            // Check property type

            if (propValue is string)

            {

                // Add property to dictionary

                dictionary.Add(prop.Name, new Either<string, double>((string) propValue));

            }

            else if (propValue is Enum)

            {

                var name = Enum.GetName(propValue.GetType(), propValue);

                dictionary.Add(prop.Name, new Either<string, double>((string) name));

            }

            else if (Helpers.IsNumber(propValue))

            {

                try

                {

                    var tempDouble = Convert.ToDouble(propValue);

                    dictionary.Add(prop.Name, new Either<string, double>((double) tempDouble));

                }

                catch (Exception err)

                {}

            }

        }

​

        foreach (KeyValuePair<string, Either<string, double>> item in dictionary)

        {

            item.Value.Switch(

                onLeft: (stringValue) => {

                    Console.WriteLine($"String: {item.Key}={stringValue}");

                },

                onRight: (doubleValue) => {

                    Console.WriteLine($"Double: {item.Key}={doubleValue}");

                }

            );

        }

        Console.WriteLine("Done");

    }

}