{"id":525492,"date":"2024-11-12T16:26:18","date_gmt":"2024-11-12T15:26:18","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=dotnet&p=525492"},"modified":"2025-04-09T08:11:20","modified_gmt":"2025-04-09T07:11:20","slug":"csharp-language-support-in-resharper-and-rider-2024-3","status":"publish","type":"dotnet","link":"https:\/\/blog.jetbrains.com\/zh-hans\/dotnet\/2024\/11\/12\/csharp-language-support-in-resharper-and-rider-2024-3","title":{"rendered":"C# Language Support in ReSharper and Rider 2024.3"},"content":{"rendered":"\n

Our upcoming 2024.3 release marks a huge milestone<\/b> for our development process but especially<\/em> for our users. ReSharper and Rider 2024.3 will be <\/em>simshipped<\/a> along with .NET 9 and C# 13!<\/b> Yes, you heard right\u2014no more waiting an extra few weeks or using our EAP builds to take advantage of the latest and greatest C# of all time. If all goes well (UPD: We’ve made it!), you can enjoy your most loved language in your most loved IDE starting tomorrow!<\/p>\n\n\n

\n
\nDownload Rider 2024.3<\/a> Download ReSharper 2024.3<\/a><\/div>\n<\/div>\n\n\n

In this blog post, we will cover new features that have been added to our C# language support over the 2024.3 release cycle. Note that some C# 13 features have already been covered in the 2024.2 release, including escape characters<\/a> and ref struct interfaces<\/a>. Make sure to check out our three-part series<\/a> if you’ve missed it!<\/p>\n\n\n\n

Partial Properties<\/h2>\n\n\n\n

One of the most anticipated features in C# 13 are partial properties<\/a>. Previously, the concept of partial members was limited to types and methods. While partial types (classes, structs, records) mainly help organize your code into multiple parts and avoid cluttered single files, partial members allow you to define a single member (methods, properties, indexers) in any of these parts with only one part implementing it. This concept becomes particularly powerful in combination with source generators<\/a> that automatically provide the correct and optimized implementation based on your member definitions:<\/p>\n\n\n

\n 
\/\/ User code<\/span>\r\npublic<\/span> partial<\/span> Person<\/span> : INotifyPropertyChanged<\/span>\r\n{\r\n    [JsonPropertyName<\/span>(\"custom-name\"<\/span>)]\r\n    public<\/span> partial<\/span> string<\/span> Name<\/span> { get<\/span>; set<\/span>; }\r\n}\r\n\r\n\/\/ Generated code<\/span>\r\npartial<\/span> Person<\/span>\r\n{\r\n    \/\/ More attributes allowed!<\/span>\r\n    public<\/span> partial<\/span> string<\/span> Name<\/span>\r\n    {\r\n        get<\/span> =><\/span> field<\/span>;\r\n        set<\/span> =><\/span> SetField<\/span>(ref<\/span> field<\/span>, value<\/span>);\r\n    }\r\n    \/\/ ...<\/span>\r\n}<\/code><\/pre>\n                
Copy to clipboard<\/div><\/div>\n            <\/div>\n            \n\n\n\n\n\n\n
With ReSharper and Rider 2024.3, we are adding support for partial properties syntax and updating our code highlightings and generators. For instance, you can generate property definitions through:<\/p>\n\n\n\n
    \n
  1. The Implement property in another part of class<\/em> quick-fix\n\n
    \n    \n    
    Implementing a partial property in another part of the type<\/figcaption>\n<\/figure>\n<\/li>\n\n\n\n
  2. The Generate Partial Members<\/em><\/a> action from the Alt<\/kbd>+Enter<\/kbd> menu\n\n
    \n    \n    
    Generating multiple partial properties<\/figcaption>\n<\/figure>\n<\/li>\n\n\n\n
  3. The code completion after typing partial<\/code>\n\n
    \n    \n    
    Code completion for missing partial properties<\/figcaption>\n<\/figure>\n<\/li>\n<\/ol>\n\n\n\n
    You will also find new and updated context actions to manage existing partial definitions. For instance, you can change the accessibility from one part of a member definition, and it will reflect on all the other parts:<\/p>\n\n\n\n
    \n    \n    
    Changing access modifiers or partial properties<\/figcaption>\n<\/figure>\n\n\n\n
    Or you can merge partial members<\/em> into one definition:<\/p>\n\n\n\n
    \n    \n    
    Merging partial properties into one definition<\/figcaption>\n<\/figure>\n\n\n\n
    Field Keyword<\/h2>\n\n\n\n
    The long-awaited field<\/code> keyword for properties is finally coming to C# 13 as a preview feature. Previously, you had to explicitly declare a backing field for every non-trivial property. With the new field<\/code> keyword, you can implement semi-auto-properties<\/em> by referencing the compiler-generated backing field in your custom accessor:<\/p>\n\n\n                        
    \n                
    \/\/ Before C# 13<\/span>\r\nclass<\/span> Person<\/span>\r\n{\r\n    private<\/span> string<\/span> _name<\/span>;\r\n    public<\/span> string<\/span> Name<\/span>\r\n    {\r\n        get<\/span> =><\/span> _name<\/span>;\r\n        set<\/span> =><\/span> _name<\/span> =<\/span> value<\/span>.<\/span>Trim<\/span>();\r\n    }\r\n}\r\n\r\n\/\/ From C# 13<\/span>\r\nclass<\/span> Person<\/span>\r\n{\r\n    public<\/span> string<\/span> Name<\/span>\r\n    {\r\n        get<\/span>;\r\n        set<\/span> =><\/span> field<\/span> =<\/span> value<\/span>.<\/span>Trim<\/span>();\r\n    }\r\n}<\/code><\/pre>\n                
    Copy to clipboard<\/div><\/div>\n            <\/div>\n            \n\n\n\n\n\n\n
    Once you’ve added <LangVersion>preview<\/LangVersion><\/code> to your project file, ReSharper and Rider will recognize the old pattern and offer to Replace with \u2018field’ keyword<\/em>:<\/p>\n\n\n\n
    \n    \n    
    Replacing backing fields with the field keyword<\/figcaption>\n<\/figure>\n\n\n\n
    ReSharper and Rider will also help you to Remove redundant bodies<\/em> where the property value is only returned or set:<\/p>\n\n\n\n
    \n    \n    
    Removing redundant bodies for accessor bodies<\/figcaption>\n<\/figure>\n\n\n\n
    With this syntax, some popular patterns involving properties become notably compact. For instance, as part of ourINotifyPropertyChanged<\/code> support<\/a>, we’ve updated our To property with \u2018SetField’ change notification<\/em> context action to implement properties more efficiently and easy to read:<\/p>\n\n\n\n
    \n    \n    
    Implementing property change notifications<\/figcaption>\n<\/figure>\n\n\n\n
    Another very common pattern is input value validation. While previously, you were forced to implement getter\/setter accessors and declare a backing field, ReSharper and Rider will now allow you to use parameter-checking context actions to convert to a succinct implementation for just the set<\/code> or init<\/code> accessor:<\/p>\n\n\n\n
    \n    \n    
    Adding null checks for properties<\/figcaption>\n<\/figure>\n\n\n\n
    To get the most compact formatting layout, make sure to enable Place simple accessor on single line<\/em> in your code style settings<\/span>!<\/p>\n\n\n\n
    \n    \n   
    Code style settings for property accessors<\/figcaption>\n<\/figure>\n\n\n\n
    System.Threading.Lock Type<\/h2>\n\n\n\n
    In .NET 9, we are getting a new type System.Threading.Lock<\/a><\/code> designed for thread synchronization<\/a>. In C#, you can implement thread synchronization through the lock<\/code> statement over any reference type object. Often, this is done with a private object<\/code> field that is created solely for locking purposes:<\/p>\n\n\n                        
    \n                
    class<\/span> LockObject<\/span>\r\n{\r\n    private<\/span> readonly<\/span> object<\/span> _syncRoot<\/span> =<\/span> new<\/span>();\r\n\r\n    public<\/span> void<\/span> M<\/span>()\r\n    {\r\n        lock<\/span> (_syncRoot<\/span>)\r\n        {\r\n            \/\/ work<\/span>\r\n        }\r\n    }\r\n}<\/code><\/pre>\n                
    Copy to clipboard<\/div><\/div>\n            <\/div>\n            \n\n\n\n\n\n\n
    While technically alright, these object<\/code> fields do not tell how they’re intended to be used apart from their name. Locking is often performed over existing objects accessible to other locking types, which can have unintended side effects. Firstly, entering the block can be unnecessarily delayed from other classes that lock on the same object. Secondly, since the runtime might have to promote the lock<\/a> when Object.GetHashCode()<\/code> is called or thread contention happens, the following lock acquisition or release will be slightly more expensive.<\/p>\n\n\n\n
    The System.Threading.Lock<\/code> was introduced to solve both of the issues described above. It clearly expresses the intent of fields used for locking, while it also avoids performance degradation. In 2024.3, we detect old field synchronization patterns and offer the replacement with the Lock<\/code> type:<\/p>\n\n\n\n
    \n    \n    
    Converting to System.Threading.Lock in synchronization patterns<\/figcaption>\n<\/figure>\n\n\n\n
    Merge Switch-Case Sections<\/h2>\n\n\n\n
    In our last 2024.2 release, we introduced a new quick-fix Extract Common Code<\/em><\/a>, which can extract common statements from if<\/code> and switch<\/code> statements. In the new 2024.3 release, we are extending this family of code duplication fixes with a new quick-fix to merge duplicated switch<\/code> cases into a single case with broader conditions:<\/p>\n\n\n\n
    \n    \n    
    Merging duplicated switch section bodies<\/figcaption>\n<\/figure>\n\n\n\n
    As a reminder, these inspections can also hint at code that was supposed<\/em> to be different but ended up unchanged after copy-pasting it. So make sure to carefully investigate each duplication before merging it!<\/p>\n\n\n\n
    IDE Tooltips Colorization<\/h2>\n\n\n\n
    As with every release, we not only focus on supporting new language features but also enhancing existing functionality to ensure our .NET IDEs stay aligned with modern IDE capabilities. In this release, we reviewed nearly all C# errors, warnings, and informational messages to introduce editor-like text colorization wherever possible. Overall, approximately 600 messages were upgraded, making many of the tooltips you see daily more structured and easier to read:<\/p>\n\n\n\n
    \n    \n   
    Colorization and cleanup of tooltips<\/figcaption>\n<\/figure>\n\n\n\n
    And this is just the beginning\u2014utilizing the colorization infrastructure, we plan to enhance other error messages, particularly type conversion errors. During the refactoring, we also introduced colorization in various other editor tooltips and popups:<\/p>\n\n\n\n
    \n    \n   
    Colorization of classes in \u2018missing references\u2019 popup (Rider only)<\/figcaption>\n<\/figure>\n\n\n\n
    \n    \n   
    Colorization of classes in type hierarchy popup (ReSharper only)<\/figcaption>\n<\/figure>\n\n\n\n
    Obsolete and EditorBrowsable<\/h2>\n\n\n\n
    Over many years, we’ve been struggling to properly support [Obsolete]<\/code><\/a> and [EditorBrowsable]<\/code><\/a> in our code completion. That is mainly because we cannot afford to ask each code entity in a completion list (types, members) about its traits regarding these two attributes. Caching, one of the most obvious solutions, is not well-suited for the source code domain, where code semantics can change drastically with each keypress. However, it can be effective for compiled code from assemblies, though it has the drawback of using more memory and performance on the first read.<\/p>\n\n\n\n
    In 2024.3, we’ve managed to find the sweet spot of trade-offs to support both the [Obsolete]<\/code> and [EditorBrowsable]<\/code> attributes while also ensuring that the IDE performance remains unaffected. Types and members marked as obsolete are now de-prioritized in the completion list sorting. This should be particularly useful for Unity developers, where some common base classes have many obsolete members. Types and members marked with EditorBrowsableState.Never<\/code> are filtered out from the list by default:<\/p>\n\n\n\n
    \n    \n   
    Filtering and sorting in code completion lists<\/figcaption>\n<\/figure>\n\n\n\n
    You can change the filter behavior for the [EditorBrowsable]<\/code> attribute in the code completion settings:<\/p>\n\n\n\n
    \n    \n   
    Code completion settings for the [EditorBrowsable] attribute<\/figcaption>\n<\/figure>\n\n\n\n
    Operation Priority Quick-Fixes<\/h2>\n\n\n\n
    In C#, certain operations, such as enum flag checks or nested ternary conditional expressions, may require extra parentheses to ensure correct priority and readability. Adding these parentheses manually can be cumbersome and disrupt your coding flow. To streamline this, we’ve introduced a Prioritize operation using parentheses<\/em> quick-fix that automatically inserts any necessary parentheses in these common scenarios, allowing you to focus on more critical aspects of your code:<\/p>\n\n\n\n
    \n    \n    
    Prioritizing operations using parentheses<\/figcaption>\n<\/figure>\n\n\n\n
    Conclusion<\/h2>\n\n\n\n
    .NET 9 and C# 13 bring powerful advancements in runtime and language. ReSharper and Rider are here to complement them with the best-in-class and most productive IDE experience!<\/p>\n\n\n\n
    As always\u2014make sure to use the comment section below to let us know about other features around .NET and C# you’d like to see in your developer toolbox!<\/p>\n","protected":false},"author":553,"featured_media":525174,"comment_status":"closed","ping_status":"closed","template":"","categories":[4992,1401],"tags":[158,8553,211,8538,46,1978,1941],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/dotnet\/525492"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/dotnet"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/types\/dotnet"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/users\/553"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/comments?post=525492"}],"version-history":[{"count":9,"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/dotnet\/525492\/revisions"}],"predecessor-version":[{"id":557401,"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/dotnet\/525492\/revisions\/557401"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/media\/525174"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/media?parent=525492"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/categories?post=525492"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/tags?post=525492"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/zh-hans\/wp-json\/wp\/v2\/cross-post-tag?post=525492"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}