OpenCourser
Learn skills that shape your future
Visit OpenCourser.com
In this course, you will learn the basic principles of object-oriented programming, and then learn how to apply those principles to construct an operational and correct code using the C# programming language and .NET. As the course progresses, you will learn such programming concepts as objects, method resolution, polymorphism, object composition, class inheritance, object substitution, etc., but also the basic principles of object-oriented design and even project management, such as abstraction, dependency injection, open-closed principle, tell don't ask principle, the principles of agile software development and many more.
In this course, you will learn the basic principles of object-oriented programming, and then learn how to apply those principles to construct an operational and correct code using the C# programming language and .NET. As the course progresses, you will learn such programming concepts as objects, method resolution, polymorphism, object composition, class inheritance, object substitution, etc., but also the basic principles of object-oriented design and even project management, such as abstraction, dependency injection, open-closed principle, tell don't ask principle, the principles of agile software development and many more.
After completing this course, you will be qualified to continue learning the principles of object-oriented design, and to start developing applications that will be modeling different business domains.
This course differs from other similar courses in that it first devises the C# programming language from scratch, and the .NET Runtime that makes the object-oriented code run. Only after completing this task shall we step on to using the programming concepts to implement customer's requirements in C#.
The reason for such an extreme experiment is to teach the programmers that any object-oriented language is only a tool, which relies on a small set of operations that are already implemented for us - such as silently passing the this reference or resolving function addresses from the object reference at run time. I find great danger in writing code without understanding what happens when a piece of object-oriented code is taken for execution.
Puts C# programming language into perspective of major programming styles
Briefly lists the topics that will be covered in this course
Provides instructions how to choose and install an IDE that will be used throughout this course
Introduces variables and values to represent numbers, character strings and dates
Introduces arithmetic and other transforms that apply to variables and values
Summarizes this module
Displays the roles of procedures, as far as they are useful to build larger chunks of logic
Introduces objects, as the first programming form which brings data and procedures together
Introduces constructors and instances, for the first time creating what looks like an object
Substitutes classes for modules and introduces object-oriented lingo
Explains explicit and implicit memory deallocation
Explains importance of making every programming language deterministic
Explains basic building blocks of C# code
Introduces blocks of code and explains syntax of the if instruction and Boolean conditions
Explains how methods are defined on a C# class
Introduces access modifiers that apply to methods, fields and other class members
Explains the concept of program entry points in modern operating systems
Demonstrates how a new console application project can be created and run using Visual Studio
Contains autonomous exercise
Demonstrates limitation of a class which does not support varying implementation of a method
Introduces derived classes
Explains the role of virtual methods table in a class
Explains how vtable is used to specify method overrides
Introduces proper virtual functions in C#
Explains C# language syntax that allows declaring and overriding virtual function
Introduces method overloading syntax in C#
Explains the relationship between .NET projects and assemblies
Explains .NET solutions and the elements they contain
Analyzes customer's requirements which shall be implemented in subsequent demos
Explains how to add a new class to the project, driven by customer's requirements
Demonstrates how to initialize objects to valid state
Introduces common base class for all classes
Demonstrates how to override the ToString method inherited from System.Object
Explains decisions that lead to creation of new classes
Examines code which appears in multiple places and corrects the issue by introducing a new class for the duplicated code
Explains strategies useful when giving names to methods
Examines separation of concerns between domain classes and how it influences method implementation
Implements a domain-related method in full object-oriented style
Explains how an exception can be used as a placeholder for a method which is not implemented yet
Introduces method call chaining to simplify code
Introduces expression-bodied syntax for methods
Explains the "Tell, don't ask" principle and its relationship to encapsulation
Demonstrates problem decomposition through private methods defined on a class that uses them
Applies ternary operator as means of pattern matching
Continues development of the demo
Explains reasons and benefits of following the top-down development style
Showcases capabilities of currently developed code
Explains benefits we collect from having a detailed domain model
Demonstrates the working principle of combining smaller features into larger ones when implementing requirements
Explains polymorphic calls and methods implemented in derived classes
Analyzes requirements and prepares ground to implement some of them
Explains reasons that lead to introduction of the Open-closed Principle in object-oriented programming
Analyzes code and identifies methods that are misplaced, and which are candidates to migrate to new classes
Reiterates dynamic dispatch mechanism applied by the runtime
Introduces dependency injection technique
Applies dependency injection to the sample domain model
Demonstrates use of an injected dependency
Demonstrates practical method of deriving a class from an existing class
Introduces abstract methods and classes
Demonstrates application of the object substitution principle on class dependencies
Demonstrates modifying behavior of a class by selecting a concrete dependency object
Repeats principal methods of how to approach the problem of learning a new programming language
Repeats operational principles of classes and objects
Repeats backing principles of good object-oriented design
Repeats principles of method composition, and how it applies to object-oriented design
Repeats principles of dependency injection, and how it applies to object-oriented design
Explains major problems we face when designing solutions for the real world
Explains principles of code refactoring techniques and their role in redesigning object-oriented models
Save
Builds programming concepts conceptually first.
Includes demos and Visual Studio use.
Instructor explains complex ideas effectively.
Covers key principles and design patterns.
Delves deep into core OOP concepts and runtime.
SaveSaveOpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.
Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.
Find this site helpful? Tell a friend about us.
We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.
Your purchases help us maintain our catalog and keep our servers humming without ads.
Thank you for supporting OpenCourser.
