Versuch

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Zeilenrechner
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] terms = new string[] { "(1+2*3)", "2*3", "1+2*3", "1.5+2.5", "4.4/1.2" };

            try
            {
                foreach (String term in terms)
                {
                    Console.Write("Berechnung des Terms '");
                    Console.Write(term);
                    Console.Write("' = ");
                    double d = Berechne(term);
                    Console.Write(d);
                    Console.Write("\r\n");
                }
            }
            catch (Exception ex)
            {
                Console.Write("\r\n");
                Console.Write("Der folgende Fehler in dem Term wurde gefunden: ");
                Console.Write(ex.Message);
            }

            Console.ReadKey();
        }

        public static double Berechne(string term)
        {
            double result = 0.0;
            double a = 0.0;
            double b = 0.0;
            double c = 0.0;

            // operatoren reihenfolge prüfen (. vor  -)
            char ersterOperator = ' ';
            char zweiterOperator = ' ';

            bool klammerAuf = false;

            string tmpZahlStr = "";

            char offeneKlammer = ' ';
            char geschlosseneKlammer = ' ';

            // zahlen und operatoren finden und speichern
            for (int i = 0; i < term.Length; i++)
            {
                if (ersterOperator == ' ')
                { // noch kein operator erkannt also befinden wir uns in der ersten operation des terms
                    if (term[i] == '+' || term[i] == '-' || term[i] == '*' || term[i] == '/')
                    { // wenn char ein operator oder eine klammer, dann als ersten Speichern
                        if (i == 0)
                        { // erste stelle ist ein operator!
                            throw new Exception("Es darf kein Operator am Anfang des Terms stehen!");
                        }
                        a = Convert.ToDouble(tmpZahlStr); // erste zahl speichern
                        tmpZahlStr = ""; // reset tmp var

                        ersterOperator = term[i];
                    }
                    else
                    { // kein operator also erste zahl
                        tmpZahlStr += term[i];
                    }
                    //ZULETZT DAS PROBLEM MIT DEM KLAMMERN ANGEGANGEN!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                    if (term[i] == '(')
                    {
                        offeneKlammer = term[i];
                    }
                    else if (term[i] == ')')
                    {
                        geschlosseneKlammer = term[i];
                    }
                }
                else if (zweiterOperator == ' ')
                { // hat bereits einen operator -> nach weiterem suchen
                    if (term[i] == '+' || term[i] == '-' || term[i] == '*' || term[i] == '/')
                    {
                        b = Convert.ToDouble(tmpZahlStr); // erste zahl speichern
                        tmpZahlStr = ""; // reset tmp var

                        zweiterOperator = term[i];
                    }
                    else
                    { // kein operator also zweite zahl
                        tmpZahlStr += term[i];

                        // hat keine weiteren zeichen also zweite zahl komplett
                        if (i == (term.Length - 1))
                        {
                            b = Convert.ToDouble(tmpZahlStr); // erste zahl speichern
                            tmpZahlStr = ""; // reset tmp var
                        }
                    }
                }
                else
                { // hat zweiten operator bereites also ist der rest die letzte zahl
                    tmpZahlStr += term[i];

                    // hat keine weiteren zeichen also zweite zahl komplett
                    if (i == (term.Length - 1))
                    {
                        c = Convert.ToDouble(tmpZahlStr); // erste zahl speichern
                        tmpZahlStr = ""; // reset tmp var
                    }
                }
            }

            // berechnen
            if (zweiterOperator != ' ')
            { // hat zweiten operator
                if ((ersterOperator == '+' || ersterOperator == '-') && (zweiterOperator == '*' || zweiterOperator == '/'))
                { // punkt vor strich fall tritt ein
                    switch (zweiterOperator)
                    {
                        case '*':
                            result += b * c;
                            break;
                        case '/':
                            if (c == 0)
                            { // teilen durch null nicht möglich
                                throw new Exception("Teilen durch Null nicht möglich");
                            }

                            result += b / c;
                            break;
                    }

                    switch (ersterOperator)
                    {
                        case '+':
                            result += a * b;
                            break;
                        case '-':
                            result += a / b;
                            break;
                    }
                }
                else
                { // normale rechnung
                    switch (ersterOperator)
                    {
                        case '+':
                            result += a * b;
                            break;
                        case '-':
                            result += a / b;
                            break;
                        case '*':
                            result += a * b;
                            break;
                        case '/':
                            if (b == 0)
                            { // teilen durch null nicht möglich
                                throw new Exception("Teilen durch Null nicht möglich");
                            }

                            result += a / b;
                            break;
                    }

                    switch (zweiterOperator)
                    {
                        case '+':
                            result += b * c;
                            break;
                        case '-':
                            result += b / c;
                            break;
                        case '*':
                            result += b * c;
                            break;
                        case '/':
                            if (c == 0)
                            { // teilen durch null nicht möglich
                                throw new Exception("Teilen durch Null nicht möglich");
                            }

                            result += b / c;
                            break;
                    }
                }
            }
            else
            { // keinen zweiten operator
                switch (ersterOperator)
                {
                    case '+':
                        result += a + b;
                        break;
                    case '-':
                        result += a - b;
                        break;
                    case '*':
                        result += a * b;
                        break;
                    case '/':
                        if (b == 0)
                        { // teilen durch null nicht möglich
                            throw new Exception("Teilen durch Null nicht möglich");
                        }

                        result += a / b;
                        break;
                }
            }

            return result;

        }
    }
}