C# Intermediate: Classes, Interfaces and OOP

The Next Logical Step For Beginners Looking To Grow


This review covers an intermediate C# course. If you don’t know what C# or .NET are then you might benefit from the beginner’s course that comes before this one. This is the second course in the series that targets those looking to go from zero experience to coding like a professional. Now that I have completed C# Intermediate: Classes, Interfaces and OOP, here are my thoughts.

Who is the Course For?

The course is self-described as: “An in-depth, step-by-step guide to classes, interfaces and object-oriented programming (OOP) with C#“. While this definition gets a pass in my books, I think it doesn’t really do itself justice. All of the promised concepts are definitely touched on, but in a way that is focused mainly on the core definition without spending more time than you might expect. Every lesson starts with theory and ends with a live coding session. There is indeed a lot of stuff thrown in here and there such as personal opinions (always backed up with examples), but no concept is waited on too long. This results in a slightly aggressive pace that may put off those of little to no experience who could benefit from more examples. This is why I would recommend if you’re coming from the first course that you should spend some time writing your own programs to solidify your understanding. The author provides a summary and exercises for each section, but if you’re still struggling with the basics then you might not be able to focus on what he’s actually teaching. This potential problem for newcomers is doubled with the fact that the summaries can sometimes lack the context that the videos provide and the exercises don’t challenge the student to do anything beyond what they learned.

I think the type of person that benefits most from this short, aggressive style of teaching are those who need information fast. For example, people studying for an exam or who have a job interview lined up need this terse format. By being given concepts and few examples (albeit strong ones), the author is challenging the student to either read between the lines (if they have the necessary experience) or research further independently. On the other hand, perhaps those looking to see where they’re at and possibly fill in the gaps of knowledge may also benefit. If you’re coming from another strong-typed language with a healthy amount of experience I’d imagine you will also have no problem progressing through the course.

Want to determine what course is best for you? Here are each of the curriculum.

Beginner Course Curriculum

  • C# and .NET Framework fundamentals
  • Primitive types and expressions
  • Non-primitive types (classes, structs, arrays and enums)
  • Value types and reference types
  • Conditional statements
  • Arrays and lists
  • Files and directories
  • Text
  • Date and time
  • Debugging

Intermediate Course Curriculum

  • Classes: properties, access modifiers, constructors
  • Class association: coupling, inheritance, composition
  • Inheritance: downcasting, upcasting, boxing, unboxing.
  • Polymorphism: method overriding, abstract classes, sealed classes
  • Interfaces: extensibility and testability

Advanced Course Curriculum

  • Exception Handling
  • Generics
  • Delegates
  • Events
  • Lambda Expressions
  • Extensions Methods
  • LINQ
  • Nullable Types
  • Dynamics
  • Asynchronous Programming with Async / Await

The growth you can expect to see from the beginner’s course to this one is to go from someone who only thought about writing functional code, but can now see the bigger picture: writing code that is easy to maintain, readability, decoupling, encapsulation, testability, and just overall intelligent design. When programming, you should definitely move past just writing debug logs and fully implementing unit testing. The course does a great job at introducing how to make code that is easier to test, although I do wish it was done earlier in the course and then repeated throughout.

There is far less hand-holding in this course compared to the first to the point where exercises don’t even come with solutions. The author did, nonetheless, provide a series of videos that target what students are doing right and wrong. This ties back into the goal of the course: it isn’t about writing programs that just work, it is about writing code that is designed well and that can be easily extended.

Despite being only 30 minutes longer than the beginner course, the course load feels more intense due to the six hours being spread over eight sections as opposed to the beginner courses eleven sections. This can lead to some sections feeling especially exhaustive, most notably the section on interfaces.

