Every single feature added in C# 11
Until the 28th of Nov 2022 use discount code BF2022 for up to 25% off
at: dometrain.com
Become a Patreon and get source code access: / nickchapsas
Hello everybody I'm Nick and in this video I will introduce you to every single feature added in C# 11.
Timestamps
Raw string literals - 0:00
List patterns - 5:04
Generics on attributes - 7:41
Extended nameof scope - 9:11
UTF-8 string literals - 10:08
String interpolated new line - 12:29
Generic maths/abstracting over static members - 13:23
Required members - 16:14
File scoped types - 17:45
Pattern matching on Spans for constant strings - 19:47
Auto-default structs - 20:57
Improved method group conversion to delegate - 21:51
Numeric IntPtr - 22:52
ref fields and ref scoped variables - 23:34
Don't forget to comment, like and subscribe :)
Social Media:
Follow me on GitHub: bit.ly/ChapsasGitHub
Follow me on Twitter: bit.ly/ChapsasTwitter
Connect on LinkedIn: bit.ly/ChapsasLinkedIn
Keep coding merch: keepcoding.shop
#csharp #dotnet
My god, I can't even imagine how people even _compare_ java to this language. C# is on an entirely different level. There are things in C#11 where the developers of java don't even know what they are. My boss absolutely loves Java and it's so frustrating. We don't have access to generics (T.class, instanceof, new, etc), no operator overloading, no extension methods, no namespaces, no value types, everything has to be boxed, all function calls are virtual, it doesn't compile to actual machine code, there are no properties, no pattern matching, no nameof, no spans, no linq query syntax, no async/await, no generator functions, no partial classes, records were an afterthought that don't really help anything, reflection is half as powerful, no assembly-level visibility, no linq expression tree compilation, I could go on for hours. string interpolation, better string literals, dynamic type (for easier reflection), multiple generic classes with the same name but different generic count, no tuples, no named tuples, no initialization statements, no references, no top level main function, functions aren't first-class members, no local functions, just one class per file,
You missed one interesting feature: you can now declare ref fields inside a ref struct. So you can write a new type like Span etc
Raw string literals/ interpolation, list patterns, file scoped types, and static virtual interfaces are all very useful.
Generics on attributes and required members are what I am personally looking forward to. I can write cleaner OO code that end users are less likely to be able to misuse :)
happened to be idle, lets learn 😊
static abstract interface members are my favorite by far. I cannot count how many times I thought "this code would be much nicer if this was possible". Second is raw string literals, because I have tons of tests that need constant XML or JSON values.
I have purchased courses from both Nick Chapsas and Tim Corey and Nick's courses are head and shoulders above Tim's. Nick talks at normal speed in his courses, provides the source code to follow along, and goes deep into the technical details of the topic. The courses are priced the same as a good book. They are a great value. Looking forward to more courses. I'd love a course on CI/CD with Azure and good NuGet package making practices.
This is an interesting contrast between these two content developers (Nick and Tim). I've kind of made the same observation myself, and I'm curious to know what it is about Tim's courses and content that you don't like? I'm a content creator myself and looking to develop some courses as well from my perspective and experience (25 years) as a .net developer. It's the first public critique of Tim's content I've seen so I'm curious to know if any other developers make the same observations I have. FULL DISCLOSURE: I'm not trying to incite unfair criticism of Tim or his content. One thing I will say is that this space is big enough for multiple content providers, and different people learn differently. I like Nick's content personally because the cadence works well (for me) as an experienced developer who wants to get down to the nitty-gritty of how it works.
My favorite new feature is the required' keyword with the new raw string literals as a close second. As someone who doesn't really write library/package code, only front-end consumed code, the other features don't really apply; but I love the work that the C# design team has done!
Thank you for the videos. I found out about you a few weeks ago and since then I am watching all of your videos and enjoy them very much!
I love your videos, I can always improve my projects with them + it's keeps me updated with every release.
Thanks for another amazing video. I'll be using the raw string literals a lot and the file scoped types in some cases.
This video is truly awesome. The perfect amount of detail to understand what the features do without making it way too long.
Awesome video as usual, and I do appreciate this presentation of the new features as you did it with examples.
This video was an impressive introduction to a lot of new features, most of this really wanted for the community. Amazing video, thanks you for sharing.
Great video, as always, Nick! Static abstract members by far will be my most-used feature here. I've wanted that more times than I can count going all the way back to .NET Framework days. The extended nameof scope will also be handy, my team ironically just attempted that the other day under C# 10 (obviously to no avail), so good to know it'll be there next time!
Love it Nick. Thanks for sharing it.
I was really hoping that the `required` keyword had more use cases. I was thinking it'd be awesome if DI could use them for property injection- if the field is specified as `required`, then when the DI container tries to build the type, it should try to populate those values and throw if it doesn't have a registration for it. This would mean we could get rid of constructor injection which would be awesome!
Well it depends whether you can check the field for required keyword using reflection API in .NET 7. Can you?
@@NoGamer256 Yes, the compiler adds a RequiredMemberAttribute to the property
String changes will be so useful and needed. Also thanks for the video Nick! You are doing God's work here 💪
Amazing video, thanks for shortcut new features!
Thanks for great video. My favourite features are list patterns, required member and pattern machining on spans...
This is exactly what I needed Thanks a ton mate!
As usual to the point, clear. Great video!
I'm disappointed that semi-auto properties were not added in C#11 :( that was the feature I was looking forward to most
Lots of exciting stuff. Required members are going to be so nice but I've been looking forward to list patterns since it was pushed right from the original pattern matching release.
i was waiting for exactly this video!
Static abstract interface members, how long have I been waiting for you. The System.Numerics namespace is full of yummies.
I really do love list patterns for parsers, a very useful feature
Scoped (and ref fields), easily. A big addition to the ref/ref readonly/in parameter toolkit.
Awesome video. I think at least the half of the new features will be useful for me, so let's see. Thanks Nick :)
Very good video! Thank you Nick
Great content. Thank you!
This is the video that i was watting for
Good video, thanks Nick
Awesome content. So useful. Any chance you can do similar summaries for earlier versions for those catching up? I find it incredibly useful in keeping up to date. Thanks again for such great content. 😎
I had the same thoughts. It would be really great to have the whole C# development history in a series of such videos! Also thanks for this pearl of a compact video with lot of content.
kzhead.info/sun/icqtZLV8jKKvipE/bejne.html this is for C# 10
Yes please, i was thinking the same
Great job Nick. I like 3 double quotes and pattern matching feature in C# 11 becuase they are "common man" features!
Nick, you're awesome!
This one video is worth so much for people who want to move to c# 11 Thx a lot man, you helped me more then you can believe 😄
Started using static abstract members on interfaces a couple months ago via the preview feature, but was looking forward to generic math becoming generally available - the combination of both has severely reduced boilerplate in a library I'm working on. Definitely looking forward to the 'scoped' video. I'm guessing it's something similar to lifetime annotations in Rust, albeit slightly more coder-friendly.
The "required" keyword seems to be the most benefitial and to be used. Tx.
ref fields and ref scoped are my favourites!
great content, thanks!
This video is so useful as usual. A similar video demonstrating all new features of C#9, 10, etc. Would also be very useful. I can see that you like to focus on new features, but you would be surprised how many teams still use. NET all the way back to 4.0. Even Microsoft is still moving code from ancient releases. These many folks could use a series of such videos as a single point of reference as they transition.
Awesome summary! Save me a lot of time!
Woha, so ready for c# 11! Techempower benchmarks on the release blog post for net7.0. Love it. They became household name quickly
Raw string literals very well explained.
I will use Generic attributes and Required members. Maybe file scoped types will become handy too. Thanks, for video.
21:30 The reason you need to initialize all values first is because structs are always located linearly in memory, and are not reset by default (as this has a performance cost), so C# gives you the opportunity to either use them without initialization default (and save a few nanoseconds, which can be relevant in extremely performance-hungry code), or initialize them all to ensure consistency
Finaly! Interface for countable types!! Yes!!!
list patterns (are also cool for pattern matching in switch), static abstract, string interpolation
required keyword will be better if it'll be default for records So you can created record either by ctor or by object initializer
Amazing video has there any other video like C# 1 feature C# 2 feature and so on
Hi Nick. Would you be interested in making a video about the performance improvements in EFCore 7? Maybe with a comparison with Dapper and ADO?
required keyword is definitely my favorite , just wish you could also do null/argument checking with auto-properties.
the notification got me excited
Thank you for your content. I am working as a .NET developer primarily using VS2022 and have many times referred to your content as best practice. I would like to see a video how you have configured Visual Studio Code to be so fluent when running and debugging projects. What plug-ins are you using. How have you configured your environment? How do you configure VS Code to have the features you so fluently use in your videos?
Raw literals will be very useful for inline values when creating unit testing or initial setups and List patterns looks great. But .Net 7 is a great release with a bunch of cool features.
Required members are my favorite new feature
Raw string literals for unit testing
Danke!
Good video as always. Generic math would have been a big help to me at my prior job. Most of those look pretty useful though. No great "oh my gosh, this changes everything" features. But lots of little useful additions.
Raw string literals, patterns for numeric values, abstract math, scope for name of.
7:45 this change alone is worth it for me. I have a writer to a nosql where i have a standardized data contract, before the Typing and params was overly complex and ugly. Now I can make my code way cleaner 😎
Feature 7 is awesome and will save us a ton of headaches with our special signal math routines. We finally can drop that bad template generator code for our special number types and methods like Min/Max/Avg, etc.
27:15 Well, why this is the case is quite understandable when you think about how a value type like a struct is stored: directly within the current scope, since no managed reference (pointer) in memory is made. Since you can never use an uninitialized variable in C#, it inevitably means that the struct has to be FULLY initialized before use, i.e. all fields must have been assigned with something. The compiler just wants to ensure this. Requiring you to assign it was needed, but assigning fields with a default value is also a solution. But it must be done in some or other way.
Is this restricted to Net7 or can I use some or all of these in Net6 as well? We are keeping to LTS versions at work.
So excited about generic attributes.
Generics on attributes ❤
this sound like microsoft moving features from typescript to c# and also taking inspirations from unity dots c# is getting better and better wish there was version of it that will force you to write optimized code by using new ways of doing things
For sure required fields. Pattern matching is nice, but can get a little terse and lower comprehension because you have to "compile" in your head what it's doing.
My 2 favorites: (1) Raw string literals is a very smart and useful adddition (2) Required members (when Autofac and Microsoft DI go updated to replace CTOR injection). SO MUCH boilerplate code will be removed!
It's likely going to be the same for me when it comes to the most used ones of these features. But really don't underestimate the gigantic impact of the new abstract static class members. Opposed what Nick says, it's not the same as the generic math extensions. The generic math extensions make use of it indeed (without the feature they where not possible), but also use a lot of new interfaces and their implementations on the primitive types associated classes. Static abstract members go beyond that. I also have yet to take a more detailed look at them, but basically they extend the whole inheritance model to static code, or at least for interfaces (I believe static virtual members for abstract classes are not added, but that may have good reasons). Their use is not limited to numeric types.
One of the projects I work on has a large number of unit tests that use static json as input, which I get from real data. Copying such strings as json is very annoying. So I will use raw string literals immediately and massively. Static virtual interfaces have been missing in C# for a long time. Required members is another feature that I very much welcome. And the last feature that I will definitely use right away is Generics on attributes.
I like the using spans for strings things. And all the span things. Raw string pretty cool. I guess the interface stuff is pretty cool too.. But couldn't it be done with abstract classes since 20 years or so ago? I mean they need to be implemented by the implementing types still? Am I missing to understan something important? :)
Let's hear it for literalliteral strings!!
Omg that INumber interface No more switching on the type of input, fuck yes.
Can we now remove [Required] attribute from Fields and replace that to "required member" ?? Do it will work with Json serialisation and ModelState in WebApi ?
I was employed as a programmer for a bit more than a decade and use Java, Javascript and C# reasonably often. While all the many language features each of these languages have to offer is great - because I'm often porting programs between each of these 3 languages the featureset of the engines and code I write remains extremely simple. Almost everything I write is single threaded, uses only basic data types (floats, ints, strings and doubles), struct like objects and simple arrays of data types and structs/objects. I find that by limiting my code to only the most basic features of the language I can port from one to another extremely easily - plus my programs remain very simple to read and understand.
lowered C# viewer in rider is so nice, only JIT asm viewer is left now and sharplab not needed anymore
my vavorit is INumber but what i will use the most is probaply """ this """;
Great video! On 21:46 you have IL Viewer, but it shows "High-Level C#". What plugin is that?
It’s not a plug-in. It’s a new feature of Rider’s new version. It’s amazing!
So, List Patterns can be used to search for entire key-values in a hashtable, instead of the Unix regular expressions? As long as you know what pattern you're looking for (which you do since you are writing the code, if you get an unexpected result you throw an exception)
Thank you!
Is there any mention of performance improvement or benchmark?
I’m one of the poor souls that will actual benefit from the scoped keyword 🤣🤣 (kill me)
Oh no! Sorry for not going too in depth. You can understand how advanced that type of C# is
It’s fine I’ve already gone through the release notes. I’m actually very grateful c# are adding these types of features, it’s almost in direct competition with rust now.
After about five minutes, I found myself counting how many times you said "go ahead and"...
List pattern matching is first C# pattern matching where it is nicer way than in F#.
Honestly some of c# syntax sugar is making things less and less readable.
What I like the most is the performance boost in C#11.
Required Required Required ... finally! :D
I'm very interested what happens what happens if you keep a reference to a value passed by the `scoped` keyword past the end of it's lifetime. Does it extend the lifetime by shifting it to the heap? Does it refuse to compile? Does it just let the reference dangle? Is it guaranteed to throw if you attempt to use the dangling reference, or are you just in UB land?
Will List Pattern matching work for object lists/arrays?
I'm still waiting for extension-everything, and hopefully getting rid of opening up entire namespaces just to use them
How do File Scoped Types work with unit testing?
Damn yesterday i bought an course from you, today there is a new discount code -_-
Generic Attributes... waiting soooooo long for it
Does `file` access modifier only apply to types? It will make closed hierarchies and exhaustive switches possible if it can be applied to constructors.
It’s classes, interfaces, structs and delegates
Raw string """xy"xh""" is handy but what one has to do to have " at the end or beginning of the string? :D
What IDE is Nick using here?
Can you explain more about the "Improved method group conversion to Delegate" and why is a lambda faster than a normal method when the lambda method will be boxed? I thought the opposite was true so I avoided using lambdas anywhere in my code
He has a video on his channel, titled "The C# 11 fix you didn’t know you needed", where he explains it in detail and shows benchmarks and everything
Basically, the lambda is cached in a static variable, while the method group recreates a delegate on every invocation.
@@MrBunt Thanks will look for the video
It can be a confusion by code reading, when we use a public class based on a file interface, because of need to keep in mind where the class was declared. Looks like it's too flexible, or I'm wrong.
Good video. Did they add keyword 'field' in this version to reduce private field declaration?
The field keyword didn’t make it in the full release
That was initially planned for C#11 but now it is planned for C#12
@@nickchapsas That means no semi auto implemented properties? That's sad, was really looking forward to this.
@@nickchapsas big sad