Q:

Why does this generic method implementation NOT require the Type value to be passed? 

I have implemented a strongly typed implementation of INotifyPropertyChanged, except instead of using the interface, I have added a base class to implement. 
It works fine, but the bit I am struggling with is why TValue is used in the base method declaration (I did use this section from some code I found online)
NotifyPropertyUpdate<TValue>(...
BUT in the derived class, it doesn't need to pass TValue at all!  
What tells the compiler to resolve this at runtime instead of complaining at build? 
Thanks,
Base class:
public class NotifyFuncPropertyChanged<T> : INotifyPropertyChanged
{
    #region Implementation of INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged;

    protected void NotifyPropertyUpdate<TValue>(Expression<Func<T, TValue>> selector)
    {
        //get memberInfo from object selection
        MemberInfo memberInfoSelection;
        Expression body = selector;
        if (body is LambdaExpression)
        {
            body = ((LambdaExpression)body).Body;
        }
        switch (body. NodeType)
        {
            case ExpressionType. MemberAccess:
                memberInfoSelection =((MemberExpression)body).Member;
                break;
            default:
                throw new InvalidOperationException();
        }

        //send notifyupdate to memberInfo
        if (PropertyChanged ! = null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(memberInfoSelection. Name));
        }
    }

    #endregion
}

Usage (derived class)
public class NameTest : NotifyFuncPropertyChanged<NameTest>
{
    public string Name { get; set; }

    public void TestUpdateName()
    {
        this. NotifyPropertyUpdate(x => x.Name);
    }
}

A:

The C# compiler has a feature called Type inference.  You can read about it in all its complexity in the language specification, in section 7.5.2, or there's a very brief introduction here. 
From the spec:

When a generic method is called without specifying type arguments, a
  type inference process attempts to infer type arguments for the call.  The presence of type inference allows a more convenient syntax
  to be used for calling a generic method, and allows the programmer to
  avoid specifying redundant type information.  For example, given the
  method declaration:
class Chooser
{
  static Random rand = new Random();
  public static T Choose<T>(T first, T second) {
      return (rand. Next(2) == 0)?  first: second;
  }
}

it is possible to invoke the Choose method without explicitly
  specifying a type argument:
int i = Chooser. Choose(5, 213);                   // Calls Choose<int>
string s = Chooser. Choose("foo", "bar");      // Calls Choose<string>

Through type inference, the type arguments int and string are
  determined from the arguments to the method.