A simple C# calculator
I completely agree with you that such tasks is a good opportunity to learn new concepts and the language itself. And, as you asked, I have a few comments on your code



Do not call variables by reserved names

I mean, I was sweating to understand what is going on here the first time

Action = Convert.ToString(userInput[i]);


Better to call such variable as

private static string OperationString { get; set; }




Split complex task on simpler ones - one logic per function

Your function ParseInput is doing not just parsing, but also reading from standard input. So split this task - ParseInput will just do parsing.

private static double ParseInput(string inputString)




Using the == operator to compare floating-point numbers is, generally, a bad idea

So instead of 

if (Action.Equals("/") &amp;&amp; Item2 == 0)


better to use this

if (Action.Equals("/") &amp;&amp; Math.Abs(Item2) &lt; Double.Epsilon)




Be aware of the difference between || and | logic operations

And without a need, do no mix up this two operators. So use

if ( userInput[i].Equals('+') || userInput[i].Equals('-') || userInput[i].Equals('*') || userInput[i].Equals('/'))


instead of

if ( userInput[i].Equals('+') || userInput[i].Equals('-') || userInput[i].Equals('*') | userInput[i].Equals('/'))




Better to avoid static not-readonly field

I don't see any actual reason for you to keep variables Item1, Item2 and OperationString as private static fields - make them as local variables. In general, based on my experience, many nasty bugs (especially in multi-thread applications) happen because of an inappropriate usage of static fields. I know, this problem is far away from this simple calculator application, but anyway. 



Good regular expression would solve many problems, including


code will become simpler and cleaner, so easy to debug and read
easier to solve your "serious flaw" - input validation


I would suggest to use Regular Expressions instead of buggy for-if construction.

// \d+\.? supports xxx. and xxx
// \.\d+ - .xxx
// \d+\.\d+ - xxx.xxx
Regex InputRegex = new Regex(@"^\s*([-+]?)(\d+\.?|\.\d+|\d+\.\d+)(.)(\d+\.?|\.\d+|\d+\.\d+)\s*$");

// match.Groups[0] whole pattern
// match.Groups[1] sign of the first value
// match.Groups[2] first value (without sign)
// match.Groups[3] operation
// match.Groups[4] second value
Match match = InputRegex.Match(userInput);

if (!match.Success)
{
    // we didn't find a match
}
double item1 = match.Groups[1].Value == "-" ? -Double.Parse(match.Groups[2].Value) : Double.Parse(match.Groups[2].Value);
string actionString = match.Groups[3].Value;
double item2 = double.Parse(match.Groups[4].Value);




Let user know that calculation was successful or not

Let's check which error can happen in your code:


RegexNotSuccess Regular expression doesn't find a match
DivisionByZero Second item is 0, so we have the division by zero
NoSuchOperation User specified not [+-*/] operation


I would suggest to create enumerated list of those errors, return one enum element as output of your function.

public enum ErrorCode
{
    Success,
    NoSuchOperation,
    DivisionByZero,
    RegexNotSuccess
}

public static ErrorCode ParseInput(string userInput, out double result)
{
    //...
    if (!match.Success)
    {
        result = Double.MinValue;
        return ErrorCode.RegexNotSuccess;
    }
    //...
    switch (actionString)
    {
        //...
        case "/":
            if (Math.Abs(item2) &lt; Double.Epsilon)
            {
                result = Double.MinValue;
                return ErrorCode.DivisionByZero;
            }
        //...
        default:
            result = Double.MinValue;
            return ErrorCode.NoSuchOperation;
    }
    result = handler(item1, item2);
    return ErrorCode.Success;
}




The final code looks like this

Program.cs

using System;

namespace CalculatorTest
{
    class Program
    {
        private static void Main()
        {
            while (true)
            {
                Console.WriteLine("Enter a mathematical expression, please");
                string userInput = Console.ReadLine();
                Calculator.ErrorCode stdout = Calculator.ParseTwoNumberOperation(userInput, out double result);
                if (stdout == Calculator.ErrorCode.Success)
                {
                    Console.WriteLine(result);
                }
                else
                {
                    Console.Error.WriteLine("Error: " + stdout + "\t" + userInput);
                }
            }
        }
    }
}


Calculator.cs

using System;
using System.Text.RegularExpressions;

namespace CalculatorTest
{
    public static class Calculator
    {
        public enum ErrorCode
        {
            Success,
            NoSuchOperation,
            DivisionByZero,
            RegexNotSuccess
        }

        private delegate double Handler(double a, double b);
        /// &lt;summary&gt;
        /// \d+\.? supports xxx. and xxx
        /// \.\d+ - .xxx
        /// \d+\.\d+ - xxx.xxx
        /// &lt;/summary&gt;
        private static readonly Regex InputRegex = new Regex(@"^\s*([-+]?)(\d+\.?|\.\d+|\d+\.\d+)(.)(\d+\.?|\.\d+|\d+\.\d+)\s*$");
        public static ErrorCode ParseTwoNumberOperation(string userInput, out double result)
        {
            Handler handler;
            // match.Groups[0] whole pattern
            // match.Groups[1] sign of the first value
            // match.Groups[2] first value (without sign)
            // match.Groups[3] operation
            // match.Groups[4] second value
            Match match = InputRegex.Match(userInput);
            if (!match.Success)
            {
                result = Double.MinValue;
                return ErrorCode.RegexNotSuccess;
            }
            double item1 = match.Groups[1].Value == "-" ? -Double.Parse(match.Groups[2].Value) : Double.Parse(match.Groups[2].Value);
            string actionString = match.Groups[3].Value;
            double item2 = double.Parse(match.Groups[4].Value);
            switch (actionString)
            {
                case "+":
                    handler = GetSum;
                    break;

                case "-":
                    handler = GetDif;
                    break;

                case "*":
                    handler = GetMul;
                    break;

                case "/":
                    if (Math.Abs(item2) &lt; Double.Epsilon)
                    {
                        result = Double.MinValue;
                        return ErrorCode.DivisionByZero;
                    }
                    handler = GetDiv;
                    break;

                default:
                    result = Double.MinValue;
                    return ErrorCode.NoSuchOperation;
            }

            result = handler(item1, item2);
            return ErrorCode.Success;
        }

        private static double GetSum(double a, double b) =&gt; a + b;
        private static double GetDif(double a, double b) =&gt; a - b;
        private static double GetMul(double a, double b) =&gt; a * b;
        private static double GetDiv(double a, double b) =&gt; a / b;
    }
}