The Complete Advanced C# course 2024

Explore object-oriented programming in Python, defining classes as blueprints, creating objects with attributes and methods, and applying inheritance, encapsulation, and polymorphism to build modular, scalable code.

A class is defined as a blueprint for creating objects, detailing attributes and methods, and it explores instantiation, encapsulation, abstraction, inheritance, and polymorphism.

Learn how to define a class in c sharp, using the class keyword, public properties and methods to model a customer and a bank account in an object oriented design.

Explore how an object in C# is an instance of a class created with new, using a Customer class with first name, last name, email, and phone.

Explain what a method is and its structure, including the access modifier, return type, method name, and parameter list, plus a public string example returning a first and last name.

Learn how constructors in a C# class initialize new objects, are invoked automatically with the new keyword, and support overloading, default constructors, and proper initialization order in inheritance.

Learn constructor implementation in c#, covering syntax, access modifiers, no return type, initialization, and parameterized overloads for public or private constructors.

Explore how inheritance lets a derived class reuse attributes and methods from a base class, forming a hierarchy that enables extension, polymorphism, and access modifiers such as public and protected.

Explore encapsulation in object-oriented programming by bundling data and methods into a class, enforcing data hiding, access control via modifiers, and abstraction to ensure data integrity and modularity.

Explore abstraction in object oriented programming: hide details, model real-world concepts with classes, and hide data and behavior behind simple interfaces. See how encapsulation and interfaces enable modular, reusable designs.

Understand polymorphism in object-oriented programming, including method overriding, dynamic binding, subtype and interface polymorphism, static polymorphism via method overloading and operator overloading, and abstract classes and dynamic dispatch.

Learn how interfaces define a contract for methods and properties, enable separation of concerns and polymorphism, support multiple implementations, and aid dependency injection in object oriented design.

Explore how dependency injection decouples classes in C#, enabling inversion of control and easier testing by injecting dependencies via constructor, property, or method, with an IoC container demonstration.

Explore abstract, partial, and sealed classes in C#. Learn how abstract classes define shared behavior with abstract members, how partial classes split across files, and how sealed classes prevent inheritance.

Learn what tuples are in C#: fixed-size, ordered collections of heterogeneous elements, immutable after creation, used for returning multiple values or passing multiple arguments, via tuple class or tuple literal.

Explore C# access specifiers for classes, including public, internal, protected, and private, and learn how they control visibility, encapsulation, and inheritance within and across assemblies.

Explore fundamental software design principles, including SRP, OCP, Liskov substitution principle, ISP, DIP, plus don't repeat yourself and composition over inheritance to keep software simple.

Explore software patterns as reusable design solutions that address specific problems, provide a common language, and classify into creation, structural, and behavioral types, with examples like singleton, observer, and strategy.

Explore software development life cycle patterns, from phases to agile, lean, and hybrid approaches. Understand test-driven development with red-green-refactor cycles, automated testing, regression prevention, and high test coverage.

Explore why test-driven development (TDD) matters: write tests first to define expected behavior, gain rapid feedback, ensure regression safety, promote modular, maintainable design, and support CI/CD pipelines.

Explore functional programming as a paradigm that treats computation as mathematical functions and highlights first-class and higher-order functions, pure functions, immutable data, recursion, and map, filter, reduce.

Discover how delegates in dotnet serve as type-safe function pointers that encapsulate methods, enabling passing, storing, and dynamic invocation for callbacks and event handling.

Implement delegates to validate data using order and delivery date validators, wire them through a constructor, and call delegates to enforce validation rules in a C# context.

Showcase delegates in a C# console app by testing a date validator for orders and deliveries, validating weekends and delivery dates with a practical, hands-on delegate workflow.

Learn how to declare a delegate in C#, assign methods to it, pass it as an argument, and invoke it to execute methods dynamically.

Learn to implement and invoke a delegate in a console app to extract distance or journey time from a car, and compute yesterday versus today differences using a comparison class.

Learn to implement a car class with random journey times, read and parse user input to double using culture-aware number styles, and display results inside a loop.

Explore lambda expressions in C#, writing anonymous methods as inline functions with compact syntax, type inference, and delegates for linq, events, and a two-integer sum.

Implement and simplify lambda functions using anonymous methods, delegates, and expression or statement lambdas, including asynchronous lambdas with await, and capture variables for event handlers and list operations.

Explore lambda implementation part 2: see how lambdas capture values and class members, learn scope rules, and note captured variables persist until the delegate is collected, with language-integrated query context.

