High Performance Coding with .NET Core and C#

High Performance Coding with .NET Core and C#, available at $69.99, has an average rating of 4.37, with 38 lectures, based on 1636 reviews, and has 11468 subscribers.

You will learn about Get an overview about the current stage of the .NET platform with focus on .NET Core, ASP .NET Core, and C# 7 with their performance aspects Get to know tools which are essential to measure the performance of a .NET Core application: Visual Studio Performance Tools, PerfView, BenchmarkDotNet, Perf and LTTng on Linux, Prefix, MiniProfiler Performance characteristics of value types and reference types, the effect of async/await on performance, and performance of collections in the base library Behind the scenes knowledge about C# 7: you will see what the compiler generates from C# 7 code and what performance implications this has on your application New performance related APIs like Span<T>, ArrayPool<T> Data access performance with Entity Framework Core Ahead of time compilation for .NET Core with CrossGen, and removing dead code with the .NET IL Linker Production monitoring for .NET Core and ASP .NET Core with Application Insights and Dynatrace This course is ideal for individuals who are If you are a .NET Core developer and you want to make sure your application does not break under production load then this course is for you! or Furthermore, if you are interested in performance and you like looking behind the scenes and understanding what really happens in your application then you will also find this course interesting. It is particularly useful for If you are a .NET Core developer and you want to make sure your application does not break under production load then this course is for you! or Furthermore, if you are interested in performance and you like looking behind the scenes and understanding what really happens in your application then you will also find this course interesting.

Enroll now: High Performance Coding with .NET Core and C#

Summary

Title: High Performance Coding with .NET Core and C#

Price: $69.99

Average Rating: 4.37

Number of Lectures: 38

Number of Published Lectures: 38

Number of Curriculum Items: 38

Number of Published Curriculum Objects: 38

Original Price: $99.99

Quality Status: approved

Status: Live

What You Will Learn

Get an overview about the current stage of the .NET platform with focus on .NET Core, ASP .NET Core, and C# 7 with their performance aspects
Get to know tools which are essential to measure the performance of a .NET Core application: Visual Studio Performance Tools, PerfView, BenchmarkDotNet, Perf and LTTng on Linux, Prefix, MiniProfiler
Performance characteristics of value types and reference types, the effect of async/await on performance, and performance of collections in the base library
Behind the scenes knowledge about C# 7: you will see what the compiler generates from C# 7 code and what performance implications this has on your application
New performance related APIs like Span<T>, ArrayPool<T>
Data access performance with Entity Framework Core
Ahead of time compilation for .NET Core with CrossGen, and removing dead code with the .NET IL Linker
Production monitoring for .NET Core and ASP .NET Core with Application Insights and Dynatrace

Who Should Attend

If you are a .NET Core developer and you want to make sure your application does not break under production load then this course is for you!
Furthermore, if you are interested in performance and you like looking behind the scenes and understanding what really happens in your application then you will also find this course interesting.

Target Audiences

If you are a .NET Core developer and you want to make sure your application does not break under production load then this course is for you!
Furthermore, if you are interested in performance and you like looking behind the scenes and understanding what really happens in your application then you will also find this course interesting.

A few years ago, Microsoft decided to radically redefine the .NET platform. An open-source, cross-platform, high performance flavor of the .NET framework was created: this is .NET Core. Additionally, C#, the most widely used .NET programming language also evolved over the years. These new developments include many performance improvements.

The goal of the course is to give you deep understanding about these performance improvements. By applying the knowledge from this course, you will be able to measure and optimize the performance of .NET Core (including ASP.NET Core), C# applications.

After a short wrap-up on .NET Core the course introduces you to the first pillar of the performance topic: measuring performance. You will learn to use tools that you can apply to measure the performance of your code running on .NET Core. Then we will focus on some important performance tricks like reducing the pressure on the GC by using value types or choosing the right collection for the given problem. After that we will see what the compiler does behind the scenes when it compiles your C# 7 code and what performance implications this has. We will talk about some new performance related APIs like ArrayPool and Span and we will also look into the performance aspects of Entity Framework Core. We will talk about the ahead of time compilation story for .NET with CrossGen and IL trimming with the .NET IL Linker. We will finish the course by learning about production performance monitoring for .NET Core.�

Goal of the course�

Understanding why .NET Core and ASP.NET Core are great platforms to create high performance applications �
Learning about tools that can measure the performance of your .NET Core code: Visual Studio Performance Tools, BenchmarkDotNet, MiniProfiler, Stackify Prefix, LTTng and Perf on Linux, ETW and PerfView
Understand the latest language features of C# and how they affect performance
Advanced tools to improve the performance of your .NET Core and ASP.NET Core applications: Span<T>, ArrayPool<T>, ASP.NET Core Precompiled Views, Entity Framework Core performance, .NET IL Linker, AOT compilation with CrossGen.�
Performance monitoring in production for .NET Core and ASP.NET Core: Application Insights and Dynatrace

Course style

The course is a mix of theory and practice. Tools and concepts with their theoretical background will be introduced with slides and then the theoretical knowledge will be applied in demos.�

�

Course Curriculum

Chapter 1: Setting the Stage

Lecture 1: Course Overview

Lecture 2: Note for .NET Core experts

Lecture 3: .NET Core History – Performance

Lecture 4: .NET Core Concepts and Definitions

Chapter 2: Measure Performance During Development Part 1

Lecture 1: Measuring CPU

Lecture 2: Measuring Memory

Lecture 3: Visual Studio Performance Tools – PerfTips and Profiler

Lecture 4: Visual Studio Performance Tools – The Diagnostic Tools Window

Chapter 3: Measure Performance During Development Part 2

Lecture 1: Event Tracing: ETW and PerfView

Lecture 2: Micro Benchmarking with BenchmarkDotNet

Lecture 3: .NET Core Performance Diagnostic on Linux

Lecture 4: Performance Monitoring on the Developer Machine with Stackify Prefix

Lecture 5: Performance Monitoring on the Developer Machine with MiniProfiler

Chapter 4: Make your Code Faster – General Tips for .NET Developers

Lecture 1: Value Types vs. Reference Types and Reducing Pressure on the GC

Lecture 2: Value Types vs. Reference Types and Reducing Pressure on the GC – Demo

Lecture 3: Saving Threads with async/await

Lecture 4: Saving Threads with async/await – Demo

Lecture 5: Choosing the Right Collection

Lecture 6: Choosing the Right Collection – Demo

Chapter 5: C# 7 Performance

Lecture 1: Performance Impact of C# 7 Features

Lecture 2: Avoid Heap Allocations with Local Functions

Lecture 3: Make ValueTypes Faster with ref return

Lecture 4: The Performance Characteristics of the C# 7 Tuple Feature

Lecture 5: Optimization of async-methods with ValueTask

Lecture 6: Pattern matching and Performance

Chapter 6: New Performance Related APIs

Lecture 1: Reusing Arrays with ArrayPool<T>

Lecture 2: Accessing all Types of Memory Safely and Efficiently with Span<T>

Lecture 3: Accessing all Types of memory Safely and Efficiently with Span<T> – Demo

Chapter 7: Data Access Performance: Entity Framework Core

Lecture 1: Make faster Queries with Entity Framework Core

Lecture 2: Loading Dependent Entities Efficiently

Lecture 3: EF Core Performance: Maximum Length, Client Side Execution, Change Tracking

Chapter 8: .NET Core Specific Performance Tools and Configurations

Lecture 1: Pre-JIT .NET Core Applications with CrossGen

Lecture 2: Make your .NET Core Application Smaller with Mono’s Linker

Lecture 3: Faster Startup with ASP.NET Core Precompiled Views

Chapter 9: Performance Monitoring in Production for .NET Core

Lecture 1: Enabling Application Insights for ASP.NET Core Applications

Lecture 2: Tracking Slow Requests and Performance Testing with Application Insights

Lecture 3: Tracking Custom Dependencies with Application Insights

Lecture 4: Monitoring .NET Core Applications with Dynatrace

Instructors

Gergely Kalapos
Software Engineer

Rating Distribution

1 stars: 13 votes
2 stars: 37 votes
3 stars: 206 votes
4 stars: 697 votes
5 stars: 683 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu