Stack using a Linked List I thought implementing a stack using a linked list was a good option since an array implementation involves reallocation of array size and so on. 

I have implemented basic Push, Pop and Print operation: What best practices can I follow?

class StackusingLinkedList
{
    public Node&lt;int&gt; Head;
    int Nodecount = 0;
    public void Push(int data)
    {
        if (Nodecount == 0)
        {
            Head = new Node&lt;int&gt;(data);
            Nodecount++;
            return; ;
        }
        var temp = new Node&lt;int&gt;(data);
        temp.Next = Head;
        Head = temp;
        Nodecount++;
    }
    public void Pop()
    {
        var temp = Head;
        Head = temp.Next;
    }
    public void Print()
    {
        var prtemp = Head;
        StringBuilder sb = new StringBuilder();
        while (true)
        {
            if (prtemp == null)
            {
                break;
            }
            sb.Append("|"+prtemp.Data+"|");
            var temp = prtemp;
            prtemp = temp.Next;
        }
        Console.WriteLine(sb.ToString());
    }
}

class Node&lt;T&gt;
{
    public Node&lt;T&gt; Next { get; set; }

    public T Data { get; set; }

    public Node(T data)
    {
        Data = data;
    }

}
Major Issues


The class access modifier does not allow public access, so your class is not usable by third party consumers. Make it public.
Your class should be generic to be usable.
You should always provide unit tests when providing a class to consumers of your API.
Pop is ill-defined. It does not return anything. It can throw a NullReferenceException when the stack is empty. It does not decrement the count. It should throw InvalidOperationException when empty.
A class representing a collection should always implement the correct interfaces. Implement IEnumerable&lt;T&gt; to let consumers iterate the items. Implement IReadOnlyCollection&lt;T&gt; to provide a property Count. Don't be fooled by its name, collections implementing this interface are not stipulated to be immutable. They provide a Count to indicate eager iteration is provided (Interesting Discussion about IReadOnlyCollection).


Review


The name of a class should tell you what it is, not how it's implemented. Call it LinkedStack (conform naming convention LinkedList).
Node could be made public, but then its state should be private or internal at best. Given the few operations you provide, it could be made private. Consider making it public if you would provide mehods as Remove(Node&lt;T&gt; node). This would remove a specific node, even if multiple nodes hold the same value as the specified node.
Push has a redundant creation of a node. Create the node before the first if statement.
Print has no purpose in this class. It should be an extension method declared elsewhere.
Node should be a nested class for better encapsulation.
A property IsEmpty, as suggested in another answer, is syntactic sugar that improves readability.




Refactored

In this solution the Node remains private. Some API's allow it to be public.

public class LinkedStack&lt;T&gt; : IReadOnlyCollection&lt;T&gt;, IEnumerable&lt;T&gt;
{
    private class Node
    {
        internal Node next;
        internal T Value { get; }

        public Node(T value) =&gt; Value = value;
    }

    private Node head;

    public void Push(T item)
    {
        var node = new Node(item);
        if (IsEmpty)
        {
            head = node;
        }
        else
        {
            node.next = head;
            head = node;
        }
        Count++;
    }

    public T Pop()
    {
        if (IsEmpty)
        {
            throw new InvalidOperationException();
        }
        var value = head.Value;
        head = head.next;
        Count--;
        return value;
    }

    public int Count { get; private set; }
    public bool IsEmpty =&gt; Count == 0;

    public IEnumerator&lt;T&gt; GetEnumerator()
    {
        var node = head;
        while (node != null)
        {
            yield return node.Value;
            node = node.next;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}


Unit Tests

[TestClass]
public class LinkedStackTests
{
    [TestMethod]
    public void LinkedStackTest()
    {
        var stack = new LinkedStack&lt;int&gt;();

        stack.Push(0);
        stack.Push(0);
        stack.Push(1);

        Assert.AreEqual(3, stack.Count);

        Assert.AreEqual(1, stack.Pop());
        Assert.AreEqual(0, stack.Pop());
        Assert.AreEqual(0, stack.Pop());

        Assert.AreEqual(0, stack.Count);
    }
}