Explore language integrated query (linq) in C#, unifying data queries across collections, databases, and xml with fluent syntax; leverage deferred execution, extension methods, and strong typing.

Explore how to implement language integrated queries in C# by using LINQ query operators and the query syntax, enabling filtering, projection, aggregation, and sorting with deferred execution.

Build a linq implementation in C# by modeling articles, customers, and orders, then query article names bought by a customer since a given day using joins.

Demonstrates advanced LINQ in C# by building a text query: split text, apply where, order by, group by, select results, and print with console output.

Explore concurrency in computer science, where tasks run simultaneously to improve efficiency and responsiveness; learn about parallelism, threads, processes, and models like cooperative and pre-emptive multitasking and event-driven programming.

Learn why concurrency matters for performance, responsiveness, scalability, and resource utilization by efficiently using RAM and multi-core hardware in real world applications.

Explore threads in C# for parallel and asynchronous execution, creating threads with the thread class and passing delegates, while synchronizing data with locks, mutexes, semaphores, monitors, and pool work items.

Define what a task is and how to create it with an action delegate, cancellation tokens, creation options, and explore properties like is completed, is cancelled, and is started.

Explore creating and starting tasks in C# using Task, Task.Run, and Task.Factory.StartNew, including non-generic and generic variants, cancellation tokens, and asynchronous delays.

Learn how concurrent bag provides a thread-safe, unordered collection for multi-threaded scenarios, allowing concurrent add, remove, and iteration without external synchronization. Ideal for parallel loops and producer consumer patterns.

Discover the concurrent queue, a thread-safe FIFO collection for multiple threads to enqueue and dequeue. Peek at the first item and apply it to producer-consumer and synchronous task processing patterns.

Explore the concurrent stack in .NET, a thread-safe LIFO collection in System.Collections.Concurrent that supports push, pop, and peek concurrently, enabling parallel loops and producer-consumer patterns.

BlockingCollection<T> wraps another collection to enable thread-safe, blocking, and bounded access for producer and consumer threads, with optional cancellation tokens and GetConsumingEnumerable support.

Learn how concurrent dictionary provides thread-safe key-value storage for TKey and TValue, enabling multi-threaded add, update, remove, and enumeration with internal synchronization.

Learn how to use async and await in C# to write non-blocking, responsive code, handle exceptions, and implement asynchronous HTTP requests with a practical download example.

Explore asynchronous programming in C#, mastering concurrency and non-blocking operations to run time-consuming tasks efficiently. Use callbacks, promises, and event-driven architectures with robust error handling to build responsive, scalable applications.

Explore asynchronous download with a web client by converting a synchronous download into an async flow, using download string async and a download complete event to prevent blocking.

Explore delegates and lambda expressions in C# for asynchronous programming with async and await, including an async delegate using a lambda to delay a second and return 42.

Explore exception handling in asynchronous C# code, using try catch around awaits, understanding task results, aggregate and inner exceptions, propagating errors, and logging with Serilog and similar frameworks.

Explore advanced exception handling in asynchronous C# by implementing try-catch blocks with and without await, observing task continuations, and logging exception messages and stack traces.

Learn PLINQ, the parallel language integrated query in dotnet, enabling C# queries on data sources like arrays, databases, and XML to run in parallel on multi-core processors and boost performance.

Leverage PLINQ to parallelize downloading 100 web pages using an HTTP client and an async lambda, reducing total time by running requests concurrently.

Explore the System.IO namespace for input and output operations, including files, directories, paths, and streams. Learn to read and write data with file, directory, path, stream, and binary readers/writers.

Explore the System.IO.Path class, learning how to combine paths, resolve absolute paths, extract file names and extensions, change extensions, and determine rooted paths for cross-platform file handling.

Master path methods in c# using path combine overloads to assemble paths, and retrieve directory name, file name, and extension, while generating a random temp file in the temp folder.

Learn to work with files and directories in C# using DirectoryInfo and FileInfo, create and delete directories, and explore path properties, attributes, and timestamps.

Explore a recursive function that prints directory contents to the console with file methods. Compare get versus enumerate calls, and learn to write, append, and read text files, handling errors.

Explore streams in C# as byte sequences used to read from or write to files, networks, or memory, via the System.IO namespace.

Implement a C# file I/O workflow by writing with FileStream and StreamWriter and reading with the open text method and StreamReader, using UTF-8 and end of stream loop.

Explore memory streams in C#, writing and reading data entirely in memory as a byte stream, with operations to set position, adjust length, and copy data without physical storage.

Advance your deep learning skills through consistent practice and goal setting, building and sharing a model from Kaggle or UCI datasets.