Singly linked list implementation
Consider using a different naming convention for your data members and methods, such as camelCase or snake_case.  Your user-defined types are already uppercase, which is okay.  Whichever you choose, it's more readable to keep them separate.
The push/pop methods here imply that this is a stack implementation, but a linked list should be capable of inserting or removing a node at any location in the list.  Consider adding additional functions for this.  For an idea of typical linked list functions, read this.
Since you're using a list class, you should have a size member to maintain.  Your Size() method is calculating the size at each call by traversing, which is O(n).

Instead, have a size data member and update it with other operations:


initialize to 0 in the initializer list
increment with each push
decrement with each pop
reset to 0 with each clear


When you call Size(), it should just return the data member value, which is O(1).

It should also return a std::size_t.  It is closest to the return type used in STL containers, and a very large list size may not fit inside an unsigned int.
Instead of having a return in PushFront(), put the last two lines into an else block.
Shouldn't popBack() check tail if PopFront() checks head?  Although they may be pointing to the same node if there's only one node, but the intent is more clear this way.
You should probably also have a Front() and Back() that return a T const&amp;, in case the reference will not be modified or a const value is needed.
You should have some way of displaying the list.  For that, consider overloading operator&lt;&lt; for the List class (instead of a display function), allowing you to do this:

List list;
std::cout &lt;&lt; list;


You could also overload Node's operator, allowing you to output a node within the List class.
std::out_of_range is defined in &lt;stdexcept&gt;, not &lt;exception&gt;.