001 Welcome! Basic information & how to get help.mp4

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

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

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

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

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

001 Section introduction.mp4

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

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

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

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)

0% Complete