Your cart is empty.
Keep shoppingC# Intermediate - Part II (Reflection, Events, LINQ)
28 students
C# Intermediate - Part II (Reflection, Events, LINQ)
Value and Reference Types, Generics, Reflection, Delegates and Events, Lambda and LINQ
Created byIvan Iliev
Last updated 12/2023
English
What you'll learn
- The different purposes of out, ref and in keyword.
- The similarities and distinctions between classes, structures and tuples.
- When and why to use dynamic keyword.
- What the dangers of not knowing the difference between value and reference types are.
- How to compare objects with Equals and GetHashCode methods and when to use IComparable and IComparer.
- Reverse engineer classes with the reflection technique.
- What the delegates and events are and when and why you should use them.
- Exotic examples with delegates and events and how they blend with some of the ideas of OOP (encapsulation and polymorphism).
- Five different ways of writing/reading files.
- What lambda expressions and LINQ are. Solve practical tasks with them.
Explore related topics
Course content
3 sections • 33 lectures • 11h 3m total length
Requirements
- Students should have knowledge about the basics of Object-oriented programming.
- Finishing my course "C# Intermediate - Part I (Mastering OOP)" will be of great help.
Description
This course will start with the explanation of intricacies between out, ref and in keyword. Then the students will learn about new data types (tuples and structures) – when and why they shall be used. After grasping all of the preceding knowledge there shall be no mistakes when students use value or reference types. The late-bounding (enabled by various techniques of polymorphism – inheritance, object, dynamic, generics and reflection) opens new doors that will be explored in this course in theory and practice.
The topics about delegates and events are very interesting and usually difficult for new developers. The concept of holding as a reference a method is something common to functional programming but C# allows you to get the advantages of that feature too. The students that will finish this course won’t have problems in understanding when and how to use delegates. The Event-driven Design (EDD) is based on the work with events and delegates (wired to them). Coupling EED with the knowledge and characteristics of OOP will help students build web, mobile and graphical applications in the near future/courses easily.
The last two important concepts that will be taught in this course are lambda expressions and LINQ. Understanding how they work will improve not only the development speed of different tasks/algorithms but will give the students opportunity to grasp the clever use of delegates, generics and the so called ‘Fluent API’ – a technique that will be used later (when we separate and specify our components/libraries of the n-tier application and/or use ORM such as EF Core).
Before we start making multi-tier applications a strong foundation of knowledge, skills and experience with solving simple tasks are necessary. This course is the third stepping stone towards achieving that goal.
I hope that my students will be benevolent toward each other in the Q&A section of the courses and be successful in their future career as a software developer (and engineer).
Who this course is for:
- Anyone who has an interest in software development and particularly object oriented programming.
- Students that finished my course "C# Intermediate - Part I (Mastering OOP)".