50 Things You've Been Doing Wrong in C# and .NET Core

Video description

Avoid common C# mistakes to improve your apps' productivity

About This Video

  • Grasp how language constructs, structs, equality, polymorphism, and C# primitives work
  • Master tools such as perfview, windbg, and Visual Studio's debugging capabilities
  • Effectively design reusable apps that obey SOLID principles, properly secure them, and scale them via microservices

In Detail

Professional software development involves many different skills. As a C# developer, you must be skilled in the C# language and the .NET Core runtime. With this course, you'll take your C# and .NET Core skills to the next level by avoiding common mistakes when coding, using design patterns, developing microservices, persisting your data, securing your application, and even debugging problems.

Learning the basics of a language or platform can easily be done by following a course/book and with some hands-on practice. The path to becoming a software developer encounters many edge cases. During this course, you'll learn from my hard-earned experience, garnered from real-life situations, regarding the C# language and .NET platform. You can take this course as a vaccination against future coding infections!

By the time you finish this course, you will have developed your skills to "sniff out" coding issues effectively and avoid mistakes. Whatever your issues, the aim of this course is to take you to the 'Bring it on!' point when it comes to solving your .NET and C# problems.

Please note that this course assumes familiarity with C#, .NET Core, and ASP.NET Core, together with Visual Studio (2017 or 2019).

Publisher resources

Download Example Code

Table of contents

  1. Chapter 1 : Resolving General C# Coding Errors
    1. The Course Overview 00:02:16
    2. Misunderstanding Pass by Reference 00:02:39
    3. Misunderstanding Dispose and Garbage Collector Relation 00:04:46
    4. Incorrectly Implementing Equals and GetHashCode 00:04:30
    5. Handling Exceptions Correctly 00:03:07
    6. Misunderstanding Virtual and Override 00:04:56
    7. Ignoring Compiler Warnings 00:00:59
  2. Chapter 2 : Misusing C# Primitives
    1. Misusing DateTime 00:05:27
    2. String and Localization Mistakes 00:07:22
    3. Issues with int and long 00:03:11
    4. Issues with float, double, and decimal. 00:02:34
    5. Misusing Structs and Boxing Mistakes 00:05:22
  3. Chapter 3 : Design Patterns and SOLID
    1. Misunderstanding and Violating SOLID Principles 00:05:34
    2. Changing Your Core Logic 00:03:06
    3. Not Using Design Patterns When You Should 00:03:04
    4. Incorrectly Implementing Singleton 00:03:24
  4. Chapter 4 : Data Structures and Algorithms
    1. Using List and Array Everywhere 00:07:35
    2. Using OrderBy Instead of Sort 00:01:36
    3. Using Where Instead of Find 00:01:24
    4. Not Understanding How LINQ Works 00:04:18
  5. Chapter 5 : Parallelism and Asynchronicity
    1. Overusing Threads Instead of Tasks 00:02:40
    2. Not Understanding Thread Safety 00:01:47
    3. Not Being Aware of Fences and Memory Barriers 00:03:23
    4. Not Using Task in Interface Signatures with Potential I/O 00:01:47
    5. Using Result or Wait Inappropriately 00:03:16
  6. Chapter 6 : Dependency Injection
    1. Choosing the Wrong Lifetime 00:03:15
    2. Using the Service Locator Pattern 00:02:11
    3. Injecting Too Many Parameters 00:01:46
    4. Using Dependency Injection Only for Testing 00:02:57
  7. Chapter 7 : Entity Framework
    1. Making Everything Public 00:01:27
    2. Not Using Transactions 00:02:13
    3. Losing Aggregate Boundaries 00:02:35
    4. Ignoring Concurrency 00:05:09
    5. Using Auto-Incremented Primary Keys 00:01:18
  8. Chapter 8 : Building RESTful APIs
    1. Misunderstanding What Resources Are 00:03:15
    2. Using Only POST and GET 00:03:43
    3. Underestimating Caching and Redirection 00:04:14
    4. Using HttpClient Wrongly 00:02:48
  9. Chapter 9 : What to Avoid When Building Microservices
    1. Sharing a Database Between Microservices 00:02:32
    2. Having Chatty Traffic 00:01:47
    3. Ignoring Latency Concerns 00:01:08
    4. Having Cyclic Dependencies 00:01:41
  10. Chapter 10 : Security Flaws
    1. Not Properly Hashing Passwords 00:03:34
    2. Misusing Cookies 00:03:57
    3. Not Properly Hiding Your Secrets 00:03:01
    4. Relying on Client Validation 00:03:12
    5. SQL Injections 00:02:00
  11. Chapter 11 : Not Knowing About Debugging Tools
    1. Not Being Aware of Visual Studio's Debugging Abilities 00:05:47
    2. Not Using Fiddler to Diagnose HTTP Traffic 00:03:25
    3. Not Using PerfView for Production Issues 00:05:29
    4. Not Using Memory Dumps for Production Issues 00:04:48

Product information

  • Title: 50 Things You've Been Doing Wrong in C# and .NET Core
  • Author(s): Onur Gumus
  • Release date: February 2020
  • Publisher(s): Packt Publishing
  • ISBN: 9781789804683