They are completely different concepts but they are both founding principles of OOP.
Encapsulation refers to the fact that a type, i.e. a class or structure, encapsulates, i.e. encloses within, all the data (properties and fields) and behaviour (methods and events) of an object of that type. The idea is that you don't have just one place where all your variables and functions go no matter what they do. You create a type for each entity you want to represent, whether that entity be physical, e.g. a Person, or more abstract, e.g. a database connection. Each of those types will contain all the variables and functions that relate specifically to that entity. Where you need to use that entity in your code you simply create an instance of the type and you then have a simple, well defined interface to interact with and all the heavy lifting is done internally by the type.
Subclassing is not really an OOP concept but rather the accepted name for the act of implementing inheritance. Inheritance is the actual concept, and refers to the fact that one type can inherit all the data and behaviour from another type and then just add whatever is specific to itself, rather than recreating all the existing functionality of the existing type.
In some other languages, like C/C++, they have superclasses and subclasses, where the subclass inherits, or is derived from, the superclass. The act of deriving a subclass from a superclass is known as "subclassing". The term "subclassing" doesn't get used much in .NET because the terms "superclass" and "subclass" are not used. In .NET you have base classes and derived classes. When you define a new type that inherits from an existing type, the existing type is the base class and the new type is the derived class. The derived type inherits all the data and behvaiour of the base type and then adds its own to that.
As an example of how these OOP concepts work together, consider what happens when you add a form to a project. What you're doing is deriving a new class the Form base class. The Form class encapsulates all the data and behaviour of a Form object, so you inherit all that for free. You then add your own data and behaviour, thereby encapsulating that within your own derived class.
Note that "subclassing" in .NET apps actually refers to another, very specific process. Rather than inheriting a UI class you can hook into its Windows message queue. This allows you to preview any and all message that get sent from the OS to a window, where a window is any control, including a form. You are then able to divert or modify these message to alter the way a control behaves. This is something that is rarely done and you will probably never have to do. In the event that you do though, it is achieved by inheriting the NativeWindow class and providing it with the handle of the windw you want to subclass. You then override the WndProc method of your class and it will receive all the messages that the specified window does.
