I think you are struggling, as many newcomers to C# and OOP do, with trying map big-picture concepts/outcomes of
implementing what you might call "general OOP philosophy" to actual C# code objects you program with.
In my experience students often start C# with a general sense that OOP is about modeling "objects" in "the real world;" and, yes, that is a major use of OOP technique, but, in programming in C# you are dealing with objects that are unique to code, as well. Your Program in WinForms is a (static) Class; your UserControl in WinForms can inherit from other user-interface widgets.
I'd like to suggest that you focus on studying, and creating, actual C# programs that implement and use Classes (abstract, virtual, and "regular"), Interfaces, Structs, Enums, and Delegates.
As you gain increasing mastery of using these tools/objects, then I suggest you step-back and articulate how, for you, they fit in to your understanding of OOP, in general. This suggestion is based on my experience with many students, most of whom do better learning OOP with a bottom-up, rather than top-down approach.
Abstraction is a principle, an outcome to be attained, of implementing relationships of objects in such a way that they can interact efficiently, and also do not generate unknown side-effects.
Inheritance is the key technique used to implement abstraction; C#'s inheritance facility allows for single-class inheritance, and multiple interface inheritance (other programming languages offer different paradigms). However, one can, in C#, in effect achieve multiple inheritance by compound, or serial, inheritance of the form:
public Class1
{
public void Method1(string sParam, int iParam) {}
}
public Class2 : Class1
{
public void Method2(string sParam, int iParam) {}
}
public Class3 : Class2
{
public void Method3(string sParam, int iParam) {}
}
In this (silly) example the point is that any instance of Class3 will have access to Method1 in Class1 and Method2 in Class2.
An actual Abstract Class in C# is not necessarily an "abstraction," although it's a tool one can use to implement "abstraction:" remember that the Abstract Class can contain
actual Method implementations, as well as Virtual methods.
Encapsulation is a big-picture concept that says it is valuable, desirable, even necessary, to exert rigorous control over the possible interactions of objects by regulating what they expose to other objects, and regulate that exposure through formal means (Interfaces, for example). This big-picture concept is also expressed using terms like "modularity," "separation of concerns."
Around the term "OOP," there are a swarm of buzzwords that come and go, reflecting the times, the trends, the latest gurus.
Getting "down to earth" with what C# allows, and does not allow, is a good basis for, later, exploring such fascinating capabilities of the language as Extension Methods (you can even extend Interfaces !), Linq, Reflection and dynamic creating of new assemblies at run-time that contain code that can be executed, etc.