Code Analysis and Helpers for String Literals
ReSharper provides a bunch of features for string literals in your code. You can benefit from ReSharper's code analysis and numerous helpers in:
Plain strings
Here is how ReSharper can help you when you are working with plain strings in your code:
-
By default, ReSharper highlights correct and incorrect escape sequences in all non-verbatim strings:
- You can convert regular strings to verbatim strings and back by pressing Alt+Enter when your caret is in the string and choosing the corresponding context actions. This also works with interpolated strings.
- You can split string literals simply by pressing Enter or Shift+Enter.
- If a string contains regular expression, ReSharper will highlight its syntax and errors, and help you with code completion inside the expression. For more information, see Regular Expressions Assistance.
- You can select some substring within a string and automatically introduce a variable for the substring.
- If your project is localizable, you can automatically move a string to resource.
String formatting methods
ReSharper analyzes format strings and arguments of all .NET string formatting methods, such as
String.Format
,
Text.StringBuilder.AppendFormat
, or
Console.WriteLine
.
In usages of string formatting methods, ReSharper highlights format placeholders and also synchronously highlights placeholder with the corresponding argument when your caret is at either of them:
If arguments and format placeholders mismatch (which leads to the
FormatException
in runtime if arguments are missing),
ReSharper generates warnings for missing or redundant arguments:
Ypu can easily fix this problem by pressing Alt+Enter over the warning. ReSharper will suggest you either to automatically add the missing argument or to remove the mismatched format placeholder.
ReSharper also helps you detect and remove redundant calls of string formatting methods inside other string formatting methods. For example:
To qucily convert a concatenation of string literals and variables, press
Alt+Enter anywhere within the concatenation and use the
To String.Format invocation
context action.
For example, if we apply this context action in the
return
statement of the following method:
public string Greet(string name, int age)
{
return "Hi, my name is " + name + " and I'm " + age;
}
It will be converted to:
public string Greet(string name, int age)
{
return String.Format("Hi, my name is {0} and I'm {1}", name, age);
}
You can also use context actions to automatically add and remove format placeholders
and arguments in strings.
When you invoke the
Insert format argument action within a string literal,
ReSharper inserts a new placeholder with the proper index
and brings you to the position where you can immediately start typing the argument.
This action can be also invoked on a plain string.
In this case ReSharper will automatically convert it to the
String.Format
call.
In order to quickly remove a format placeholder together with the corresponding argument, set the caret at the placeholder, press Alt+Enter and choose Remove format argument.
Custom string formatting methods
When a custom string formatting method appears,
you have to tell ReSharper to interpret it as such, which is quite easy - you need to decorate the method
with the
[StringFormatMethodAttribute]
from the
JetBrains.Annotations namespace.
As soon as the method has this attribute, you will enjoy all
features available for standard formatting methods.
Consider a custom string formatting method
ShowError
:
public void ShowError(string formatString, params object[] args)
{
// some custom logic
Console.WriteLine(formatString, args);
}
If the method is called incorrectly, as shown below, ReSharper has no chance to detect the missing argument:
To make ReSharper aware of a custom string formatting method
-
Reference the
JetBrains.Annotations
namespace as described in the Annotations in Source Code section. -
Annotate your custom string formatting method with the
[StringFormatMethodAttribute]
attribute, which takes a single argument - the name of the format string parameter:[StringFormatMethod("formatString")] public void ShowError(string formatString, params object[] args) { // some custom logic Console.WriteLine(formatString, args); }
ReSharper will now be able to warn you about missing arguments when this custom formatting method is invoked. Even more, the Add argument quick-fix will make it easier for you to insert them:
Interpolated strings
If you are using C# 6.0 in your project, you can use
interpolated strings
instead of the
String.Format
method.
By default, ReSharper automatically detects C# version based on the associated compiler However, you can specify the target C# version explicitly by selecting the project in the Solution Explorer and using the C# Language Level property in the Visual Studio's Properties window (choose in the menu).
In C# 6.0 projects, ReSharper highlights usages of
String.Format
with the suggestion to convert them into interpolated strings.
You can use a
quick-fix to convert the current usage or all usages
in the specific scope
with a couple of keystrokes.
If an interpolated string contains no expressions, ReSharper highlights the
$
sign as redundant and helps you remove it: