Top 8 Recommended C# Self-Study Materials! [December 2023]

Welcome to the "Ultimate C# Masterclass" course! Are you ready to take your knowledge and career to the next level?

43 hours of on-demand videos, 62 coding exercises, 71 quizzes, and 15 assignments. All this is to help you start coding in C# like a pro.

I'm a .NET Technical Lead with over 10 years of professional experience. I will help you on this journey every step of the way, no matter if you are a complete beginner who has never coded before or a developer who wants to advance to the next level. We will start from the basics, but we will not stop there.

I will not only teach you how to code but also how to code well. Clean code and good design will be our priorities, and design patterns will be shown in practice, not as abstract concepts that seem impossible to be used in real-life challenges. Refactoring will be something we practice all the time.

Programs written in C# are fast, but we can make them faster. The performance will be discussed in detail.

You will learn more than C# syntax. It is not only a course about the language but a course about programming in general. You will understand why all the things we learn are needed and how to use them right. Moreover, I will show you how they work under the hood, and thanks to that, you will gain an in-depth understanding of C#. This course also covers the development of unit tests using NUnit and Moq libraries.

Practice makes perfect. You will solve dozens of coding exercises right in the browser. You will also implement coding assignments, such as a program processing the data read from an external API or an app for analyzing PDF files. You will also solidify your knowledge by solving short quizzes as well as doing final knowledge checks after each section.

This course comes with a 30-day money-back guarantee. If you are not satisfied, you can return it and get all your money back, no questions asked. In other words, you don't risk anything by purchasing this course. You have nothing to lose, and the knowledge you will gain may take your career to the next level.

So, why hesitate? Join me in this course and start coding like a professional.

1. Introduction
2. Welcome! Basic information & how to get help
3. 46 seconds about your instructor
4. 72 seconds about what this course is
5. 105 seconds about what this course isn’t
6. 97 seconds about practicing what you learn
7. 112 seconds about time optimization
8. Installing Visual Studio Community
9. Accessing the code
10. Resources you can download
11. Coding exercises issues troubleshooting
12. C# Fundamentals
13. Section introduction
14. Our first C# program
15. From a text file to an executable program
16. Programmer's most important skill
17. The goal for this section
18. Variables
19. Naming variables & introduction to clean code
20. Variables
21. Operators
22. Implicitly typed variables
23. User input
24. Debugging with breakpoints
25. Coding exercises introduction
26. Variables and operators
27. Comments
28. Boolean type. Logical negation, equality, comparison, and modulo operators
29. Bools & operators
30. AND and OR logical operators
31. Boolean type and operators
32. if/else conditional statement
33. if/else conditional statement
34. The scope of local variables
35. Booleans, operators and if/else conditional statement.
36. Methods - part 1 - void methods
37. Methods - part 2 - non-void methods
38. Methods - AbsoluteOfSum method
39. Methods - part 3 - parameters types and the return type. Static typing in C#
40. Methods and typing
41. Parsing a string to an int (int.Parse method)
42. The first exception
43. Adding a new project to a solution
44. Assignments - Introduction
45. Assignment - Simple Calculator - Description and requirements
46. Assignment - Simple Calculator - It's time for you to implement it
47. Assignment - Simple Calculator - Solution
48. String interpolation
49. String interpolation - FormatDate
50. Switch statement
51. Switch statement - DescribeDay
52. Char
53. A need for loops
54. While loop - part 1
55. += and ++ operators. Infinite loops
56. While loop - part 2
57. While loop - CalculateSumOfNumbersBetween
58. Do...while loop
59. Do-while loop - RepeatCharacter
60. For loop
61. For loop - Factorial
62. Break
63. Continue
64. Break and continue
65. Nested loops
66. Loops performance
67. Arrays
68. Arrays
69. Arrays (1) - BuildHelloString
70. Arrays (2) - IsWordPresentInCollection
71. Multi-dimensional arrays
72. Multi-dimensional arrays - FindMax
73. Foreach loop
74. Foreach loop - IsAnyWordLongerThan
75. Lists
76. Lists - GetOnlyUpperCaseWords
77. "out" keyword
78. TryParse method
79. Assignment - TODO List - Description and requirements
80. Assignment - TODO List - It's time for you to try to solve it
81. Assignment - TODO List - Implementation - User options & adding a TODO
82. Assignment - TODO List - Implementation - Listing and Removing TODOs
83. Assignment - TODO List - Refactoring
84. Section final quiz
85. Basics of Object-Oriented Programming
86. Section introduction
87. The issues in our code. A need for Object-Oriented Programming
88. Introduction to object-oriented programming
89. Understanding OOP with the DateTime type
90. Basics of OOP
91. Abstraction
92. Our first class
93. Data hiding
94. Custom constructor
95. HotelBooking class
96. C# restrictions on code outside classes. Top-level statements
97. Adding methods to classes
98. Basics of classes
99. Encapsulation
100. The Triangle class
101. Methods overloading
102. Constructors overloading. Calling one constructor from another
103. Encapsulation & overloading
104. Expression-bodied methods
105. "this" keyword (current instance reference)
106. Optional parameters
107. Dog class
108. Validation of constructor parameters
109. Readonly and const
110. Optional parameters and more
111. Limitations of fields. A need for properties
112. Properties
113. Properties of the Order class
114. Object initializers
115. Computed properties
116. Computed properties - DailyAccountState class
117. Static methods and classes
118. Static classes - NumberToDayOfWeekTranslator
119. Static fields, properties and constructors
120. Properties & static
121. string.Split and string.Join methods
122. Single Responsibility Principle - Introduction
123. Single Responsibility Principle - Refactoring (part 1)
124. Single Responsibility Principle - Refactoring (part 2)
125. Single Responsibility Principle - Refactoring (part 3)
126. Single Responsibility Principle
127. Files, namespaces and the using directive
128. Global using directives
129. Assignment - Dice Roll Game - Description and requirements
130. Assignment - Dice Roll Game - It's time for you to try to solve it
131. Assignment - Dice Roll Game - Random
132. Assignment - Dice Roll Game - Magic Number Antipattern
133. Assignment - Dice Roll Game - Designing classes
134. Assignment - Dice Roll Game - Enums
135. Assignment - Dice Roll Game - Ternary conditional operator
136. Section final quiz
137. Object-Oriented Programming: Polymorphism, Inheritance, Interfaces
138. Section introduction
139. A need for polymorphism
140. Inheritance
141. Inheriting members from the base class. Protected access modifier
142. Basics of polymorphism
143. Overriding members from the base class. Virtual methods and properties
144. Virtual methods - practice
145. Inheritance & Overriding - Animals
146. Virtual methods - StringsProcessor classes
147. A deeper inheritance hierarchy
148. Multiple inheritance
149. System.Object and the ToString method
150. Virtual methods and properties
151. Inheriting constructors and the "base" keyword
152. Implicit conversion
153. Explicit conversion
154. Conversion
155. Upcasting and downcasting
156. "is" operator
157. Null
158. "is" operator and null object -NumericTypesDescriber class
159. "as" operator
160. Abstract classes
161. Abstract methods
162. Abstract methods - Shapes
163. A need for abstract methods
164. Sealed classes and methods
165. Static classes are always sealed
166. Abstract & sealed
167. Extension methods
168. Extension methods - List extensions
169. A need for interfaces
170. Interfaces
171. Interfaces - Applying multiple transformations to a number
172. Interfaces vs abstract classes
173. Interfaces
174. JSON
175. Assignment - Cookies Cookbook - Description and requirements
176. Assignment - Cookies Cookbook - It's time for you to try to solve it
177. Assignment - Cookies Cookbook - High-level design
178. Assignment - Cookies Cookbook - Dependency Inversion and Dependency Injection
179. Assignment - Cookies Cookbook - Designing data types
180. Assignment - Cookies Cookbook - Printing data object. LINQ.
181. Assignment - Cookies Cookbook - Printing the ingredients
182. Assignment - Cookies Cookbook - Composing the recipe by the user
183. Assignment - Cookies Cookbook - Reading and writing from and to a *.txt file
184. Assignment - Cookies Cookbook - Reading and writing from and to a *.json file
185. Assignment - Cookies Cookbook - Template Method Design Pattern
186. Assignment - Cookies Cookbook - Cleanup and project organizing
187. Section final quiz
188. Exceptions and error handling
189. Section introduction
190. Exception object
191. Stack trace
192. Handling exceptions. Try-catch-finally
193. Try-catch-finally. DivideNumbers
194. Multiple catch blocks
195. Basics of exceptions
196. Throwing exceptions explicitly
197. Built-in exception types
198. Built-in exceptions
199. StackOverflowException. Recursive methods
200. Precise exceptions

The course gets updated frequently - Last update: 1st of July 2023

Have you ever had an idea for a program, an app, or a game?

Maybe you want to work as a developer? Then you are in the right place. In this course, you are going to discover how to become a c# developer - one of the best programming languages on earth!

C# is one of the few programming languages which allows you to create amazing cross-platform Mobile Apps, Games, and PC Programs. 

Bringing an Idea to life is one of the best feelings one can have, but the path to get there is often full of challenges. So I have created a course that makes this path as easy as possible all with the help of c# so that you become a skilled c# developer!

You start off by learning the C# basics and C# programming concepts in general:

• variables

• methods

• arrays

• if statements

• loops

Then you learn the three pillars of Object-oriented programming.

• Classes and Objects

• Inheritance

• Polymorphism

Once you mastered them, you will go into advanced C# Topics, such as:

• Databases

• Linq

• WPF

• Test-Driven Development TDD (Unit Testing)

In order to really become really good in c# programming, you have to program yourself, so I have created loads of exercises (and quizzes) for you to try for yourself to do c# programming and also to see how it is done afterward. Of course, you learn the best programming practices along the way.

Equipped with those skills, you will build beautiful user interfaces with WPF - A framework, which makes creating GUI’s a piece of cake.
By that point, you can create your very own complex programs.
But what comes next is even cooler.

Learn Game Development with Unity and C# - Build 3 awesome games.

As C# can be used for multiple different areas of programming, I have decided to cover the most important ones. So I have added a whole bunch of chapters specifically designed for a C# developer and Unity game developer - arguably the best Game Engine in the world. In those chapters, you will discover how to create your very own video games by building pong, the mother of video games, and Zig-zag, an amazing and successful endless runner game.

We live in a world where knowledge and work are shared more than ever, so using assets provided by others is a huge boost to your progress.  You will learn how to use 3D assets to make an endless runner. Then you’ll use animations, reset the game, use particle systems, and finally create a map procedurally. That’s quite some advanced stuff right there.

I know that learning to code can be hard at times, and sometimes you just get stuck. But no worries, we are there for you. We answer each question as quickly as we can and make sure that you reach your goal of becoming a developer.

WHO IS THIS COURSE FOR?

The course is for anyone, who wants to learn c# and wants to become professionally good in c# programming. No experience is required whatsoever. It is designed so that anyone who can handle a mouse and keyboard will succeed in finishing it. The only real requisite is the desire to learn.

 30-DAY FULL MONEY-BACK GUARANTEE

This course comes with a 30-day full money-back guarantee. Take the course, watch every lecture, and do the exercises, and if you feel like this course is not for you, ask for a full refund within 30 days. All your money back, no questions asked.  

ABOUT YOUR INSTRUCTOR:

My name is Denis Panjuta, and in my courses, I have taught over 350.000 students how to code. I have a Bachelor of Engineering from the University of Applied Sciences in Constance (Germany). I love teaching and creating high-quality courses. My mission is to teach programming to over 10.000.000 people! 

As you see, this is the only C# course you will ever need!

You will learn all the c# fundamentals, all c# basics, and everything that you need to know to succeed in c# programming and building your own cool video games! 

So don’t waste any more time and start to make your dreams and ideas come true by taking this course now.

1. Your First C# Program And Overview Of Visual Studio
2. Introduction
3. What Do You Want To Achieve?
4. Installing Visual Studio Community
5. Udemy Reviews Update
6. Hello World - First Program
7. Hello World Project Structure
8. Understanding the new and old Format and how to make a sound in the console
9. Hello World on Mac
10. Visual Studio Interface
11. What To Do If You Get Stuck
12. Whats new in Visual Studio 2022
13. BONUS: additional materials
14. Intro Quiz
15. Chapter 1 Summary
16. Want to become an employed C# developer?
17. Get the most from Tutorials.EU
18. Your first task to become a successful developer...
19. The different things you can build with C# and .NET
20. DataTypes And Variables
21. Quick Hint
22. High Level Overview of Variables and Datatypes
23. More Datatypes and Their Limits
24. Other Datatypes
25. Datatypes Int, Float and Double
26. Datatype String And Some Of Its Methods
27. Value vs Reference Types
28. Datatypes And Variables
29. Coding Standards
30. Console Class and some of its Methods
31. Naming Conventions and Coding Standards
32. Implicit and Explicit Conversion
33. Parsing a String To An Integer
34. Exercise: Parsing
35. String Manipulation
36. Some String Methods
37. How to use special characters in strings with the escape character
38. Challenge String and its methods
39. Solution For Exercise: Strings 1
40. Challenge String and its methods 2
41. Solution For Exercise: Strings 2
42. Challenge - Datatypes And Variables
43. Solution For The Challenge "Datatypes And Variables"
44. Using The var Keyword
45. Constants
46. Datatypes and Variables Part 2
47. C# Cheat sheets
48. DataTypes Summary
49. Functions / Methods And How To Save Time
50. Methods Intro
51. Intro To Functions / Methods
52. Void Methods
53. Methods With Return Value And Parameters
54. Methods
55. Challenge - Methods
56. Solution For The Challenge "Methods"
57. Test your methods
58. User Input
59. Try Catch and Finally
60. Operators
61. Operators
62. Methods Summary
63. Making Decisions
64. Making Decisions Intro
65. Introduction To Decision Making In C#
66. Intro to TryParse
67. IF And Else If + Try Parse
68. If & Else Coding Exercise
69. Nested If Statements
70. Nested If Statements
71. Challenge - If Statements
72. Solution For The Challenge "If Statements"
73. Switch Statement
74. Challenge - If Statements 2
75. Solution For The Challenge "If Statements 2"
76. Enhanced If Statements - Ternary Operator
77. Enhanced If Statements - Ternary Operator - Challenge
78. Enhanced If Statements - Ternary Operator - Challenge - Solution
79. If-Statements
80. Making Decisions Summary
81. Loops
82. Loops Intro
83. Basics of Loops
84. For Loops
85. Do While Loops
86. While Loops
87. Loops
88. break and continue
89. break and continue practice
90. Challenge - Loops 1 - Average
91. Solution For The Challenge "Loops"
92. Loops
93. Loops Summary
94. Object Oriented Programming (OOP)
95. Objects Intro
96. Introduction To Classes And Objects
97. Our First Own Class
98. Constructors and Member Variables
99. Using Multiple Constructors
100. Constructors
101. Access Modifiers
102. Constructors and Member-Variables
103. Shortcuts in VS
104. Useful shortcuts
105. Code Snippets in VS
106. Understanding private vs public for methods and variables
107. Setters in CSharp
108. Getters in CSharp
109. Properties in CSharp
110. Auto Implemented Properties
111. Read-Only and Write-Only Properties
112. Understanding Properties in C#
113. Implement Properties in C#
114. Members And Finalizers/Destructors
115. Objects Summary
116. Collections in C#
117. Arrays Intro
118. Basics of Arrays
119. Declaring and Initializing Arrays and the Length Property
120. Foreach Loops
121. Why Foreach?
122. Arrays, for and foreach loops
123. Multi Dimensional Arrays
124. Nested For Loops And 2D Arrays
125. Nested For Loops And 2D Arrays - Two Examples
126. Tic Tac Toe winner identifier
127. Arrays Quiz
128. Challenge - Tic Tac Toe
129. Jagged Arrays
130. Jagged Arrays or Multidimensional Arrays?
131. Challenge - Jagged Arrays
132. Using Arrays As Parameters
133. Why you can change an array by passing it as a variable
134. Params Keyword
135. Why would we use Params?
136. Getting The Min Value Of Many Given Numbers Using Params
137. Overview Generic and Non-Generic Collections
138. ArrayLists
139. Lists
140. Lists
141. Hashtables
142. Hashtables - Challenge
143. Dictionaries
144. Editing And Removing Entries in a Dictionairy
145. Dictionary practice
146. Queues and Stacks Overview
147. Stacks in Csharp
148. Queues
149. Arrays Summary
150. This far into the course? Reminder! Check this out if you want to be employed!
151. Debugging
152. Debugging Intro
153. Debugging Basics
154. Locals and Autos
155. Debugging, Creating Copies of Lists and solving some bugs
156. Debugging Call Stack, Throwing Errors and defensive programming
157. Inheritance And More About OOP
158. Welcome to Inheritance
159. Introduction To Inheritance
160. Simple Inheritance Example
161. Virtual and Override Keywords
162. Inheritance Demo
163. Inheritance Challenge - Videopost and Timer with Callback
164. Inheritance Challenge 2 - Employees, Bosses and Trainees
165. Inheritance Challenge 2 - Employees, Bosses and Trainees Solution
166. Interfaces Intro
167. Creating And Using Your Own Interfaces
168. Inheritances and Interfaces
169. IEnumerator and IEnumerable
170. IEnumerable Example 1
171. IEnumerable Example 2
172. IEnumerable
173. Inheritance Outro
174. Polymorphism And Even More On OOP + Text Files
175. Polymorphism Intro
176. Polymorphic Parameters
177. Sealed Key Word
178. Has A - Relationships
179. Abstract
180. Abstract and as & is Keyword / Polymorphism
181. Interfaces vs Abstract Classes
182. Read from a Textfile
183. Write into a Text File
184. Parsing game (part 1) / Read from and write into a file
185. Polymorphism Summary
186. Advanced C# Topics
187. Advanced Topics Intro
188. .net core vs .net framework
189. Access Modifiers
190. Structs
191. Enums
192. Math Class
193. Math Class
194. Random Class
195. VS 2019 and Regular expressions
196. Regular Expressions
197. Parsing game (part 2) / Regular Expressions
198. DateTime
199. Nullables
200. Garbage Collector

With over 50,000 happy students and 15,000+ positive reviews, this course is Udemy's most popular course for learning C# from scratch! 

C# is a beautiful cross-platform language that can be used to build variety of applications. With C#, you can build mobile apps (for Windows, Android and iOS), games, web sites and desktop applications.

Once you master fundamentals of C# and programming with .NET framework, you'll have lots of options in front of you. You can choose to build mobile apps if you prefer, or you can change job and work as a web developer. As long as you know the fundamentals well, switching to different technology stacks is pretty easy.

In this course, Mosh, author of several best-selling C# courses on Udemy, teaches you the fundamentals of C# programming in a clear, concise and step-by-step way. Note only that, but he'll also teach you best practices and shortcuts to help you become a better developer.

Every section comes with a few bite-sized video lectures and a quiz or programming exercises. These exercises are carefully chosen from academic and real-world examples to train your "programming brain". If you want to be a successful programmer, who has many high-paid job offers and freedom to "choose", you need to learn how to think like a programmer. And this is what you're going to get out of these exercises. All exercises come with solutions, so you can compare your solutions with Mosh's to find areas for improvement.

There are plenty of free tutorials and videos that teach you C# and they are great if all you want to learn is C# constructs. But if you want to learn C# and become a better programmer with a bright future and lots of options, this is the course for you. For every topic, not only will you learn the whats, but you'll also learn the whys, and hows. You'll see common errors that pop up as part of developing applications with C#. Mosh explains these errors in detail, and shows you how to resolve them.

THE COMPLETE C# PACKAGE

This course is the first part of Mosh's complete C# series on Udemy:

• Part 1: C# Basics for Beginners: Learn C# Fundamentals by Coding 
  
• Part 2: C# Intermediate: Classes, Interfaces and Object-oriented Programming
• Part 3: C# Advanced: Take Your C# Skills to the Next Level

WHAT OTHER STUDENTS WHO HAVE TAKEN THIS COURSE SAY:

"I’ve actually landed my first job as a Junior software developer. I owe a lot of it to you because your courses have been EXTREMELY helpful. May God bless you and your efforts to create high quality courses. This has really changed my life from working as a security guard and doing websites for free, now I am a professional." -Danish Jafri

"Great Instructor, Great Course, Mosh does a great job of breaking down the material and making it interesting." -Michael Gardner

"You can hear the passion in his voice which makes the course sound 10x more exciting then someone who just does it for the money." -Tim Medcalf

"Great Instructor, I love the way he teaches the course." -Edward Tkachev

"I love Mosh's approach of delivering the theory and then the practice. Audio and video quality are superb." -Paul Mooney

"You can definitely tell that Mosh is not only an experienced programmer, but he also cares deeply about producing great quality lessons and ensuring that his students are understanding the content." -David

30-DAY FULL MONEY-BACK GUARANTEE

This course comes with a 30-day full money-back guarantee. Take the course, watch every lecture, and do the exercises, and if you feel like this course is not for you, ask for a full refund within 30 days. All your money back, no questions asked. 

ABOUT YOUR INSTRUCTOR 

Mosh (Moshfegh) Hamedani is a software engineer with 17 years of professional experience. He is the author of several best selling Udemy courses with more than 120,000 students in 192 countries. He has a Master of Science in Network Systems and Bachelor of Science in Software Engineering. His students describe him as passionate, pragmatic and motivational in his teaching.

Do you want to start learning C# now? 

Join the other 50,000+ happy students who have taken this course and start coding within a few minutes.

1. Introduction
2. What is this Course
3. About Me
4. A Note on Taking this Course
5. Asking Questions
6. Before You Get Started
7. Introduction to C# and .NET Framework
8. Introduction
9. C# vs .NET
10. What is CLR?
11. Architecture of .NET Applications
12. Getting Visual Studio
13. Our First C# Application
14. What is ReSharper?
15. Fundamentals of C# and .NET
16. Summary
17. Primitive Types and Expressions
18. Introduction
19. Variables and Constants
20. Overflowing
21. Scope
22. Demo: Variables and Constants
23. Type Conversion
24. Demo: Type Conversion
25. Operators
26. What are Logical Operations?
27. Demo: Operators
28. Comments
29. Primitive Types and Expressions
30. Summary
31. Non-Primitive Types
32. Introduction
33. Classes
34. Demo: Classes
35. Structs
36. Arrays
37. Demo: Arrays
38. Strings
39. Demo: Strings
40. Enums
41. Demo: Enums
42. Reference Types and Value Types
43. Demo: Reference Types and Value Types
44. Demo: Reference Types and Value Types
45. Non-primitive Types
46. Summary
47. Control Flow
48. Introduction
49. Conditional Statements
50. Demo: If/Else and Switch/Case
51. Exercises
52. Iteration Statements
53. Demo: For Loops
54. Demo: Foreach Loops
55. Demo: While Loops
56. Random Class
57. Control Flow
58. Exercises
59. Summary
60. Arrays and Lists
61. Introduction
62. Arrays
63. Demo: Arrays
64. Lists
65. Demo: Lists
66. Exercises
67. Arrays and Lists
68. Summary
69. Working with Dates
70. Introduction
71. DateTime
72. TimeSpan
73. Dates and Times Quiz
74. Summary
75. Working with Text
76. Introduction
77. String
78. Demo: String
79. Live Coding: Summarising Text
80. StringBuilder
81. Demo: StringBuilder
82. Working with Text
83. Exercises
84. Procedural Programming
85. Summary
86. Working with Files
87. Introduction
88. System.IO Namespace
89. Demo: File and FileInfo
90. Demo: Directory and DirectoryInfo
91. Demo: Path
92. Exercises
93. Working with Files
94. Summary
95. Debugging Applications
96. Introduction
97. Debugging Tools in Visual Studio
98. Removing Side Effects
99. Defensive Programming
100. Call Stack Window
101. Locals and Autos Windows
102. Debugging Applications
103. Summary
104. What's Next?
105. What's Next?
106. Final Words
107. Get My Other Courses with a Discount

***** THE BEST SELLING C# COURSE ON UDEMY *****

Learn C# by doing, with real world projects.

"I have completed other courses on C#. While some of those instructors are trully excellent, including Moshe Hamedani, and othe courses on PluralSight, indeed i swore by PluralSight before coming to Udemy, Mr Vardhan has to be commended. This is trully the most comprehensive course a new C# learner needs to form a solid understanding not only of the basics but intermediate level subjects. If you want to learn C# and have full confidence that you are at least intermediate level after your course, take this course. Thank you sir for your dedication to the learner. Too often instructors create courses with the learner not in mind, but just to get something decent out there. This is so thorough and presented so that you will understand without ambiguity Thank you again sir!." - David Odoom

"Concepts are explained in very well manner" - Akanksha

"Great course, Focused on point with no distractions, straightforward, highly organized and really great effort. Thanks." - Nishma

"I have some programming experience. I like the flow of the instruction, and the fact that the quizzes allow for some creativity" - Michael

"Best Teacher ever hope more success for you and more courses for us" - Mohmd alkhatib

"i am still on the first sections of the course , but i wanted to write this review because this is a very good course on C# ,very clear in depth explanation and cover all the topics of C# , i only wish i have found this course sooner . update , i finished have the course still think this is the best C# course i have taking so far." - Moustamid Karim

"I like the background info. Extra effort was put in the graphics. I'm early in the course, but look forward to the rest.." - Mark Workman

"As a computer engineering graduate, I can easily say that this course really helped me to brush up my C# skills and the tutor (Mr. Harsha) is a caring person. He usually answers your questions in 12 hours." - Tayfun Odabaşı

"This course is amazing! Such a great instructor. Concepts are clearly and intelligently presented. I have a few C# courses and this one is by far my favorite. He doesn't just touch on a topic and bam you're on to the next one. He gives several examples and by the time that section is finished, you feel you really understand that concept. I can't give this course enough praise! I'm a professional C# dev and this course is helping fill in the gaps of my understanding. Thank you for such a great course!" - Business

"Incredible course for anyone looking to start with C# and OOP. I'm halfway through, and thus far every single concept has been explained in an easy-to-understand manner. The instructor also does a fantastic job of reinforcing the topics he's discussing by reiterating them multiple times in different ways and in different scenarios." - Vincent

...and more reviews.

**********************************************************************************************************************

List of topics that ARE covered in this course:

   - .Net Basics: Introduction to .NET, CLI, CLR, .NET Framework Architecture, Versions of .Net Framework, Overview of .Net Core, Introduction to Visual Studio, Basics of C#

   - Language Basics: System.Console class, Variables, Primitive Types, Control Statements

   - OOP Fundamentals: OOP Basics, Classes, Objects, Object References

   - Fields: Fields, Static Fields, Constants, Readonly Fields

   - Methods: Methods, Encapsulation, Abstraction, Polymorphism, Local Variables, Parameters, this keyword, Static methods, Default arguments, Named arguments, Method overloading, ref, out, out declaration, in, ref returns, params modifier, Local functions, Static local functions, Recursion

   - Type Conversion: Type conversion, Implicit casting, Explicit casting, Parse, TryParse, Conversion methods

   - Constructors: Constructors, Static constructors, Constructor overloading, Object initializer

   - Properties: Properties, Readonly properties, Writeonly properties, Automatic properties, Automatic properties accessibility, Automatic property initializers, Indexers

   - Inheritance: Inheritance, Various types of inheritance, base keyword, Calling parent class's constructor, Method hiding, Method overriding, Sealed classes, Sealed methods

   - Abstract Classes and Interfaces:  Abstract classes, Abstract methods, Interfaces, Dynamic polymorphism with interfaces, Multiple inheritance, Interface inheritance, Explicit interface implementation

   - Namespaces: Namespaces, Nested namespaces, Importing namespaces, Creating using alias, Using static

   - Partial & Static Classes:  Partial classes, Partial methods, Static classes, Enumerations

   - Structures: Structures, Readonly structures, Primitive types as structures

   - System.Object: System.Object class, Overriding methods of System.Object class, Boxing, Unboxing

   - Generics: Generic classes, Multiple generic parameters, Generic constraints, Generic methods

   - Working with Null: Nullable types, Null Coalescing operator, Null propagation operator

   - Extension Methods: Extension methods, Pattern matching, Implicitly typed variables, Dynamically typed variables, Inner classes

   - Garbage Collection: Garbage Collection, Generations of GC, Destructors, Finalize, IDisposable, Using Declaration

   - Delegates and Events: Single-Cast Delegates, Multi-Cast Delegates, Events, Auto-implemented events, Anonymous methods, Lambda expressions, Inline lambda expressions, Expression bodied members, Switch expression, Func, Action, Predicate, EventHandler, Expression Trees

   - Arrays: Creating arrays, Arrays with for loop, Arrays with foreach loop, Methods of System.Array class, Mult-Dim arrays, Index from-end operator, Jagged arrays, Array of objects

   - Collections: Working with various collections, List, Dictionary, SortedList, Hashtable, ArrayList, Stack, Queue, HashSet, typeof operator, Collection of objects, Object relations, IEnumerator vs IEnumerable, Iterators and Yield return, Custom Collections, ICollection, IList, IEquatable, IComparable, IComparer, Covariance and Contravariance

   - Anonymous types, Tuples, Value Tuples, Discards, String, DateTme, StringBuilder, Math

   - LINQ Basics

   - Exception Handling

   - System .IO namespace (File handling, Directory handling, File Streams)

   - Serialization (Binary, Json, Xml)

   - C# 9 and 10: Top level statements, File scope namespaces, Global using, Module initializer, Nullable reference types, Target-typed New expressions, Pattern Matching, Parameterless struct constructors, Records

PORTFOLIO PROJECT

• A mini project, "Banking application", where the bank user can create / edit bank accounts and also can perform deposit, withdraw, balance enquiry, account statement etc. operations.

• Some of the above features are given as assignments; so that you can exercise coding practices based on the guidelines provided.

List of C# 3.0 New Features covered in this course:

• Auto-Implemented Properties

• Anonymous Types

• Lambda Expressions

• Expression Trees

• Extension Methods

• Implicitly Typed Local Variables / Type Inference

• Partial Methods

• Object Initializer

• Collection Initializer

• LINQ

List of C# 4.0 New Features covered in this course:

• Dynamically Typed Variables

• Named Arguments

• Optional Arguments

• Covariance and Contravariance

List of C# 5.0 New Features covered in this course:

• Async & Await

List of C# 6.0 New Features covered in this course:

• Static Imports (using static)

• Exception Filters (catch when)

• Auto-Implemented Property Initializers

• Null Propagator

• String Interpolation

• nameof operator

List of C# 7.0 New Features covered in this course:

• Out Variable Declaration

• Tuples

• Discards

• Pattern Matching

• Local Functions

• Expression Bodied Members

List of C# 7.1 New Features covered in this course:

• Default literals

• Inferred Tuple Element Names

List of C# 7.2 New Features covered in this course:

• 'private protected' access modifier

• 'in' parameter modifier

List of C# 7.3 New Features covered in this course:

• Ref returns

• == operator on tuples

List of C# 8.0 New Features covered in this course:

• readonly structs

• Switch Expressions

• Using Declarations

• Static Local Functions

List of C# 9 and 10 New Features covered in this course:

• Top level statements

• File-scope namespaces

• Global 'using'

• Module initializers

• Nullable reference types

• Null forgiving operator

• Target-typed 'new' expressions

• Pattern Matching

• Extended Property Pattern Matching

• Init-only properties

• Parameter-less struct constructors

• Records

***********************************************************************************************************

POTENTIAL BENEFITS OF THIS COURSE

• By the end of this course, you will create all of the source code for a complete C# project, by using collections as backend for storage.

• You will type in every line of code with me in the videos ... all from scratch. No copy-paste of ready-made code.

• I explain every line of C# code that we create. So this isn't a copy/paste exercise, you will have a full understanding of the code.

• I am a RESPONSIVE INSTRUCTOR .... post your questions and I will RESPOND in 24 hours, ASAP.

• All source code is available for download.

• English captions are available.

***********************************************************************************************************

No Risk – Money-Back Guarantee

Finally, there is no risk. You can preview first few lectures of the course for free. Once you purchase the course, if for some reason you are not happy with the course, Udemy offers a 30-day money back guarantee.

So you have nothing to lose, sign up for this course and learn how to build C# Projects from scratch!

Key Points about this Course: 

• All C# programs are demonstrated using 'Console Applications' and 'Class Library' projects in Visual Studio 2019 / 2022.

• Each concept is first explained theoretically like understanding what is that concept, different types / syntax to write code. And then we will show the same with a real-world-like scenario. At last, I'll explain where exactly we use this concept in real-word applications.

• All the concepts explained in both theoretically, diagrammatically and practically.

• We use Visual Studio 2019 for up to C# 8; and Visual Studio 2022 for C# 9 and 10 features.

• Video lectures are not downloadable.

***********************************************************************************************************

The following topics are NOT covered in this course:

1. Multi-Threading

2. ADO .NET

3. Entity Framework

4. WPF / WCF

5. WinForms

6. Cryptography

7. Assemblies

1. Course Fundamentals (Theory)
2. Introduction to .NET
3. CLI
4. Where to start practicals
5. Where can I download course material & source code
6. CLR
7. .NET Framework Architecture
8. Versions of .NET Framework
9. Overview of .NET Core
10. Introducing Visual Studio
11. Introduction to C#
12. Introducing Object, Class, Fields and Methods
13. Introducing Namespaces
14. C# Language Tokens
15. Versions of C#
16. C# Naming Conventions
17. Section Cheat Sheet (PPT)
18. Section 1 - Interview Questions
19. C# Language Basics (Practical Starts Here)
20. Installing Visual Studio 2022
21. Creating First C# App using Visual Studio
22. The System.Console class
23. Variables
24. Primitive Types
25. Operators
26. Area of Circle
27. Feet to Centimeters
28. Nearest Thousand
29. Convert Seconds into Minutes
30. If, If-else, Else-if, Nested-if
31. Height Category
32. Largest of Three Numbers
33. Switch-Case
34. While, Do-While
35. For loop
36. Break
37. Continue
38. Nested For loops
39. Goto
40. Section Cheat Sheet (PPT)
41. Section 2 Interview Questions
42. Pattern Printing
43. Bank Project - Getting Started
44. Creating Login Form
45. Creating Main Menu
46. Creating Customers and Accounts Menu
47. C# Object Oriented Programming - Basics
48. Understanding OOP
49. Creating Classes & Objects
50. IMP Points to Remember about Objects
51. Section Cheat Sheet (PPT)
52. Section 4 Interview Questions
53. Fields
54. Understanding Fields
55. Access Modifiers of Fields
56. Playing with Fields of Multiple Objects
57. Static Fields
58. Constant Fields
59. Readonly Fields
60. Local Constants
61. Section Cheat Sheet (PPT)
62. IMP Points to Remember about Fields
63. Section 5 Interview Questions
64. Working with Multiple Objects
65. Methods
66. Understanding Methods
67. Encapsulation - Part 1
68. Encapsulation - Part 2
69. Local Variables & Parameters
70. this keyword
71. Static Methods
72. Object reference as Arguments
73. Default Arguments
74. Named Arguments
75. Method Overloading
76. Parameter Modifiers - Default
77. Parameter Modifiers - ref
78. Parameter Modifiers - out
79. Parameter Modifiers - Out Declaration
80. Parameter Modifiers - in
81. ref Returns
82. Parameter Modifiers - params
83. Local Functions
84. Static Local Functions
85. Recursion
86. IMP Points to Remember about Methods
87. Section Cheat Sheet (PPT)
88. Section 6 Interview Questions - Part 1
89. Section 6 Interview Questions - Part 2
90. Section 6 Interview Questions - Part 3
91. Section 6 Interview Questions - Part 4
92. Medical Bot with Fields and Methods
93. Type Conversion
94. Overview of Type Conversion
95. Implicit Casting
96. Explicit Casting
97. Parse
98. TryParse
99. Conversion Methods
100. IMP Points to Remeber about Type Conversion
101. Section Cheat Sheet (PPT)
102. Section 7 Interview Questions
103. Type Conversion
104. Constructors
105. Instance Constructors
106. Static Constructor
107. Types of Constructor
108. Constructor Overloading
109. Object Initializer
110. IMP Points to Remember about Constructors
111. Section Cheat Sheet (PPT)
112. Section 8 Interview Questions
113. The 'Question' class
114. Properties & Indexers
115. Creating Properties
116. Readonly & Writeonly Properties
117. Auto-Properties with Accessor Accessibility
118. Auto-Implemented Property Initializers
119. IMP Points to Remember about Properties
120. Creating Indexers
121. Indexer Overloading
122. Section Cheat Sheet (PPT)
123. Section 9 Interview Questions - Part 1
124. Section 9 Interview Questions - Part 2
125. ATM PIN Validation
126. Inheritance, Hiding, Overriding
127. Creating Inheritance
128. Types of Inheritance
129. 'base' Keyword
130. Parent Class's Constructor
131. Method Hiding
132. Method Overriding
133. Sealed Classes
134. Sealed Methods
135. Section Cheat Sheet (PPT)
136. Section 10 Interview Questions
137. IMP Points to Remember about Inheritance
138. Abstract Classes and Interfaces
139. Abstraction
140. Abstract Classes
141. Abstract Methods
142. Gaming Characters using Inheritance
143. Creating Interfaces
144. Dynamic Polymorphism with Interfaces
145. Multiple Inheritance with Interfaces
146. Interface Inheritance
147. Explicit Interface Implementation
148. Section Cheat Sheet (PPT)
149. Section 11 Interview Questions
150. Library Assignment with Interfaces
151. Namespaces
152. Creating Namespaces
153. Nested Namespaces
154. Importing Namespaces
155. Creating Using Alias
156. Using Static
157. Section Cheat Sheet (PPT)
158. Section 12 Interview Questions
159. Partial & Static Classes, Enumerations
160. Partial Classes
161. Partial Methods
162. Static Classes
163. Enumerations
164. Section Cheat Sheet (PPT)
165. Section 13 Interview Questions - Part 1
166. Section 13 Interview Questions - Part 2
167. Structures
168. Creating Structures
169. Structures with Constructors
170. Understanding Structures (vs) Class Practically
171. Readonly Structures
172. Primitive Types as Structures
173. Section Cheat Sheet (PPT)
174. Section 14 Interview Questions - Part 1
175. Section 14 Interview Questions - Part 2
176. System.Object Class
177. Overview of System.Object class
178. Understanding & Overriding Methods of Object class
179. IMP Points to Remember about Object class
180. Boxing
181. Unboxing
182. Section Cheat Sheet (PPT)
183. Section 15 Interview Questions
184. Generics
185. Generic Classes
186. Multiple Generic Parameters
187. Generic Constraints
188. Generic Methods
189. Section Cheat Sheet
190. Section 16 Interview Questions
191. Handling Null
192. Nullable Types
193. Null Coalescing Operator
194. Null Propagation Operator
195. Section Cheat Sheet (PPT)
196. Section 17 Interview Questions
197. Extension Methods and Pattern Matching
198. Extension Methods
199. Pattern Matching
200. Implicitly Typed Variables

Whether you want to use C# to build web apps, mobile apps, desktop apps or games, understanding C# classes, interfaces and principles of object-oriented programming is crucial.

This course is the second part of Mosh's best-selling C# series and is all about classes, interfaces and object-oriented programming. In essence, you'll learn:

• How to work with classes, constructors, fields, properties, methods and indexers
  
  
• How to use encapsulation to reduce the impact of change
  
  
• How to improve the robustness of your code
  
  
• How to re-use code using inheritance and composition
  
  
• Why composition is better than inheritance
  
  
• How to build extensible applications using polymorphism
  
  
• How to develop loosely-coupled, extensible and testable applications using interfaces

There are lots of free tutorials and videos on YouTube. Why would you want to take this course?

The answer is simple: quality of teaching.

Mosh is a passionate software engineer with over 13 years of experience developing applications in C#. He is the author of several best-selling C# courses on Udemy and knows how to lead you through a series of baby steps in a logical way.

So, from the very beginning to the very end, you'll be confident that you'll be in good hands and watching every minute of the course, unlike the reading many free tutorials and videos, does not waste your precious time.

Each section is equipped with a balanced mix of theory and practice. At the end of each section you'll get exercises to master the concepts you learn in that section.

And one last reason: all videos are produced with high quality video/audio, to provide you the best learning experience.

THE COMPLETE C# PACKAGE

This course is the second part of Mosh's complete C# series on Udemy:

• Part 1: C# Basics for Beginners: Learn C# Fundamentals by Coding 
• Part 2: C# Intermediate: Classes, Interfaces and Object-oriented Programming
• Part 3: C# Advanced: Take Your C# Skills to the Next Level

WHAT OTHER STUDENTS WHO HAVE TAKEN THIS COURSE SAY:

"I’ve actually landed my first job as a Junior software developer. I owe a lot of it to you because your courses have been EXTREMELY helpful. May God bless you and your efforts to create high quality courses. This has really changed my life from working as a security guard and doing websites for free, now I am a professional." -Danish Jafri

"Your courses have given me the confidence to get out of my dead end job and apply for a full time coding job. I am very happy to say that I just finished the job interview and they gave me the job!!!" -Dan Farnell

"Outstanding quality! I have come to learn that all Mosh's courses are top notch. This course is no different! The content is beautifully designed, well organized with great examples, and delivered in a clear and concise manner (with great video and audio quality)! I also loved that this course includes exercises. Fantastic stuff!" -Roger Sæle

"Love it! This guy definitely knows what he's talking about. He strives to make his courses as comprehensive as possible and he teaches you several tricks along the way." -Jeb Watson

"As with all of his courses his passion and love for programming is infectious. He does a great job of intermixing theory with hard examples and cautions with practicality. If you learn better by watching and examples then reading and theory this is a must watch to move beyond the learning the syntax of c#." -Michael Paul

"Excellent course! All of Mosh's courses are very much worth taking if you really want to learn C# in a professional way. Not only does Mosh clearly describe the syntax of the language and explain the language concepts, but he also constantly emphasizes the importance of good programming practices" -Tony Zampini

ABOUT YOUR INSTRUCTOR

Mosh (Moshfegh) Hamedani is a passionate software engineer and teacher with 13 years of experience building applications using C# (since the first release of .NET Framework in 2002). Mosh is a full-time developer and what you are going to learn in this course is the result of his day-to-day work as a hardcore programmer along with years of studying,

Mosh's students describe him as a passionate teacher who knows how to take a student on a series of logical steps and enriching them with a great mixed of theory and practice.

100% MONEY-BACK GUARANTEE

This course comes with a 30-day full money-back guarantee. Take the course, go through the lectures, do the exercises, and if you're not happy, ask for a refund within 30 days. All your money back, no questions asked.

So do you want to take your C# skills to the next level? Then take this course now and get started!

1. About this Course
2. What You are Going to Learn
3. Who is Your Instructor
4. Source Code
5. Exercises
6. Asking Questions
7. Before You Get Started
8. Classes
9. Introduction to Classes
10. Constructors
11. Object Initializers
12. Methods
13. Fields
14. Access Modifiers
15. Properties
16. Indexers
17. Summary
18. Exercises
19. Association between Classes
20. Class Coupling
21. Inheritance
22. Composition
23. Favour Composition over Inheritance
24. Summary
25. Inheritance - Second Pillar of OOP
26. Access Modifiers
27. Constructors and Inheritance
28. Upcasting and Downcasting
29. Boxing and Unboxing
30. Summary
31. Exercises
32. Polymorphism: Third Pillar of OOP
33. Method Overriding
34. Abstract Classes and Members
35. Sealed Classes and Members
36. Summary
37. Exercises
38. Interfaces
39. What is an Interface?
40. Interfaces and Testability
41. Interfaces and Extensibility
42. Interfaces are NOT for Multiple Inheritance
43. Interfaces and Polymorphism
44. Summary
45. Exercises
46. What's Next?
47. Final Words
48. My Other Courses
49. Get My Other Courses with a Discount
50. Bonus: Students' Code Reviews
51. StopWatch Exercise
52. Stack Exercise
53. Workflow Engine Exercise