The following program takes as an input a postfix arithmetical expression and evaluates its value:

using System;

namespace ConsoleTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Stack operators = new Stack();
            Stack values = new Stack(); // operands

            string input = args[0];

            foreach (string token in input.Split(" ".ToCharArray()))
            {
                switch (token)
                {
                    case "(": // ignore left parentheses
                        break;
                    case "+":
                    case "-":
                    case "*":
                    case "/":
                    case "sqrt":
                        operators.Push(token);
                        break;
                    case ")":
                        {
                            // Pop an operator.
                            string op = operators.Pop();

                            // Pop the first operand.
                            double val = values.Pop();

                            switch (op)
                            {
                                // Pop the second operand and evaluate.
                                case "+":
                                    val = values.Pop() + val;
                                    break;
                                case "-":
                                    val = values.Pop() - val;
                                    break;
                                case "*":
                                    val = values.Pop() * val;
                                    break;
                                case "/":
                                    val = values.Pop() / val;
                                    break;
                                case "sqrt":
                                    val = Math.Sqrt(val);
                                    break;
                            }

                            // Push the result onto the operand stack.
                            values.Push(val);
                        }
                        break;
                    default:
                        double num;
                        if (Double.TryParse(token, out num))
                            values.Push(num);
                        else
                            throw new ArithmeticException(String.Format("Expected a number. The value '{0}' is not a number.", token));
                        break;
                }
            }

            double result = values.Pop();
            Console.WriteLine("Result: {0:0.#####}", result);

            Console.ReadKey();
        }

        class Stack
        {
            private Node first;
            private int N; // stack size

            public bool IsEmpty { get { return first == null; } }
            public int Size { get { return N; } }

            public void Push(T item)
            {
                Node oldFirst = first;
                first = new Node();
                first.Item = item;
                first.Next = oldFirst;

                ++N;
            }

            public T Pop()
            {
                T item = first.Item;
                first = first.Next;

                --N;

                return item;
            }

            private class Node
            {
                public T Item { get; set; }
                public Node Next { get; set; }

                public override string ToString() { return (Item == null ? "null" : Item.ToString()); }
            }
        }
    }
}

Sample output:

( ( 1 2 + ) ( ( 3 4 - ) ( 5 6 - ) * ) * ) --> 3

( ( 1 2 * ) ( 3 4 / ) + ) --> 2.75

( ( 1 ( 2 3 + ) * ) 4 / ) --> 1.25

( 1 ( 2 ( 3 4 / ) + ) * ) --> 2.75

( ( 1 ( sqrt 5.0 ) + ) 2.0 / ) --> 1.61803