C# Zero to Hero: OOP, LINQ, Async & Advanced Concept

Master intermediate to advanced C# concepts, including operator overloading, delegates, anonymous methods, and LINQ. Explore value versus reference types, stack and heap memory, events, nullable types, and asynchronous programming.

Explore operator overloading in C#, learn why to overload operators, the rules, and how to implement meaningful additions like combining two players' skill sets and experience points through overloaded operators.

Learn the rules of operator overloading in C#, including public static operators, left and right operands, and overloads for plus, comparison, and implicit or explicit casting with a player class.

Learn to implement operator overloading in a console application by building a class with constructors, display methods, and a plus operator for combining skill sets and xp.

Explore operator overloading in C#, including the plus and comparison operators, and implement implicit and explicit conversions for class instances such as players with XP.

Explore the theory and practical design of C# indexers, showing how to expose internal data structures like a player's inventory through simple, index-based access while preserving encapsulation.

Design a class with an inventory of items, fill it via a constructor and function, and implement a public get with index validation for safe item access.

Learn to work with index-based access in C# by validating bounds, reading and setting elements for an Archer, displaying inventory and skill sets, and testing with loops and console output.

Explain the difference between value types and reference types in C#, showing how structs copy values while classes reference memory and share data.

Explore value types versus reference types in C# by comparing independent copies of value types to shared references, illustrating how assignments alter memory and behavior, including stack versus heap concepts.

Explain stack and heap memory in C#, showing how variables store name, type, and value on the stack while objects reside in the heap and are allocated with new.

Understand how the stack holds Archer while new allocates the object on the heap, and how the automatic garbage collector deallocates heap memory in C#.

Understand stack versus heap memory in C# and how value types like structs differ from reference types such as strings and objects, with enums, booleans, and numeric types.

Discover how delegates in C# are typesafe objects that point to methods. Ensure signature compatibility, invoke methods, and allow multiple subscriptions by tracking name, arguments, and return values.

Master public delegates in C# by defining delegate signatures, instantiating and invoking them, and using the subscribe and unsubscribe operators to manage added methods.

Learn how a multicast delegate in C# can invoke multiple methods using the += operator, manage subscriptions with plus equals and minus equals, and route several callbacks through one delegate.

Explore public and multicast delegates in C#, binding one delegate to multiple methods and enabling subscribe, unsubscribe, and a single call that executes all attached methods with the same signature.

Explore C# delegates covariance, showing how a delegate that returns a base type can reference methods returning derived types, with examples using units, player, and sales employee.

Explore public delegates versus employee delegates in C# and see how a single delegate type can reference methods from both employee and sales employee classes using inheritance.

Create a single delegate type for an employee class and reuse it for other classes by mapping functions, demonstrating delegate covariance in action.

Discover anonymous methods and their relation to lambda expressions in C#, and learn how delegates enable inline, nameless code with flexible signatures through practical examples.

Learn how anonymous methods use delegates in C# to inline simple logic without named functions. The lecture shows defining, assigning, and calling anonymous delegates for tasks like summing numbers.

Explore delegates and anonymous methods in C# by building a simple program that counts numbers and sums a range, demonstrating inline functions and preparing for lambda expressions.

Explore lambda expressions and anonymous methods in C#, showing concise inline functions and passing functions as arguments. The lecture covers expression trees and the difference between expression and statement lambdas.

Explore lambda expressions in C# by contrasting expressions, delegates, and anonymous methods, demonstrate one-line versus statement lambdas, and show how to inline simple operations like adding five.

Learn how statement lambda and inline anonymous methods enable writing lightweight on-the-fly functions as predicates, and use find index with lists to locate elements.

Explore lambda expressions in C#, including expression lambdas and statement lambdas, using delegates to create concise function bodies, test by printing results to the console.

Explore how events enable notification in C# by using delegates, publishers, and subscribers, with practical examples of button clicks and text box interactions in GUI apps.

Explore how a publisher creates progress updates via a delegate and event, tracks percentage changes, and notifies subscribers of progress updates.

Explore a simple example of events and delegates in C#, showing how to subscribe multiple handlers with +=, invoke the event, and observe invocation order.

Learn to implement event coding in C# by subscribing to event handlers, using public delegates, and printing results to the console through static methods and multiple callbacks.

Create a class, declare and subscribe to a public event, and update a progress property to trigger event handlers as progress moves from 30 to 60.

Discover how extension methods add new functionality to existing types via a static class and static methods, callable like instance methods, with a string capitalization example.

Learn to build and apply extension methods in C# by defining a public static class and a static method in program.cs, then call the extension from main.

Explore extension methods in C# by implementing a static string extension to uppercase the first letter and using it in a sample program.

Explore extension methods in C# and learn to write and place a function inside a method. Compare static and non-static functions and design the main program.

Learn how nullable types enable representing missing values for value types in C#. Declare with T? name, check HasValue, and access Value while noting only value types can be nullable.

explain conversions and operators in c#, including implicit and explicit conversions, nullable types with the ? shorthand, and the coalescing operator ??, plus core binary and relational operators.

Explore the nullable coalescing operator in C# to assign default values when a value is null, with string and file name examples.

Explore boxing and unboxing of nullable types in C# with practical examples from the lecture caption. Learn how get type operations interact with boxed and unboxed values.

Explore nullable types in C#, using date time examples to show has value, get value or default, and usage to avoid exceptions, with guidance on initializing nullable and non-nullable types.

Explore building a customer class with nullable string addresses (permanent, local, office), using properties to access them and a null operator to handle nulls, with examples creating and evaluating customers.

Explore handling nullable types in C# master class by using null checks, the null-coalescing operator, and conditional statements to ensure safe customer data processing.

Explore language integrated query basics in C# by querying in-memory objects and databases, with a practical book repository example illustrating creating a book class and querying a collection.

Apply the main function to filter books priced under three dollars using a traditional loop, then enhance with extension methods and aggregate functions for efficiency.

learn C# fundamentals by using delegates, anonymous methods, lambda expressions, and extension methods to filter, order, and project books by price under three.

Explore how main functions such as first, single, skip, max, min, sum, and mean operate on collections of books, including handling missing items without crashing and using value or default.

utilize linq coding to build a book repository, filter priced under three using where predicates and extension methods, and demonstrate delegate usage in queries.

Master LINQ by ordering books by title, selecting titles and prices, and projecting with extension methods. Use from, where, select, order by, and single or first, handling no matches.

Learn advanced LINQ coding in C#, using a book dataset to demonstrate first or default, and perform aggregates like max, min, sum, and average with extension methods and skip.

Learn asynchronous programming by clarifying the difference with synchronous execution, where code runs line by line and time-consuming operations block, using examples like database access and heavy computations.

Learn how asynchronous programming keeps applications responsive by using callbacks to run a time consuming method without blocking the main flow, and compare it with synchronous execution in UI applications.

Identify when to use asynchronous programming to handle blocking operations like logging, downloads, files, databases, and graphics algorithms, and explore traditional versus modern async patterns with async and await.

Learn to build a Windows WPF application with a button and code-behind events. Explore synchronous and asynchronous downloads and how UI responsiveness avoids freezing.

Learn to implement asynchronous programming in a WPF app using async and await, keeping the user interface responsive while downloading content.

Refactor a non-async fetch into a private async function returning a string, call it on button clicks, await result, and keep the UI responsive by displaying the first 10 characters.

Create a new WPA project, design a window with a button, perform a synchronous download that writes to a local file with a stream writer, and address window freezing.

Explore asynchronous programming in C#, implementing async methods, awaiting downloads, and balancing sync and async patterns to keep the main thread nonblocking and responsive.

Explore asynchronous programming in C# by converting blocking operations to task-based async methods, compare synchronous and async versions, and learn when to use await to avoid UI freezing.

Explore exception handling in C#, catch and throw exceptions, manage memory, and build robust applications while handling division by zero and other input errors.

Master try catch blocks to handle division by zero and arithmetic exceptions without crashing, and learn to use specific or custom exceptions for robust error communication.

Explore exception handling in C# by demonstrating stream reader usage to read from a file, using try, catch, finally and using blocks, and applying IDisposable for disposal.

Create a YouTube API class with a get videos method, a YouTube exception, and friendly error messages; thread these into a try-catch flow in the main program to fetch videos.

Explore exception handling in C# by writing try-catch blocks, throwing and catching custom and system exceptions, exploring divide by zero errors and stack traces in a console app.

Learn to manage errors in C# by implementing try-catch blocks, disposing resources with using statements, and designing custom exceptions for robust YouTube videos API scenarios.

Compare static and dynamic typing across languages like C#, Java, C++, Ruby, Python, and JavaScript; explore compile-time versus runtime resolution and how reflection enables interop with SCORM and COM.

Explore dynamic typing in C# with runtime binding, reflection, and dynamic vs static types, and learn how implicit conversions and runtime exceptions shape robust code.

See how dynamics simplifies C# code versus reflection by transforming object handling, method calls, and hash code access, illustrating simpler maintenance and runtime safety compared to compile-time limitations.

Study how dynamic types behave at runtime in C#, compare them to static types, observe implicit conversions and runtime errors, and stress unit tests to validate dynamic code.

Demonstrate how to prevent boxing and unboxing by timing value-type versus object-type operations with a stopwatch, measuring durations and comparing method performance through practical code examples.

Learn how boxing and unboxing incur performance overhead, and how to prevent it by avoiding object usage, preferring generic collections over non-generic ones in mission-critical methods.

Compare two string concatenation methods in C#: plus operator versus a string builder, measure performance with a stopwatch, and explain string immutability causing allocations and speed gains with the builder.

Compare string concatenation strategies in C# by using a preallocated StringBuilder over the plus operator, and examine when performance benefits arise with stopwatch measurements.

Compare dot net collection classes such as list, genetic list, and non-genetic list, benchmarking performance with stopwatches to show native and genetic lists outperform non-genetic ones in mission-critical code.

Explore asynchronous programming in C#, from event-based and APM models to the task-based pattern with the Task Parallel Library, and learn async/await for nonblocking, responsive apps.

Learn why asynchronous programming boosts performance by letting input/output tasks like file access, network calls, and database operations run while your code stays productive, with a bank queue analogy.

Create a new ASP.NET website to demonstrate asynchronous programming by fetching an RSS feed from a third-party service and streaming the response while measuring elapsed time.

Learn to implement asynchronous methods in dotnet using task-based patterns and awaiting, so the caller can continue while downloads and other operations complete.

Demonstrate how asynchronous methods and tasks enable concurrent downloading of multiple RSS feeds—top stories, world news, and sports news—boosting performance over synchronous approaches.

Explore synchronous and asynchronous methods in c# by comparing task-based execution, awaiting results, and benchmarking with multiple requests to show when async helps or slows down performance.

Explore the power of asynchronous programming in download tasks, comparing synchronous versus asynchronous execution across multiple requests to show faster completion times for RSS feed downloads.

Explore cancellation tokens in asynchronous C# programming, showing how to cancel long-running tasks, enforce timeouts, and implement proper async/await patterns with task-returning methods for reading file content.

Continue exploring cancellation tokens by addressing how to gracefully cancel long-running file reads and tasks, avoid mixing synchronous and asynchronous code, and stop processing when the client disconnects.

Explore cancellation tokens in C# to terminate tasks when a client closes content, handle disconnect events, and enforce execution time limits.

Explore how cancellation tokens control asynchronous tasks in C#, including timeout handling, request timeouts, and the use of composite or linked tokens to cancel on multiple events.

explore two forms of parallelism for async tasks: io-bound operations and cpu-bound work, using task creation and thread pools, and learning when to await all tasks for performance.

Explore implementing asynchronous and synchronous patterns in an mvc action method, measuring total elapsed time, returning views, and leveraging cancellation tokens to manage long-running tasks.

Explore how to implement asynchronous processing in mvc applications. Compare synchronous and asynchronous patterns, and demonstrate performance gains using tasks, handlers, and interface design.

Learn to implement asynchronous database operations in C#, optimize performance by avoiding bottlenecks, and compare synchronous versus asynchronous access while reading from a customer table.

convert synchronous methods to asynchronous tasks, implement async data loading, and apply best practices for asynchronous programming to manage multiple tasks and improve responsiveness.

Learn how to implement asynchronous database queries to count records, compare async and synchronous execution, and boost scalability by processing multiple queries without blocking.

Explore how to implement asynchronous methods in a Windows Forms application to keep the UI responsive while performing IO operations and offloading CPU-intensive tasks from the UI thread.

Learn to create asynchronous methods in WinForms using a task completion source to return a task of int and await results while offloading work to a thread pool.