'How can I force Resharper to use the CLR type names for auto-generated code?

According to the General Naming Conventions the usage of CLR type names (e.g. String, Int16) should be preferred over the usage of language specific type names (string, short). I usually follow this advice. Resharper however seems to use the language specific type names when generating code (refactorings like extract method, generating foreach loops, etc.) which is very annoying.

How can I force Resharper to use the CLR type names instead?

Update As many are wondering why someone would enforce a style where Int32 instead of int or String instead of string is used, the intention was better syntax highlighting: int is rendered as a keyword, Int32 is rendered as a type. As modifying the highlighting implementation seems overkill, enforcing CLR type simply does the job. That one of the reasons why this is part of our style guide.

c++sharp.netvb.netnaming-conventionsresharper


Solution 1:[1]

Open R# Options, go to C# Code Style. Or in more detail:

RESHARPER->Options

Code Editing->C#->Syntax Style

Build-in types

  • In locals, members and parameters, prefer - CLR type name
  • Members to qualify - CLR type name

Aside: You probably want to safe it Team Shared only as most public projects prefer keywords instead (and you don't want to accidentally annoy OSS contributors by suggesting a patch with that style).

older versions

Code Editing->C#->Code Style

Build-in type naming->When referencing build-in type, prefer using choose CLR type name

This feature requires R#9.1 or higher.

If you are bound to even older versions of ReSharper

There was an Extension for R#4.5-5.1 with exactly that purpose in mind. It's called Neovolve. Unfortunately this extension wasn't ported to any later R# versions.

VS 2015

Also for Visual Studio 2015 you may want to disable to prefer the intrinsic predefined types (which causes the symbols to be grayed out in the text editor) under Tools->Options Text Editor->C#->Code Style->Prefer intrinsic predefined type keyword*

Solution 2:[2]

Those guidelines are referring to public method names on your api, such as obj.ReadInt32() (perhaps in a serializer). In the body of a code (variables and parameters) it is less specified. Personally I prefer the aliases double, int etc - as:

  • better highlighting
  • less typing
  • avoids issues with non-keyword usage, i.e. if I have another method/type/property/etc called Int32 (stupid, but possible; where-as int always means global::System.Int32)
  • works even if you don't have using System;

Personally, I would not worry about this. R# is not doing anything wrong.

As an aside - note that there are a few examples of MS getting this wrong - one that leaps to mind is IDataReader/DbDataReader with GetFloat() (should be GetSingle()).

Solution 3:[3]

There is currently no ReSharper option to prefer System.Int16 over short, and similar. There is an open feature request on YouTrack which you can vote for; but note that it has been open for over five years without being implemented, which you may choose to take as a hint.

Solution 4:[4]

I know this question has already been answered, but for those wondering about the preferred style in the future, the .NET team now officially recommends using the language name instead of the CLR name, and this is the style used for .NET Core development.

We use language keywords instead of BCL types (e.g. int, string, float instead of Int32, String, Single, etc) for both type references as well as method calls (e.g. int.Parse instead of Int32.Parse).

https://github.com/dotnet/corefx/blob/master/Documentation/coding-guidelines/coding-style.md

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1
Solution 2 Marc Gravell
Solution 3 AakashM
Solution 4 micahmo

Related Questions