Course Content
09 – Advanced C# types
0/44
047 Querying an API using C#.mp4
06:11
033 Overriding the GetHashCode method.mp4
06:22
035 ValueTuples.mp4
07:24
036 Benefits of immutable types.mp4
13:07
038 Records.mp4
08:10
039 Record structs.mp4
02:30
041 Nullable value types.mp4
07:43
042 Nullable reference types.mp4
12:01
043 Null-forgiving operator.mp4
09:06
044 Using nullable reference types. Generic type constraints related to nullability.mp4
07:04
046 APIs.mp4
05:11
031 When to override the GetHashCode method.mp4
02:56
048 A class for querying APIs.mp4
07:36
049 Assignment – Star Wars Planets Stats – Description and requirements.mp4
05:15
051 Assignment – Star Wars Planets Stats – JsonPropertyNameAttribute and DTOs.mp4
09:47
052 Assignment – Star Wars Planets Stats – Exceptions handling.mp4
07:49
053 Assignment – Star Wars Planets Stats – Type design.mp4
08:07
054 Assignment – Star Wars Planets Stats – Converting DTO to a custom type.mp4
08:25
055 Assignment – Star Wars Planets Stats – Finishing the app and the MaxBy method.mp4
08:38
056 Assignment – Star Wars Planets Stats – Refactoring.mp4
08:43
057 Assignment – Star Wars Planets Stats – Splitting the class.mp4
09:33
058 Assignment – Star Wars Planets Stats – Universal table printer.mp4
13:56
016 Readonly structs.mp4
02:30
002 Reflection.mp4
09:02
003 Attributes.mp4
10:36
005 Limitations of attributes parameters types.mp4
02:44
007 Structs.mp4
05:31
008 Structs vs Classes – crucial differences.mp4
05:17
009 Structs vs Classes – low-level differences.mp4
06:17
010 Choosing between structs and classes.mp4
06:12
012 Why should we make structs immutable.mp4
03:57
014 Non-destructive mutation.mp4
02:27
015 with expression.mp4
03:33
001 Section introduction.mp4
01:09
018 A close look at the System.Object type. The ReferenceEquals method.mp4
06:19
019 Equals method.mp4
03:58
020 Overriding the Equals method in classes.mp4
05:10
021 Overriding the Equals method in structs.mp4
07:07
023 IEquatableT interface.mp4
07:12
024 == operator.mp4
03:30
026 Operators overloading.mp4
06:06
027 Overloading of implicit and explicit conversion operators.mp4
06:55
029 Hash functions.mp4
09:41
030 Default implementation of the GetHashCode method.mp4
04:53
17 – Multithreading & asynchrony
0/47
044 Asyncawait and threads.mp4
03:44
031 Multiple continuations for one task.mp4
03:44
032 Handling task cancellation.mp4
03:27
033 The need for synchronization.mp4
03:39
034 Atomic operations.mp4
01:24
035 Race condition.mp4
03:24
036 Locks.mp4
03:58
038 The need for asyncawait.mp4
06:51
039 await keyword.mp4
06:44
040 Async methods.mp4
07:48
042 Asynchrony vs multithreading.mp4
06:06
043 The flow of an asynchronous program.mp4
04:01
029 Handling AggregateException.mp4
07:01
045 Asyncawait summary.mp4
05:55
046 Asyncawait practice.mp4
07:53
048 Exceptions in async methods.mp4
05:23
049 Downsides of multithreading & asynchrony.mp4
04:47
050 Using async methods in practice. HttpClient.mp4
09:07
051 Assignment – Quote Finder – Description and requirements.mp4
04:49
052 Assignment – Quote Finder – Fetching data.mp4
05:45
053 Assignment – Quote Finder – Smart asynchrony.mp4
07:29
054 Assignment – Quote Finder – Single-threaded processing.mp4
07:35
055 Assignment – Quote Finder – Multi-threaded processing.mp4
05:59
056 Assignment – Quote Finder – Refactoring.mp4
09:29
016 Returning a value from a Task.mp4
04:23
002 The computer’s processor.mp4
03:57
003 Threads and processes.mp4
04:01
004 Concurrency vs parallelism.mp4
02:19
005 Asynchrony.mp4
04:55
007 A single-threaded program.mp4
05:46
008 Starting a new thread. The Thread class.mp4
04:52
009 Multithreaded app’s code flow.mp4
02:46
011 The benefits of multithreading and asynchronous programming.mp4
02:10
012 The cost of threads. ThreadPool.mp4
05:55
014 Task Parallel Library (TPL).mp4
02:30
015 Task class.mp4
03:56
001 Section introduction.mp4
01:34
017 Waiting for the Task result.mp4
05:10
018 Wait and WaitAll methods.mp4
04:41
020 Continuations. The ContinueWith method.mp4
06:00
021 Chaining continuations. Continuations of multiple tasks.mp4
04:42
023 Canceling a Task.mp4
06:47
024 Task lifecycle.mp4
04:25
025 OperationCanceledException.mp4
03:51
026 Exceptions thrown by other threads.mp4
05:37
027 Exceptions in tasks.mp4
06:23
028 Asynchronous exception handling.mp4
03:35
16 – Clean Code
0/48
048 The reasonable comments.mp4
06:02
034 Small methods.mp4
03:27
036 One method, one job.mp4
02:46
037 One method, one job – refactoring.mp4
03:29
038 Levels of abstraction.mp4
03:55
039 Composing different levels of abstraction.mp4
02:41
040 Levels of abstraction within methods.mp4
04:16
042 Refactoring case study – methods – introduction.mp4
04:02
043 Refactoring case study – methods – signature.mp4
02:44
044 Refactoring case study – methods – body.mp4
10:54
045 Comments.mp4
03:11
047 The worst comments.mp4
03:59
032 Fewer parameters – avoiding boolean parameters.mp4
02:37
050 When to make methods static Private methods.mp4
02:41
051 The risk of making public methods static.mp4
07:00
052 When to make methods static Public methods.mp4
04:24
054 Composition over inheritance.mp4
06:00
055 The issues of inheritance.mp4
07:27
056 Replacing inheritance with composition.mp4
04:41
057 The benefits of composition.mp4
05:21
059 Assignment – Password Generator Refactoring – Description and requirements.mp4
03:04
060 Assignment – Password Generator Refactoring – Explaining the existing code.mp4
04:36
061 Assignment – Password Generator Refactoring – Fixing naming.mp4
03:53
062 Assignment – Password Generator Refactoring – Improving design.mp4
10:04
018 Bad names – meaningless words.mp4
03:01
002 The importance of clean code.mp4
05:56
003 Bad decisions related to code quality.mp4
04:24
004 Tech debt.mp4
03:29
005 Being professional.mp4
02:31
006 What is clean code.mp4
04:41
008 The importance of meaningful names.mp4
03:03
009 Renaming. The Boy Scout Rule.mp4
04:06
010 Dealing with problematic naming.mp4
03:46
012 Expressive names.mp4
03:15
013 Long and short names.mp4
06:11
016 Principle of the least surprise.mp4
06:45
001 Section introduction.mp4
00:51
019 Bad names – overspecific names.mp4
03:55
020 Bad names – Hungarian notation.mp4
02:44
021 Bad names – confusing names.mp4
02:42
022 Bad names – abbreviations.mp4
03:58
024 Reasonable abbreviations. Conventional names.mp4
03:18
025 Context.mp4
04:08
027 Refactoring case study – naming.mp4
08:58
028 Good signatures of methods.mp4
03:01
029 Number of parameters.mp4
03:22
030 Fewer parameters – splitting the method.mp4
02:20
031 Fewer parameters – bundling related parameters.mp4
02:31
15 – Unit Testing
0/41
039 Common setup for tests.mp4
06:09
027 Assignment – Fibonacci generator tests – solution.mp4
09:15
028 Testing classes depending on other classes.mp4
04:41
029 A need for mocks.mp4
03:56
030 Mocks.mp4
04:52
031 Controlling the mock behavior.mp4
03:17
033 The benefits of using mocks.mp4
01:54
034 Advanced mock setup.mp4
05:46
035 Assertions checking if a method was called.mp4
04:12
036 Advanced assertions on method calls.mp4
03:06
038 Clean code in unit tests.mp4
02:05
026 Assignment – Fibonacci generator tests – Description and requirements.mp4
02:19
040 Tests, Dependency Inversion and Dependency Injection.mp4
05:04
041 Untestable code – no Dependency Inversion.mp4
03:27
042 Untestable code – static methods.mp4
09:58
044 Other kinds of software tests.mp4
07:10
046 Assignment – Unit tests for GuessingGame – Description and requirements.mp4
01:48
047 Assignment – Unit tests for GuessingGame – Basic scenarios.mp4
09:10
048 Assignment – Unit tests for GuessingGame – Verifying messages.mp4
07:20
049 Assignment – Unit tests for GuessingGame – Approaches for messages validation.mp4
06:56
050 Assignment – Unit tests for GuessingGame – Resource files.mp4
09:50
013 TestCaseSource.mp4
06:02
002 Manual tests vs Automated tests.mp4
03:09
003 Setting up the testing environment.mp4
06:00
004 First unit tests.mp4
04:22
006 Running the tests.mp4
05:14
007 Naming unit tests.mp4
03:20
008 Test messages.mp4
05:58
009 AAA pattern.mp4
02:29
011 TestCase.mp4
05:38
012 Naming parameterized tests.mp4
01:33
001 Section introduction.mp4
01:39
015 Assertions on exceptions. Multiple assertions in single test.mp4
06:01
016 Value of unit tests.mp4
04:28
017 Basic assertions.mp4
04:28
019 Testing private methods.mp4
04:50
020 Testing internal methods.mp4
02:47
021 Benefits of unit tests – no fear of refactoring.mp4
03:46
022 Benefits of unit tests – better design.mp4
04:41
023 Benefits of unit tests – early bug detection.mp4
03:16
024 Downsides of unit tests.mp4
06:41
14 – Events
0/19
013 Windows Forms – introduction.mp4
02:50
023 Assignment – Numeric Types Suggester – Choosing numeric type.mp4
11:56
022 Assignment – Numeric Types Suggester – Numbers validation and BigInteger type.mp4
04:23
021 Assignment – Numeric Types Suggester – Handling KeyPress event.mp4
05:23
020 Assignment – Numeric Types Suggester – User Interface & basic events.mp4
06:17
018 Assignment – Numeric Types Suggester – Description and requirements.mp4
04:33
017 Windows Forms – basic UI elements.mp4
07:00
016 Events in Windows Forms.mp4
06:44
015 Understanding Windows Forms files.mp4
04:09
014 The first Windows Forms app.mp4
05:24
001 Section introduction.mp4
00:41
011 Memory leaks caused by events.mp4
05:25
010 Event vs delegate members.mp4
02:33
008 EventHandler delegate & EventArgs type.mp4
04:45
006 Raising events.mp4
04:59
005 Defining an event and subscribing to it.mp4
05:53
004 Observer design pattern.mp4
08:37
003 A need for the Observer design pattern.mp4
02:01
002 A need for communication between objects.mp4
05:26
13 – Numeric types
0/15
001 Section introduction.mp4
00:55
002 Decimal number system.mp4
03:19
003 Binary number system.mp4
01:15
004 Maximal numbers on a given number of digits.mp4
03:55
006 Numbers in memory. Integer.mp4
03:11
007 Adding binary numbers.mp4
03:03
008 Numeric overflow & silent failures.mp4
05:00
010 checked keyword.mp4
01:57
011 Checked context – when to use it.mp4
03:32
012 Scope of the checked context. unechecked keyword.mp4
03:22
014 Integral numeric types overview.mp4
04:17
015 Floating-point numbers.mp4
02:12
016 double and float.mp4
03:26
017 Smart usage of binary floating point numbers.mp4
05:51
019 Decimal.mp4
04:25
12 – Strings
0/22
015 Advanced string formatting.mp4
07:23
027 Assignment – Tickets Data Aggregator – Compliance with the SRP.mp4
08:58
026 Assignment – Tickets Data Aggregator – Refactoring.mp4
06:22
025 Assignment – Tickets Data Aggregator – Saving result in a text file.mp4
05:45
024 Assignment – Tickets Data Aggregator – Parsing culture-specific strings.mp4
05:23
023 Assignment – Tickets Data Aggregator – Splitting a string by multiple separators.mp4
05:12
022 Assignment – Tickets Data Aggregator – List all PDFs from a folder.mp4
01:52
021 Assignment – Tickets Data Aggregator – Reading text from PDF.mp4
05:19
019 Assignment – Tickets Data Aggregator – Description and requirements.mp4
05:16
017 Specific culture vs Invariant culture.mp4
04:42
016 Culture-specific string formatting.mp4
04:24
001 Section introduction.mp4
00:50
014 Flyweight design pattern.mp4
03:24
013 String interning.mp4
06:51
011 StringBuilder.mp4
04:16
010 A need for StringBuilder.mp4
03:15
008 Strings as members in structs.mp4
04:03
007 Strings – value or reference types.mp4
04:05
006 Immutability of strings.mp4
02:24
004 Managing various encodings.mp4
04:45
003 Char representation in memory. Character encoding.mp4
05:05
002 Char.mp4
02:43
11 – Projects, assemblies, solutions
0/16
001 Section introduction.mp4
00:26
002 Projects and solutions.mp4
06:06
003 Project properties.mp4
05:03
004 Debug build vs Release build.mp4
02:02
006 Assemblies.mp4
02:17
007 Referencing types from another assembly.mp4
05:22
008 Referencing types from another project.mp4
03:24
009 Internal access modifier. Principles of using access modifiers.mp4
06:11
010 Protected internal access modifier.mp4
02:27
011 Private protected access modifier.mp4
02:58
012 Access modifiers – summary.mp4
04:34
014 How to structure the code in a solution.mp4
05:13
015 NuGet.mp4
08:15
016 .csproj files.mp4
05:32
017 .sln files.mp4
02:02
018 Updating the .NET version.mp4
03:54
10 – Collections
0/40
039 Implementing IEnumerable interface using iterators.mp4
03:52
026 Performance of Dictionaries.mp4
04:44
028 HashSet.mp4
07:47
030 Queue.mp4
06:12
031 Stack.mp4
04:08
032 params keyword.mp4
04:59
034 A need for yield statement.mp4
04:05
035 yield statement – behavior analysis.mp4
05:21
036 yield statement and iterators.mp4
09:55
037 yield statement – practice. yield break statement.mp4
07:43
025 Dictionaries under the hood.mp4
10:09
040 Assignment – Custom Linked List – Description and requirements.mp4
02:46
042 Assignment – Custom Linked List – Data structures.mp4
06:30
043 Assignment – Custom Linked List – The AddToFront method.mp4
02:29
044 Assignment – Custom Linked List – Implementing IEnumerable.mp4
04:02
045 Assignment – Custom Linked List – Adding new items at the end of the list.mp4
02:34
046 Assignment – Custom Linked List – The Clear method.mp4
07:16
047 Assignment – Custom Linked List – Removing items and the Contains method.mp4
06:33
048 Assignment – Custom Linked List – The CopyTo method.mp4
03:07
049 Assignment – Custom Linked List – Summary and performance. Private classes.mp4
09:40
013 Interface Segregation Principle.mp4
04:57
002 The role of the IEnumerable interface.mp4
04:23
003 A close look at the IEnumerable interface.mp4
04:49
004 Implementing IEnumerable.mp4
06:16
005 Implicit and explicit interface implementation.mp4
06:20
006 Implementing IEnumerableT.mp4
06:48
008 Indexers.mp4
05:17
010 Collection initializers.mp4
05:08
011 ICollection and IList interfaces.mp4
04:41
012 Breaking the Interface Segregation Principle.mp4
03:22
001 Section introduction.mp4
00:41
014 The benefits of readonly collections.mp4
03:51
015 Readonly collections. ReadOnlyCollection and ReadOnlyDictionary.mp4
05:46
017 Big O Notation.mp4
07:43
018 Binary search algorithm.mp4
06:52
019 Binary search algorithm – implementation.mp4
06:07
020 Binary search algorithm – complexity.mp4
04:39
022 Improving performance when using Lists.mp4
09:46
023 Linked list.mp4
01:48
024 Linked list vs List.mp4
07:59
01 – Introduction
0/8
001 Welcome! Basic information & how to get help.mp4
01:33
002 46 seconds about your instructor.mp4
00:46
003 72 seconds about what this course is.mp4
01:12
004 105 seconds about what this course isn’t.mp4
01:45
005 97 seconds about practicing what you learn.mp4
01:37
006 112 seconds about time optimization.mp4
01:52
007 Installing Visual Studio Community.mp4
02:38
008 Accessing the code.mp4
02:43
08 – .NET under the hood
0/30
020 Garbage Collector – the Mark-and-Sweep algorithm.mp4
07:09
038 Assignment – CSV Processing Improvements – Analysis.mp4
05:33
037 Assignment – CSV Processing Improvements – Reducing the number of boxings.mp4
12:16
036 Assignment – CSV Processing Improvements – Reducing the size of Dictionaries.mp4
05:17
035 Assignment – CSV Processing Improvements – Code analysis & tips.mp4
06:11
033 Assignment – CSV Processing Improvements – Description and requirements.mp4
09:39
032 Reading CSV files.mp4
08:37
031 CSV files.mp4
02:41
029 Dispose method – implementation.mp4
06:52
028 Dispose method – reading from a file using StreamReader.mp4
06:44
027 Dispose method – writing to a file using StreamWriter.mp4
05:28
026 Dispose method – introduction.mp4
02:19
024 Finalizers.mp4
06:33
023 Memory leaks.mp4
04:57
022 Garbage Collector – generations of objects.mp4
05:53
001 Section introduction.mp4
01:18
019 Garbage Collector – memory fragmentation and defragmentation.mp4
02:57
018 Garbage Collector – introduction.mp4
05:23
016 Boxing and unboxing – performance cost.mp4
05:58
015 Boxing and unboxing.mp4
05:49
014 Unified type system. A need for boxing and unboxing.mp4
07:15
013 Using ref with reference types.mp4
04:33
011 ref keyword.mp4
07:21
010 Value types vs reference types – practical tips.mp4
08:18
008 Value types vs reference types.mp4
08:36
007 Value semantics vs reference semantics.mp4
05:51
006 Memory of a program. The stack and the heap.mp4
03:47
004 Common Language Runtime (CLR).mp4
05:52
003 Common Intermediate Language (CIL).mp4
03:46
002 .NET and C#.mp4
07:26
07 – LINQ
0/20
014 First and Last.mp4
04:39
027 Assignment – Refactoring to LINQ – Checking if collection has duplicates.mp4
08:43
026 Assignment – Refactoring to LINQ – Fewer loops & multiline strings formatting.mp4
07:27
025 Assignment – Refactoring to LINQ – Find and Replace window.mp4
10:19
024 Assignment – Refactoring to LINQ – Nested loop and code readability.mp4
07:52
022 Assignment – Refactoring to LINQ – Description and requirements.mp4
04:23
020 Average. Anonymous types.mp4
07:33
019 Select.mp4
06:17
017 Distinct.mp4
00:57
016 Where.mp4
05:59
001 Section introduction.mp4
00:57
013 OrderBy.mp4
05:06
011 Contains.mp4
01:46
010 Count.mp4
02:47
008 All.mp4
02:26
007 Any.mp4
04:29
005 Deferred execution.mp4
07:14
004 LINQ, IEnumerableT and method chaining.mp4
05:33
003 LINQ and extension methods.mp4
03:20
002 What is LINQ.mp4
08:11
06 – Generic types & advanced use of methods
0/34
037 Refactoring the code using Funcs and lambda expressions.mp4
02:58
024 Type constraints – summary. Multiple type constraints.mp4
03:02
026 Advanced use of methods – introduction.mp4
01:34
027 Funcs and Actions.mp4
05:37
029 Lambda expressions.mp4
04:34
031 Delegates.mp4
05:19
033 Dictionary – introduction.mp4
09:43
034 Dictionary – practice.mp4
09:58
036 A need for the Strategy design pattern.mp4
08:24
023 Type constraints – numeric types. Generic math.mp4
03:35
038 Open-Closed Principle. Strategy design pattern.mp4
11:33
039 Generic filtering of collections.mp4
06:25
041 Caching.mp4
05:55
042 Assignment – Custom Cache – Description and requirements.mp4
03:56
044 Assignment – Custom Cache – Implementation.mp4
13:07
045 Assignment – Custom Cache – The Decorator design pattern.mp4
08:04
046 Assignment – Custom Cache – Composing many Decorators together.mp4
03:24
012 Generic methods.mp4
05:35
002 Introduction to generic types.mp4
03:37
003 Understanding how List works under the hood.mp4
05:19
004 Simplified List (adding a new item).mp4
06:24
005 Simplified List (deleting an item at given index).mp4
07:24
006 A need for generic types. Implementing a generic type.mp4
08:52
008 A need for tuples.mp4
08:28
009 Tuples.mp4
06:00
011 C# without generics. ArrayList.mp4
09:51
001 Section introduction.mp4
01:01
013 Generic methods with multiple type parameters.mp4
05:17
015 Convert.ChangeType method. typeof keyword and the Type object.mp4
08:08
017 A need for type constraints.mp4
08:17
018 Improving the performance of the List. Measuring the time of the code execution.mp4
06:51
019 Type constraints – the constraint on the base type.mp4
07:28
020 IComparable interface. Ordering objects.mp4
08:01
021 Type constraints – the constraint on the implemented interface.mp4
05:13
05 – Exceptions and error handling
0/28
020 Custom exceptions.mp4
05:00
036 Assignment – Game Data Parser – Refactoring – SRP, DI and classes decoupling.mp4
15:22
035 Assignment – Game Data Parser – Refactoring – Extracting methods.mp4
04:22
034 Assignment – Game Data Parser – Reducing usage of exception.mp4
04:12
033 Assignment – Game Data Parser – Custom logger.mp4
07:16
032 Assignment – Game Data Parser – Adding details to JsonException.mp4
06:33
031 Assignment – Game Data Parser – Flow controlled by exceptions.mp4
06:48
030 Assignment – Game Data Parser – Sunny day scenario.mp4
09:17
028 Assignment – Game Data Parser – Description and requirements.mp4
03:03
026 Smart usage of exceptions – catch.mp4
08:30
025 Smart usage of exceptions – throw.mp4
06:46
024 Two extreme schools of using exceptions.mp4
06:46
023 Exceptions as a hidden part of a method signature.mp4
04:58
021 When to define custom exceptions.mp4
06:36
001 Section introduction.mp4
00:48
018 Exception filters.mp4
03:48
017 Code inside the catch block.mp4
03:25
016 Global try-catch block.mp4
03:56
015 Rethrowing a System.Exception object.mp4
03:28
013 Rethrowing exceptions. throw vs throw ex.mp4
07:20
012 Precise exceptions.mp4
06:46
011 StackOverflowException. Recursive methods.mp4
02:26
009 Built-in exception types.mp4
05:00
008 Throwing exceptions explicitly.mp4
09:08
006 Multiple catch blocks.mp4
05:19
004 Handling exceptions. Try-catch-finally.mp4
11:17
003 Stack trace.mp4
04:46
002 Exception object.mp4
04:21
04 – Object-Oriented Programming Polymorphism, Inheritance, Interfaces
0/37
041 Assignment – Cookies Cookbook – Dependency Inversion and Dependency Injection.mp4
10:01
027 Sealed classes and methods.mp4
03:48
028 Static classes are always sealed.mp4
03:09
030 Extension methods.mp4
08:46
032 A need for interfaces.mp4
03:39
033 Interfaces.mp4
10:07
035 Interfaces vs abstract classes.mp4
04:42
037 JSON.mp4
04:56
038 Assignment – Cookies Cookbook – Description and requirements.mp4
05:53
040 Assignment – Cookies Cookbook – High-level design.mp4
09:35
026 A need for abstract methods.mp4
03:30
042 Assignment – Cookies Cookbook – Designing data types.mp4
08:48
043 Assignment – Cookies Cookbook – Printing data object. LINQ.mp4
08:25
044 Assignment – Cookies Cookbook – Printing the ingredients.mp4
03:28
045 Assignment – Cookies Cookbook – Composing the recipe by the user.mp4
05:10
046 Assignment – Cookies Cookbook – Reading and writing from and to a .txt file.mp4
11:22
047 Assignment – Cookies Cookbook – Reading and writing from and to a .json file.mp4
08:23
048 Assignment – Cookies Cookbook – Template Method Design Pattern.mp4
05:34
049 Assignment – Cookies Cookbook – Cleanup and project organizing.mp4
05:42
014 Inheriting constructors and the base keyword.mp4
07:50
002 A need for polymorphism.mp4
05:33
003 Inheritance.mp4
04:32
004 Inheriting members from the base class. Protected access modifier.mp4
05:29
006 Overriding members from the base class. Virtual methods and properties.mp4
11:16
007 Virtual methods – practice.mp4
07:48
010 A deeper inheritance hierarchy.mp4
02:08
011 Multiple inheritance.mp4
02:58
012 System.Object and the ToString method.mp4
07:41
001 Section introduction.mp4
00:57
015 Implicit conversion.mp4
03:36
016 Explicit conversion.mp4
05:36
018 Upcasting and downcasting.mp4
02:24
019 is operator.mp4
03:55
020 Null.mp4
04:46
022 as operator.mp4
02:36
023 Abstract classes.mp4
01:32
024 Abstract methods.mp4
06:18
03 – Basics of Object-Oriented Programming
0/36
040 Single Responsibility Principle – Refactoring (part 3).mp4
04:49
027 Properties.mp4
09:15
029 Object initializers.mp4
05:10
030 Computed properties.mp4
02:54
032 Static methods and classes.mp4
08:20
034 Static fields, properties and constructors.mp4
04:37
037 Single Responsibility Principle – Introduction.mp4
09:43
038 Single Responsibility Principle – Refactoring (part 1).mp4
10:02
039 Single Responsibility Principle – Refactoring (part 2).mp4
05:52
026 Limitations of fields. A need for properties.mp4
03:39
042 Files, namespaces and the using directive.mp4
10:24
043 Global using directives.mp4
06:45
044 Assignment – Dice Roll Game – Description and requirements.mp4
02:23
046 Assignment – Dice Roll Game – Random.mp4
05:33
047 Assignment – Dice Roll Game – Magic Number Antipattern.mp4
04:02
048 Assignment – Dice Roll Game – Designing classes.mp4
09:50
049 Assignment – Dice Roll Game – Enums.mp4
05:07
050 Assignment – Dice Roll Game – Ternary conditional operator.mp4
06:22
012 Adding methods to classes.mp4
03:32
002 The issues in our code. A need for Object-Oriented Programming.mp4
05:50
003 Introduction to object-oriented programming.mp4
05:19
004 Understanding OOP with the DateTime type.mp4
06:03
006 Abstraction.mp4
03:35
007 Our first class.mp4
03:50
008 Data hiding.mp4
04:04
009 Custom constructor.mp4
05:59
011 C# restrictions on code outside classes. Top-level statements.mp4
06:18
001 Section introduction.mp4
01:16
014 Encapsulation.mp4
04:36
016 Methods overloading.mp4
05:44
017 Constructors overloading. Calling one constructor from another.mp4
02:26
019 Expression-bodied methods.mp4
02:18
020 this keyword (current instance reference).mp4
03:39
021 Optional parameters.mp4
06:14
023 Validation of constructor parameters.mp4
05:23
024 Readonly and const.mp4
05:19
02 – C# Fundamentals
0/49
053 Nested loops.mp4
01:48
035 Assignment – Simple Calculator – Solution.mp4
12:08
036 String interpolation.mp4
03:04
038 Switch statement.mp4
07:53
040 Char.mp4
01:40
041 A need for loops.mp4
01:55
042 While loop – part 1.mp4
03:14
043 += and ++ operators. Infinite loops.mp4
03:48
044 While loop – part 2.mp4
02:53
046 Do…while loop.mp4
04:29
048 For loop.mp4
06:04
050 Break.mp4
03:29
051 Continue.mp4
05:39
033 Assignment – Simple Calculator – Description and requirements.mp4
02:27
054 Loops performance.mp4
03:32
055 Arrays.mp4
10:48
059 Multi-dimensional arrays.mp4
06:57
061 Foreach loop.mp4
01:45
063 Lists.mp4
10:50
065 out keyword.mp4
09:05
066 TryParse method.mp4
04:10
067 Assignment – TODO List – Description and requirements.mp4
02:28
069 Assignment – TODO List – Implementation – User options & adding a TODO.mp4
06:51
070 Assignment – TODO List – Implementation – Listing and Removing TODOs.mp4
08:30
071 Assignment – TODO List – Refactoring.mp4
12:02
015 Comments.mp4
03:54
002 Our first C# program.mp4
06:05
003 From a text file to an executable program.mp4
03:44
004 Programmer’s most important skill.mp4
06:03
005 The goal for this section.mp4
01:23
006 Variables.mp4
08:24
007 Naming variables & introduction to clean code.mp4
06:49
009 Operators.mp4
05:14
010 Implicitly typed variables.mp4
01:57
011 User input.mp4
02:13
012 Debugging with breakpoints.mp4
04:38
013 Coding exercises introduction.mp4
07:28
001 Section introduction.mp4
00:58
016 Boolean type. Logical negation, equality, comparison, and modulo operators.mp4
06:17
018 AND and OR logical operators.mp4
05:27
020 ifelse conditional statement.mp4
05:54
022 The scope of local variables.mp4
04:47
024 Methods – part 1 – void methods.mp4
07:41
025 Methods – part 2 – non-void methods.mp4
09:33
027 Methods – part 3 – parameters types and the return type. Static typing in C#.mp4
04:10
029 Parsing a string to an int (int.Parse method).mp4
02:52
030 The first exception.mp4
02:11
031 Adding a new project to a solution.mp4
02:48
032 Assignments – Introduction.mp4
01:51
[Last updated 4/2024] Ultimate C# Masterclass for 2024 (Udemy – Vietsub and Engsub)
Previous
Next
0% Complete