public class Node<Item> {

        private Item data;
        private Node<Item> next_node;

        public Node(Item data, Node<Item> next_node) {
            this.data = data;
            this.next_node = next_node;
        }

        public Node(Node<Item> next_node) {
            this.next_node = next_node;
        }

        public Item getData() {
            return data;
        }

        public Node<Item> getNext_node() {
            return next_node;
        }



    }

 public class StackWithList<Item> {

        private int N; // size of the stack
        private Node<Item> first; // top of stack


        public StackWithList() {
            N = 0;
            this.first = null;
        }

        public bool isEmpty() {
            return first == null;
        }

        public int size() {
            return N;
        }

        public void push(Item item) {
            Node<Item> oldfirst = first;
            first = new Node<Item>(item, oldfirst);
            N++;

        }

        public Item pop() {
            if (isEmpty())
                throw new System.IndexOutOfRangeException("stack overflow");
            Item item = (Item) first.getData(); // save item to return
            first = first.getNext_node(); // delete first node
            N--;

            return item; // return the saved item
        }

        public Item peek() {
            if (isEmpty())
                throw new System.IndexOutOfRangeException("stack underflow");
            return (Item) first.getData();
        }

        public IEnumerator<Item> GetEnumerator(){
            return new myEnumrator<Item> (first);
        }

    }

class myEnumrator<Item>: System.Collections.Generic.IEnumerator<Item>
    {
        private Node<Item> current;

        public myEnumrator(Node<Item> First){
            Node<Item> temp = new Node<Item>(First);
            current = temp;
        }
        #region IEnumerator implementation
        public bool MoveNext ()
        {
            if (!hasNext()) {
                return false;
            }
            //Item item = current.getData();
            current = current.getNext_node ();
            return true;
        }
        public void Reset ()
        {
            throw new NotSupportedException ();
        }
        object System.Collections.IEnumerator.Current {
            get {
                throw new NotSupportedException ();
            }
        }
        #endregion
        #region IDisposable implementation
        public void Dispose ()
        {

        }
        #endregion
        #region IEnumerator implementation
        public Item Current {
            get {
                if (current != null) {
                    return current.getData();
                }
                return default(Item);
            }
        }
        #endregion

        public bool hasNext(){
            if (current.getNext_node() != null)
                return true ;
            return false;
        }

    }

        public static void Main (string[] args)
        {

            StackWithList<String> stack = new StackWithList<String>();
            stack.push("jack");
            stack.push("mike");
            stack.push("dany");
            Console.WriteLine(stack.pop());
            Console.WriteLine("------ items after pop ------");
            foreach(String s in stack){
                Console.WriteLine (s);
            }

            Console.ReadKey ();
        }
    }

public class StackWithArray<Item> {
        private Item[] a; // array of items
        private int N;

        public StackWithArray() {
            a =  new Item[2];
        }

        public bool isEmpty() {
            return N == 0;
        }

        public int size() {
            return N;
        }

        private void resize(int capacity) {
            Debug.Assert(capacity>=N);
            Item[] temp =  new Item[capacity];
            for (int i = 0; i < N; i++) {
                temp[i] = a[i];
            }
            a = temp;
        }

        public void push(Item item) {
            if (N == a.Length)
                resize(2 * a.Length); // double size of array if necessary
            a[N++] = item; 
        }

        public Item pop() {
            if (isEmpty())
                throw new System.IndexOutOfRangeException("stack overflow");
            Item item = a[N - 1];
            a[N - 1] = default(Item); 
            N--;
            // shrink size of array if necessary
            if (N > 0 && N == a.Length / 4)
                resize(a.Length / 2);
            return item;
        }

        public Item peek() {
            if (isEmpty()) throw new System.IndexOutOfRangeException("stack underflow");
            return a[N-1];
        }

        public IEnumerator<Item> GetEnumerator(){
            return new ReverseIterator<Item> (N,a);
        }

    }
}

class ReverseIterator<Item>: System.Collections.Generic.IEnumerator<Item>
    {

        private int i;
        private Item[] data;

        public ReverseIterator(int N,Item[] data) {
            i = N;
            this.data = data;
        }


        #region IEnumerator implementation
        public bool MoveNext ()
        {
            if(!hasNext()){
                return false;
            }
            i--;
            return true;
        }
        public void Reset ()
        {
            throw new NotImplementedException ();
        }
        object System.Collections.IEnumerator.Current {
            get {
                throw new NotImplementedException ();
            }
        }
        #endregion
        #region IDisposable implementation
        public void Dispose ()
        {

        }
        #endregion
        #region IEnumerator implementation
        public Item Current {
            get {
                return data [i];
            }
        }
        #endregion

        public bool hasNext() {
            return i > 0;
        }

    }

public static void Main (string[] args)
        {
            StackWithArray<String> mystack = new StackWithArray<String>();
            mystack.push("jack");
            mystack.push("mike");
            mystack.push("dany");

            Console.WriteLine(mystack.pop());
            Console.WriteLine("------ items after pop ------");

            foreach(string s in mystack){
                Console.WriteLine(s);
            }

            Console.ReadKey ();
        }