001 Welcome! Basic information & how to get help (12.33 MB)
002 46 seconds about your instructor (6.21 MB)
003 72 seconds about what this course is (2.26 MB)
004 105 seconds about what this course isn't (3.2 MB)
005 97 seconds about practicing what you learn (2.18 MB)
006 112 seconds about time optimization (5.61 MB)
007 Installing Visual Studio Community (13.37 MB)
008 Accessing the code (14.83 MB)
009 Requirements-for-all-assignments (937.62 KB)
001 Section introduction (1.55 MB)
002 Our first C# program (17.88 MB)
003 From a text file to an executable program (10.9 MB)
004 Programmer's most important skill (33.65 MB)
005 The goal for this section (4.29 MB)
006 Variables (44.74 MB)
007 Naming variables & introduction to clean code (43.99 MB)
009 Operators (22 MB)
010 Implicitly typed variables (8.05 MB)
011 User input (14.25 MB)
012 Debugging with breakpoints (30.65 MB)
013 Coding exercises introduction (22.18 MB)
015 Comments (25.42 MB)
016 Boolean type Logical negation, equality, comparison, and modulo operators (37.91 MB)
018 AND and OR logical operators (32.37 MB)
020 ifelse conditional statement (33.27 MB)
022 The scope of local variables (28.32 MB)
024 Methods - part 1 - void methods (44.17 MB)
025 Methods - part 2 - non-void methods (58.14 MB)
027 Methods - part 3 - parameters types and the return type Static typing in C# (15.58 MB)
029 Parsing a string to an int (int Parse method) (19.71 MB)
030 The first exception (12.91 MB)
031 Adding a new project to a solution (8.95 MB)
032 Assignments - Introduction (3.33 MB)
033 Assignment - Simple Calculator - Description and requirements (4.9 MB)
035 Assignment - Simple Calculator - Solution (96.58 MB)
036 String interpolation (17.84 MB)
038 Switch statement (46.14 MB)
040 Char (7.03 MB)
041 A need for loops (5.84 MB)
042 While loop - part 1 (10.7 MB)
043 += and ++ operators Infinite loops (14.31 MB)
044 While loop - part 2 (10.24 MB)
046 Do while loop (25 MB)
048 For loop (20.46 MB)
050 Break (17.35 MB)
051 Continue (32.94 MB)
053 Nested loops (4.69 MB)
054 Loops performance (12.85 MB)
055 Arrays (85.23 MB)
059 Multi-dimensional arrays (25.69 MB)
061 Foreach loop (5.52 MB)
063 Lists (60.27 MB)
065 out keyword (50.87 MB)
066 TryParse method (16.89 MB)
067 Assignment - TODO List - Description and requirements (11.77 MB)
069 Assignment - TODO List - Implementation - User options & adding a TODO (43.55 MB)
070 Assignment - TODO List - Implementation - Listing and Removing TODOs (19.39 MB)
071 Assignment - TODO List - Refactoring (88.87 MB)
001 Section introduction (2.82 MB)
002 The issues in our code A need for Object-Oriented Programming (16.35 MB)
003 Introduction to object-oriented programming (16.69 MB)
004 Understanding OOP with the DateTime type (14.33 MB)
006 Abstraction (14.16 MB)
007 Our first class (22.07 MB)
008 Data hiding (14.66 MB)
009 Custom constructor (31.43 MB)
011 C# restrictions on code outside classes Top-level statements (31.39 MB)
012 Adding methods to classes (19.16 MB)
014 Encapsulation (13.47 MB)
016 Methods overloading (18.13 MB)
017 Constructors overloading Calling one constructor from another (7.86 MB)
019 Expression-bodied methods (6.11 MB)
020 this keyword (current instance reference) (14.33 MB)
021 Optional parameters (25.23 MB)
023 Validation of constructor parameters (17.77 MB)
024 Readonly and const (33.65 MB)
026 Limitations of fields A need for properties (23.21 MB)
027 Properties (31.91 MB)
029 Object initializers (22.04 MB)
030 Computed properties (10.32 MB)
032 Static methods and classes (54.5 MB)
034 Static fields, properties and constructors (17.79 MB)
037 Single Responsibility Principle - Introduction (34.7 MB)
038 Single Responsibility Principle - Refactoring (part 1) (67.64 MB)
039 Single Responsibility Principle - Refactoring (part 2) (37.91 MB)
040 Single Responsibility Principle - Refactoring (part 3) (32.21 MB)
042 Files, namespaces and the using directive (105.04 MB)
043 Global using directives (61.92 MB)
044 Assignment - Dice Roll Game - Description and requirements (6.07 MB)
046 Assignment - Dice Roll Game - Random (28.66 MB)
047 Assignment - Dice Roll Game - Magic Number Antipattern (10.37 MB)
048 Assignment - Dice Roll Game - Designing classes (31.62 MB)
049 Assignment - Dice Roll Game - Enums (17.08 MB)
050 Assignment - Dice Roll Game - Ternary conditional operator (46.8 MB)
001 Section introduction (1.89 MB)
002 A need for polymorphism (17.06 MB)
003 Inheritance (16.5 MB)
004 Inheriting members from the base class Protected access modifier (34.01 MB)
006 Overriding members from the base class Virtual methods and properties (65.18 MB)
007 Virtual methods - practice (43.49 MB)
010 A deeper inheritance hierarchy (6.81 MB)
011 Multiple inheritance (9.6 MB)
012 System Object and the ToString method (31.24 MB)
014 Inheriting constructors and the base keyword (46.89 MB)
015 Implicit conversion (12.72 MB)
016 Explicit conversion (28.92 MB)
018 Upcasting and downcasting (14.86 MB)
019 is operator (16.73 MB)
020 Null (27.88 MB)
022 as operator (10.88 MB)
023 Abstract classes (5.87 MB)
024 Abstract methods (35.74 MB)
026 A need for abstract methods (12.82 MB)
027 Sealed classes and methods (22.44 MB)
028 Static classes are always sealed (11.76 MB)
030 Extension methods (48.35 MB)
032 A need for interfaces (19.1 MB)
033 Interfaces (70.16 MB)
035 Interfaces vs abstract classes (24.75 MB)
037 JSON (31.24 MB)
038 Assignment - Cookies Cookbook - Description and requirements (22.87 MB)
040 Assignment - Cookies Cookbook - High-level design (53.94 MB)
041 Assignment - Cookies Cookbook - Dependency Inversion and Dependency Injection (63.23 MB)
042 Assignment - Cookies Cookbook - Designing data types (64.42 MB)
043 Assignment - Cookies Cookbook - Printing data object LINQ (61.76 MB)
044 Assignment - Cookies Cookbook - Printing the ingredients (22.15 MB)
045 Assignment - Cookies Cookbook - Composing the recipe by the user (21.15 MB)
046 Assignment - Cookies Cookbook - Reading and writing from and to a txt file (76.34 MB)
047 Assignment - Cookies Cookbook - Reading and writing from and to a json file (23.68 MB)
048 Assignment - Cookies Cookbook - Template Method Design Pattern (52.4 MB)
049 Assignment - Cookies Cookbook - Cleanup and project organizing (62.43 MB)
001 Section introduction (1.42 MB)
002 Exception object (9.79 MB)
003 Stack trace (22.26 MB)
004 Handling exceptions Try-catch-finally (34.5 MB)
006 Multiple catch blocks (28.85 MB)
008 Throwing exceptions explicitly (36.89 MB)
009 Built-in exception types (30.28 MB)
011 StackOverflowException Recursive methods (18.53 MB)
012 Precise exceptions (32.59 MB)
013 Rethrowing exceptions throw vs throw ex (39.88 MB)
015 Rethrowing a System Exception object (9.95 MB)
016 Global try-catch block (13.99 MB)
017 Code inside the catch block (13.94 MB)
018 Exception filters (9.76 MB)
020 Custom exceptions (11.8 MB)
021 When to define custom exceptions (21.81 MB)
023 Exceptions as a hidden part of a method signature (16.48 MB)
024 Two extreme schools of using exceptions (13.4 MB)
025 Smart usage of exceptions - throw (12.74 MB)
026 Smart usage of exceptions - catch (36.58 MB)
028 Assignment - Game Data Parser - Description and requirements (13.55 MB)
028 jsonFiles (631 B)
030 Assignment - Game Data Parser - Sunny day scenario (29.54 MB)
031 Assignment - Game Data Parser - Flow controlled by exceptions (52.74 MB)
032 Assignment - Game Data Parser - Adding details to JsonException (45.86 MB)
033 Assignment - Game Data Parser - Custom logger (38.1 MB)
034 Assignment - Game Data Parser - Reducing usage of exception (24.37 MB)
035 Assignment - Game Data Parser - Refactoring - Extracting methods (25.77 MB)
036 Assignment - Game Data Parser - Refactoring - SRP, DI and classes decoupling (115.64 MB)
001 Section introduction (1.85 MB)
002 Introduction to generic types (21.9 MB)
003 Understanding how List works under the hood (8.47 MB)
004 Simplified List (adding a new item) (14.53 MB)
005 Simplified List (deleting an item at given index) (22.44 MB)
006 A need for generic types Implementing a generic type (41.8 MB)
008 A need for tuples (24.41 MB)
009 Tuples (34.94 MB)
011 C# without generics ArrayList (29.67 MB)
012 Generic methods (15.11 MB)
013 Generic methods with multiple type parameters (17.48 MB)
015 Convert ChangeType method typeof keyword and the Type object (48.74 MB)
017 A need for type constraints (40.48 MB)
018 Improving the performance of the List Measuring the time of the code execution (33.65 MB)
019 Type constraints - the constraint on the base type (48.95 MB)
020 IComparable interface Ordering objects (26.51 MB)
021 Type constraints - the constraint on the implemented interface (18.8 MB)
023 Type constraints - numeric types Generic math (8.56 MB)
024 Type constraints - summary Multiple type constraints (12.9 MB)
026 Advanced use of methods - introduction (2.96 MB)
027 Funcs and Actions (17.91 MB)
029 Lambda expressions (17.87 MB)
031 Delegates (35.42 MB)
033 Dictionary - introduction (51.81 MB)
034 Dictionary - practice (58.16 MB)
036 A need for the Strategy design pattern (26.56 MB)
037 Refactoring the code using Funcs and lambda expressions (9.46 MB)
038 Open-Closed Principle Strategy design pattern (54.43 MB)
039 Generic filtering of collections (42.25 MB)
041 Caching (14.68 MB)
042 Assignment - Custom Cache - Description and requirements (16.01 MB)
042 AssignmentStartupFile (457 B)
044 Assignment - Custom Cache - Implementation (66.41 MB)
045 Assignment - Custom Cache - The Decorator design pattern (51.69 MB)
046 Assignment - Custom Cache - Composing many Decorators together (26.88 MB)
001 Section introduction (1.61 MB)
002 What is LINQ (28.46 MB)
003 LINQ and extension methods (7.14 MB)
004 LINQ, IEnumerableT and method chaining (28.79 MB)
005 Deferred execution (27.63 MB)
007 Any (19.24 MB)
008 All (10.84 MB)
010 Count (12.51 MB)
011 Contains (6.35 MB)
013 OrderBy (33.86 MB)
014 First and Last (28.79 MB)
016 Where (26.22 MB)
017 Distinct (3.62 MB)
019 Select (49.04 MB)
020 Average Anonymous types (25.96 MB)
022 Assignment - Refactoring to LINQ - Description and requirements (14.79 MB)
022 CookieCookbook (13.05 KB)
024 Assignment - Refactoring to LINQ - Nested loop and code readability (41.08 MB)
025 Assignment - Refactoring to LINQ - Find and Replace window (54.5 MB)
026 Assignment - Refactoring to LINQ - Fewer loops & multiline strings formatting (30.14 MB)
027 Assignment - Refactoring to LINQ - Checking if collection has duplicates (24.88 MB)
001 Section introduction (1.86 MB)
002 NET and C# (12.17 MB)
003 Common Intermediate Language (CIL) (8.64 MB)
004 Common Language Runtime (CLR) (11.83 MB)
006 Memory of a program The stack and the heap (16.62 MB)
007 Value semantics vs reference semantics (27.87 MB)
008 Value types vs reference types (21.32 MB)
010 Value types vs reference types - practical tips (25.07 MB)
011 ref keyword (14.79 MB)
013 Using ref with reference types (13.1 MB)
014 Unified type system A need for boxing and unboxing (21.25 MB)
015 Boxing and unboxing (21.56 MB)
016 Boxing and unboxing - performance cost (27.82 MB)
018 Garbage Collector - introduction (14.96 MB)
019 Garbage Collector - memory fragmentation and defragmentation (12.51 MB)
020 Garbage Collector - the Mark-and-Sweep algorithm (13.91 MB)
022 Garbage Collector - generations of objects (11.49 MB)
023 Memory leaks (13.2 MB)
024 Finalizers (20.31 MB)
026 Dispose method - introduction (4.31 MB)
027 Dispose method - writing to a file using StreamWriter (23.31 MB)
028 Dispose method - reading from a file using StreamReader (34.42 MB)
029 Dispose method - implementation (49.4 MB)
031 CSV files (9.07 MB)
032 Reading CSV files (32 MB)
033 Assignment - CSV Processing Improvements - Description and requirements (79.64 MB)
033 NetUnderTheHoodAssignment (63.4 KB)
035 Assignment - CSV Processing Improvements - Code analysis & tips (38.26 MB)
036 Assignment - CSV Processing Improvements - Reducing the size of Dictionaries (29.7 MB)
037 Assignment - CSV Processing Improvements - Reducing the number of boxings (81.93 MB)
038 Assignment - CSV Processing Improvements - Analysis (36.32 MB)
001 Section introduction (1.59 MB)
002 Reflection (41.95 MB)
003 Attributes (50.25 MB)
005 Limitations of attributes parameters types (5.4 MB)
007 Structs (18.53 MB)
008 Structs vs Classes - crucial differences (16.55 MB)
009 Structs vs Classes - low-level differences (13.85 MB)
010 Choosing between structs and classes (25.85 MB)
012 Why should we make structs immutable (10.09 MB)
014 Non-destructive mutation (6.42 MB)
015 with expression (10.25 MB)
016 Readonly structs (6.43 MB)
018 A close look at the System Object type The ReferenceEquals method (19.66 MB)
019 Equals method (13.35 MB)
020 Overriding the Equals method in classes (11.16 MB)
021 Overriding the Equals method in structs (40.1 MB)
023 IEquatableT interface (22.09 MB)
024 == operator (8.74 MB)
026 Operators overloading (21.04 MB)
027 Overloading of implicit and explicit conversion operators (20.86 MB)
029 Hash functions (21.51 MB)
030 Default implementation of the GetHashCode method (40.7 MB)
031 When to override the GetHashCode method (6.21 MB)
033 Overriding the GetHashCode method (32.76 MB)
035 ValueTuples (22 MB)
036 Benefits of immutable types (40.19 MB)
038 Records (52.19 MB)
039 Record structs (5.32 MB)
041 Nullable value types (35.02 MB)
042 Nullable reference types (40.58 MB)
043 Null-forgiving operator (45.25 MB)
044 Using nullable reference types Generic type constraints related to nullability (17.42 MB)
046 APIs (20.62 MB)
047 Querying an API using C# (30.94 MB)
048 A class for querying APIs (68.05 MB)
049 Assignment - Star Wars Planets Stats - Description and requirements (31.66 MB)
049 MockApiDataAccess (1.83 KB)
051 Assignment - Star Wars Planets Stats - JsonPropertyNameAttribute and DTOs (108.55 MB)
052 Assignment - Star Wars Planets Stats - Exceptions handling (44.85 MB)
053 Assignment - Star Wars Planets Stats - Type design (38.63 MB)
054 Assignment - Star Wars Planets Stats - Converting DTO to a custom type (57.84 MB)
055 Assignment - Star Wars Planets Stats - Finishing the app and the MaxBy method (38.13 MB)
056 Assignment - Star Wars Planets Stats - Refactoring (55.37 MB)
057 Assignment - Star Wars Planets Stats - Splitting the class (34.82 MB)
058 Assignment - Star Wars Planets Stats - Universal table printer (94.05 MB)
001 Section introduction (851.68 KB)
002 The role of the IEnumerable interface (11.69 MB)
003 A close look at the IEnumerable interface (11.5 MB)
004 Implementing IEnumerable (34.06 MB)
005 Implicit and explicit interface implementation (34.27 MB)
006 Implementing IEnumerableT (19.24 MB)
008 Indexers (25.24 MB)
010 Collection initializers (17.99 MB)
011 ICollection and IList interfaces (17.12 MB)
012 Breaking the Interface Segregation Principle (10.96 MB)
013 Interface Segregation Principle (11.97 MB)
014 The benefits of readonly collections (8.43 MB)
015 Readonly collections ReadOnlyCollection and ReadOnlyDictionary (35.5 MB)
017 Big O Notation (36.46 MB)
018 Binary search algorithm (29.22 MB)
019 Binary search algorithm - implementation (28.37 MB)
020 Binary search algorithm - complexity (8.19 MB)
022 Improving performance when using Lists (44.23 MB)
023 Linked list (2.82 MB)
024 Linked list vs List (17.35 MB)
025 Dictionaries under the hood (18.83 MB)
026 Performance of Dictionaries (8.58 MB)
028 HashSet (21.31 MB)
030 Queue (19.9 MB)
031 Stack (9.79 MB)
032 params keyword (12.68 MB)
034 A need for yield statement (11.51 MB)
035 yield statement - behavior analysis (20.25 MB)
036 yield statement and iterators (69.77 MB)
037 yield statement - practice yield break statement (51.55 MB)
039 Implementing IEnumerable interface using iterators (14.78 MB)
040 Assignment - Custom Linked List - Description and requirements (7.06 MB)
042 Assignment - Custom Linked List - Data structures (19.58 MB)
043 Assignment - Custom Linked List - The AddToFront method (8.89 MB)
044 Assignment - Custom Linked List - Implementing IEnumerable (14.87 MB)
045 Assignment - Custom Linked List - Adding new items at the end of the list (7.84 MB)
046 Assignment - Custom Linked List - The Clear method (44.49 MB)
047 Assignment - Custom Linked List - Removing items and the Contains method (43.73 MB)
048 Assignment - Custom Linked List - The CopyTo method (10.17 MB)
049 Assignment - Custom Linked List - Summary and performance Private classes (34.34 MB)
001 Section introduction (667.7 KB)
002 Projects and solutions (32.35 MB)
003 Project properties (23.15 MB)
004 Debug build vs Release build (3.52 MB)
006 Assemblies (5.05 MB)
007 Referencing types from another assembly (25.68 MB)
008 Referencing types from another project (20.67 MB)
009 Internal access modifier Principles of using access modifiers (35.18 MB)
010 Protected internal access modifier (7.42 MB)
011 Private protected access modifier (9.28 MB)
012 Access modifiers - summary (8.73 MB)
014 How to structure the code in a solution (12.93 MB)
015 NuGet (61.12 MB)
016 csproj files (44.54 MB)
017 sln files (17.15 MB)
018 Updating the NET version (11.18 MB)
001 Section introduction (1.08 MB)
002 Char (8.97 MB)
003 Char representation in memory Character encoding (13.13 MB)
004 Managing various encodings (33.05 MB)
006 Immutability of strings (5.37 MB)
007 Strings - value or reference types (22.79 MB)
008 Strings as members in structs (10.98 MB)
010 A need for StringBuilder (6.88 MB)
011 StringBuilder (25.52 MB)
013 String interning (45.33 MB)
014 Flyweight design pattern (8.11 MB)
015 Advanced string formatting (26.33 MB)
016 Culture-specific string formatting (14.22 MB)
017 Specific culture vs Invariant culture (12.69 MB)
019 Assignment - Tickets Data Aggregator - Description and requirements (13.34 MB)
019 Tickets (91.63 KB)
021 Assignment - Tickets Data Aggregator - Reading text from PDF (38.03 MB)
022 Assignment - Tickets Data Aggregator - List all PDFs from a folder (11.18 MB)
023 Assignment - Tickets Data Aggregator - Splitting a string by multiple separators (16.45 MB)
024 Assignment - Tickets Data Aggregator - Parsing culture-specific strings (32.27 MB)
025 Assignment - Tickets Data Aggregator - Saving result in a text file (45.98 MB)
026 Assignment - Tickets Data Aggregator - Refactoring (45.28 MB)
027 Assignment - Tickets Data Aggregator - Compliance with the SRP (81.21 MB)
001 Section introduction (1.54 MB)
002 Decimal number system (5.2 MB)
003 Binary number system (2.37 MB)
004 Maximal numbers on a given number of digits (8.87 MB)
006 Numbers in memory Integer (4.9 MB)
007 Adding binary numbers (3.16 MB)
008 Numeric overflow & silent failures (15.63 MB)
010 checked keyword (6.01 MB)
011 Checked context - when to use it (9.68 MB)
012 Scope of the checked context unechecked keyword (24.2 MB)
014 Integral numeric types overview (10.59 MB)
015 Floating-point numbers (3.66 MB)
016 double and float (7.44 MB)
017 Smart usage of binary floating point numbers (30.22 MB)
019 Decimal (13.49 MB)
001 Section introduction (1.02 MB)
002 A need for communication between objects (40.36 MB)
003 A need for the Observer design pattern (9.17 MB)
004 Observer design pattern (51.2 MB)
005 Defining an event and subscribing to it (18.01 MB)
006 Raising events (26.29 MB)
008 EventHandler delegate & EventArgs type (33.14 MB)
010 Event vs delegate members (9.8 MB)
011 Memory leaks caused by events (15.84 MB)
013 Windows Forms - introduction (5.36 MB)
014 The first Windows Forms app (19.57 MB)
015 Understanding Windows Forms files (25.51 MB)
016 Events in Windows Forms (39.07 MB)
017 Windows Forms - basic UI elements (26.57 MB)
018 Assignment - Numeric Types Suggester - Description and requirements (17.37 MB)
020 Assignment - Numeric Types Suggester - User Interface & basic events (38.76 MB)
021 Assignment - Numeric Types Suggester - Handling KeyPress event (38.39 MB)
022 Assignment - Numeric Types Suggester - Numbers validation and BigInteger type (28.91 MB)
023 Assignment - Numeric Types Suggester - Choosing numeric type (74.01 MB)
001 Section introduction (3.62 MB)
002 Manual tests vs Automated tests (5.43 MB)
003 Setting up the testing environment (18.62 MB)
004 First unit tests (22.41 MB)
006 Running the tests (46.53 MB)
007 Naming unit tests (8.77 MB)
008 Test messages (38.62 MB)
009 AAA pattern (10.16 MB)
011 TestCase (33.76 MB)
012 Naming parameterized tests (9.45 MB)
013 TestCaseSource (38.13 MB)
015 Assertions on exceptions Multiple assertions in single test (40.64 MB)
016 Value of unit tests (25.01 MB)
017 Basic assertions (27.12 MB)
019 Testing private methods (30.2 MB)
020 Testing internal methods (19.77 MB)
021 Benefits of unit tests - no fear of refactoring (8.15 MB)
022 Benefits of unit tests - better design (9.98 MB)
023 Benefits of unit tests - early bug detection (5.46 MB)
024 Downsides of unit tests (14.37 MB)
026 Assignment - Fibonacci generator tests - Description and requirements (14.63 MB)
027 Assignment - Fibonacci generator tests - solution (74.6 MB)
028 Testing classes depending on other classes (24.62 MB)
029 A need for mocks (8.31 MB)
030 Mocks (22.47 MB)
031 Controlling the mock behavior (9.23 MB)
033 The benefits of using mocks (5.03 MB)
034 Advanced mock setup (34.73 MB)
035 Assertions checking if a method was called (24.83 MB)
036 Advanced assertions on method calls (18.77 MB)
038 Clean code in unit tests (3.36 MB)
039 Common setup for tests (21.8 MB)
040 Tests, Dependency Inversion and Dependency Injection (10.95 MB)
041 Untestable code - no Dependency Inversion (11.16 MB)
042 Untestable code - static methods (62.87 MB)
044 Other kinds of software tests (15.48 MB)
046 Assignment - Unit tests for GuessingGame - Description and requirements (3.48 MB)
047 Assignment - Unit tests for GuessingGame - Basic scenarios (75.51 MB)
048 Assignment - Unit tests for GuessingGame - Verifying messages (60.25 MB)
049 Assignment - Unit tests for GuessingGame - Approaches for messages validation (35.11 MB)
050 Assignment - Unit tests for GuessingGame - Resource files (79.14 MB)
001 Section introduction (1.31 MB)
002 The importance of clean code (10.95 MB)
003 Bad decisions related to code quality (7.83 MB)
004 Tech debt (6.42 MB)
005 Being professional (5.53 MB)
006 What is clean code (8.08 MB)
008 The importance of meaningful names (5.25 MB)
009 Renaming The Boy Scout Rule (6.81 MB)
010 Dealing with problematic naming (5.28 MB)
012 Expressive names (5.12 MB)
013 Long and short names (10.24 MB)
016 Principle of the least surprise (11.99 MB)
018 Bad names - meaningless words (4.05 MB)
019 Bad names - overspecific names (8.02 MB)
020 Bad names - Hungarian notation (4.96 MB)
021 Bad names - confusing names (3.65 MB)
022 Bad names - abbreviations (4.96 MB)
024 Reasonable abbreviations Conventional names (5.92 MB)
025 Context (6.46 MB)
027 Refactoring case study - naming (53.16 MB)
028 Good signatures of methods (5.33 MB)
029 Number of parameters (5.59 MB)
030 Fewer parameters - splitting the method (4.57 MB)
031 Fewer parameters - bundling related parameters (5.01 MB)
032 Fewer parameters - avoiding boolean parameters (5.08 MB)
034 Small methods (6.62 MB)
036 One method, one job (4.41 MB)
037 One method, one job - refactoring (6.38 MB)
038 Levels of abstraction (9.9 MB)
039 Composing different levels of abstraction (6.18 MB)
040 Levels of abstraction within methods (11.08 MB)
042 Refactoring case study - methods - introduction (12.14 MB)
043 Refactoring case study - methods - signature (10.09 MB)
044 Refactoring case study - methods - body (65.05 MB)
045 Comments (8.25 MB)
047 The worst comments (8.32 MB)
048 The reasonable comments (11.86 MB)
050 When to make methods static Private methods (5.75 MB)
051 The risk of making public methods static (21.52 MB)
052 When to make methods static Public methods (8.97 MB)
054 Composition over inheritance (18.35 MB)
055 The issues of inheritance (19.55 MB)
056 Replacing inheritance with composition (32.96 MB)
057 The benefits of composition (18.66 MB)
059 Assignment - Password Generator Refactoring - Description and requirements (16.4 MB)
060 Assignment - Password Generator Refactoring - Explaining the existing code (15.99 MB)
061 Assignment - Password Generator Refactoring - Fixing naming (22.58 MB)
062 Assignment - Password Generator Refactoring - Improving design (61 MB)
001 Section introduction (2.89 MB)
002 The computer's processor (8.11 MB)
003 Threads and processes (10.15 MB)
004 Concurrency vs parallelism (4.37 MB)
005 Asynchrony (11.45 MB)
007 A single-threaded program (29.19 MB)
008 Starting a new thread The Thread class (32.99 MB)
009 Multithreaded app's code flow (16.84 MB)
011 The benefits of multithreading and asynchronous programming (3.85 MB)
012 The cost of threads ThreadPool (36.7 MB)
014 Task Parallel Library (TPL) (5.54 MB)
015 Task class (25.99 MB)
016 Returning a value from a Task (12.92 MB)
017 Waiting for the Task result (20.85 MB)
018 Wait and WaitAll methods (27.27 MB)
020 Continuations The ContinueWith method (40.63 MB)
021 Chaining continuations Continuations of multiple tasks (26.71 MB)
023 Canceling a Task (42.83 MB)
024 Task lifecycle (15.83 MB)
025 OperationCanceledException (22.97 MB)
026 Exceptions thrown by other threads (34.87 MB)
027 Exceptions in tasks (46.31 MB)
028 Asynchronous exception handling (21.08 MB)
029 Handling AggregateException (19.48 MB)
031 Multiple continuations for one task (23.48 MB)
032 Handling task cancellation (13.51 MB)
033 The need for synchronization (11.48 MB)
034 Atomic operations (2.21 MB)
035 Race condition (6.17 MB)
036 Locks (13.15 MB)
038 The need for asyncawait (46.6 MB)
039 await keyword (34.9 MB)
040 Async methods (42.23 MB)
042 Asynchrony vs multithreading (24.03 MB)
043 The flow of an asynchronous program (24.87 MB)
044 Asyncawait and threads (14.73 MB)
045 Asyncawait summary (9.76 MB)
046 Asyncawait practice (31.56 MB)
048 Exceptions in async methods (38.17 MB)
049 Downsides of multithreading & asynchrony (8.91 MB)
050 Using async methods in practice HttpClient (65.63 MB)
051 Assignment - Quote Finder - Description and requirements (20.78 MB)
052 Assignment - Quote Finder - Fetching data (45.92 MB)
053 Assignment - Quote Finder - Smart asynchrony (29.2 MB)
054 Assignment - Quote Finder - Single-threaded processing (49.44 MB)
055 Assignment - Quote Finder - Multi-threaded processing (40.56 MB)
056 Assignment - Quote Finder - Refactoring (82.33 MB)