Student’s who made it through the beginner course are obviously dedicated and the instructor thus treats them with a greater degree of respect. The author does not just go from concept to concept, but provides a lot of useful information. For example, after finishing his talk on properties the author goes in depth on the subject of keeping ones classes away from a false state. For example, if your class has a list you can initialize it in the constructor so it is never null (furthermore, you can make it “readonly” to make it more robust (i.e, so you can’t overwrite a value and go into an unexpected state). Another skill that is introduced is looking out for “code smell”, something that breaks a goal such as hiding implementation. The author has strong feelings against using the out and ref keywords and backs up his opinions with examples that point out their flaws. By taking this course, students will be able to write their own classes that hide implementation due to the great coverage of access modifiers. The major benefit and reason for being here is that when there’s a need to modify a class it won’t have as great of an impact as all changes can be made from within the class.

“… a class should be always in a valid state. We use encapsulation and information hiding to achieve that. The class should not reveal its implementation detail. It only reveals a little bit, like a blackbox. From the outside, you should not be able to misuse a class because you shouldn’t be able to see the implementation detail. “

The author doesn’t just show that their are multiple ways to implement the same thing, but also shows the deciding factor in those choices. For example, the auto-implementation of a property can be used when no logic is needed in the get/set method. The author takes this a step further and uses the command prompt to expose how the compiler is generating the private field. The course does a good job on breaking down inheritance vs composition: the author outlines the difference between the two (i.e., inheritance results in tightly coupled code) and the preferred choice of composition over inheritance in order to keep code loosely coupled.

Now for the bad. The author does not always make as many connections for the reader during live code demos as I would deem necessary. The end result is those with less experience will have to struggle in order to make those connections themselves. Whether or not you are ready to be independent at this point in your learning will be subjective. Personally, I’ve been using C# for a while now and so I had no trouble keeping up; however, I could see where I would have struggled if this was my first or second course ever. Fortunately, the provided course QA (question & answer) has been up for several years and just about any question you might have has likely been asked and answered adequately by either the author, TA or fellow student. Some opinions from the author are not fully fleshed out with sufficient attention. As mentioned, the author has a pretty strong resentment towards the out and ref modifiers, but only spends a few minutes explaining why. This raises my main criticism of the course: examples are short and minimal. Sometimes one example is adequate, but other times I would have appreciated several examples to fully explore more complicated concepts.

What you’re really getting here is a big trade-off between time and thoroughness. By learning only the core of each concept, students will be able to move onto either more advanced material or something more specialized at the expense of not getting the amount of practice they probably should if time isn’t an issue. If you’re grinding for exams or a job interview this might be the right move, otherwise, you might find the lectures lacking. The benefit of having such a fast course is that you end up being finished quicker and can then figure out if you need to spend more time on these concepts or if you’re comfortable enough to move on. In my opinion, if you have the equivalent experience to working full-time in C# for six months then this course will feel like a breeze. Otherwise, you will need more time with these concepts even if it means taking the course again as review.

“What you’re really getting here is a big trade-off between time and thoroughness.”

The course does a fairly good job of keeping things general. Whether you are moving on to mobile, web, or game development, everything you learn here will be extremely valuable. Now, the examples are in fact often given in the context of web applications; however, the actual implementation of most methods are omitted in place of just writing to the console so that the focus can be put on the actual concepts. Here’s an analogy that will hopefully make this more clear: you are learning to build a house by building a small model. So when it comes time to build the full-scale house, you will have an understanding of where everything goes and in what order. You won’t, however, know how to do the individual skilled tasks such as drywalling or painting, but you will know where and when those tasks occur. The end result here is that you are moving forward with a new respect and understanding of proper coding etiquette. No matter your background in programming or where you are headed, this course has something to offer.


“No matter your background in programming or where you are headed, this course has something to offer.”


While overall a very strong course, there is a definite noticeable dip in quality during the terminal “interfaces” section. The section was notably lacking in visuals. Having something to look at when you’re hearing about a new concept can help in attaching those memories to an image, which should aid in retention. The author tends to prefer just leaving visual studio open where it was while discussing these concepts, which left me feeling a bit distracted. This was especially true when covering the Open Closed Principle. Even a simple analogy with a relevant image would be preferable to none. There was occasional use of visuals coupled with analogies, but simply not enough.


C# Intermediate: Classes, Interfaces and OOP does a great job at keeping things general so that no matter what your background in programming is or where you are headed every lesson is a valuable use of time. The theory coverage is good, and the use of real-world examples provides the context necessary to bring the course from good to great.


  • Solid entry point for those looking to specialize in C# (i.e., mobile, web, Unity…)
  • Coverage of time-efficiency tools (Code Snippets)
  • Theory coverage
  • Great stepping stone between beginner and advanced material
  • Opinions backed up with examples
  • use of “gotchas” (code smell)


  • Exercises lack challenge
  • Not enough visuals during theory
  • End of course dips in quality



Get the Course – Intermediate C#

More from the author – Beginner C# | Advanced C# | Unit Testing | More

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s