C# 6.0 String Interpolation, FormattableString, and Code Analysis CA1305: Specify IFormatProvider

C# 6.0 introduces a syntactic sugar string interpolation, it is safer and more readable than composite formatting. Here is a small example:

1
using System;
2
using System.Diagnostics;
3

4
internal static class Program
5
{
6
    private static void Main() => Trace.WriteLine($"Machine name: {Environment.MachineName}.");
7
}

However, string interpolation does not get along with code analysis. By default, the $ syntax will be compiled to composite formatting, by calling the string.Format overload without IFormatProvider parameter:

1
using System;
2
using System.Diagnostics;
3

4
internal static class Program
5
{
6
    private static void Main() => Trace.WriteLine(string.Format("Machine name: {0}.", Environment.MachineName));
7
}

As a result, Code Analysis/FxCop issues a CA1305 warning for every interpolated string: Specify IFormatProvider. This is very annoying.

Interpolated string has a infamous feature, it can be also compiled to System.FormattableString:

1
namespace System
2
{
3
    using System.Globalization;
4

5
    public abstract class FormattableString : IFormattable
6
    {
7
        protected FormattableString() { }
8

9
        public abstract string Format { get; }
10

11
        public abstract int ArgumentCount { get; }
12

13
        public abstract object[] GetArguments();
14

15
        public abstract object GetArgument(int index);
16

17
        public abstract string ToString(IFormatProvider formatProvider);
18

19
        string IFormattable.ToString(string ignored, IFormatProvider formatProvider) => this.ToString(formatProvider);
20

21
        public static string Invariant(FormattableString formattable)
22
        {
23
            if (formattable == null)
24
            {
25
                throw new ArgumentNullException(nameof(formattable));
26
            }
27

28
            return formattable.ToString(CultureInfo.InvariantCulture);
29
        }
30

31
        public override string ToString() => this.ToString(CultureInfo.CurrentCulture);
32
    }
33
}

Here FormattableString.Invariant seems to be a solution. Notice FormattableString is an abstract class. It is inherited by System.Runtime.CompilerServices.FormattableStringFactory.ConcreteFormattableString:

1
namespace System.Runtime.CompilerServices
2
{
3
    public static class FormattableStringFactory
4
    {
5
        private sealed class ConcreteFormattableString : FormattableString
6
        {
7
            private readonly string _format;
8

9
            private readonly object[] _arguments;
10

11
            public override string Format => this._format;
12

13
            public override int ArgumentCount => this._arguments.Length;
14

15
            internal ConcreteFormattableString(string format, object[] arguments)
16
            {
17
                this._format = format;
18
                this._arguments = arguments;
19
            }
20

21
            public override object[] GetArguments() => this._arguments;
22

23
            public override object GetArgument(int index) => this._arguments[index];
24

25
            public override string ToString
26
                (IFormatProvider formatProvider) => string.Format(formatProvider, this._format, this._arguments);
27
        }
28

29
        public static FormattableString Create(string format, params object[] arguments)
30
        {
31
            if (format == null)
32
            {
33
                throw new ArgumentNullException(nameof(format));
34
            }
35

36
            if (arguments == null)
37
            {
38
                throw new ArgumentNullException(nameof(arguments));
39
            }
40

41
            return new ConcreteFormattableString(format, arguments);
42
        }
43
    }
44
}

So that, FormattableString.Invariant calls ConcreteFormattableString.ToString, which then calls string.Format, the overload with IFormatProvider. Code Analysis warning CA1305: Specify IFormatProvider can be fixed as:

1
using System;
2
using System.Diagnostics;
3

4
using static System.FormattableString;
5

6
internal static class Program
7
{
8
    private static void Main() => Trace.WriteLine(Invariant($"Machine name: {Environment.MachineName}."));
9
}

Above interpolated string is compiled to composite formatting call to FormattableStringFactory.Create:

1
using System;
2
using System.Diagnostics;
3
using System.Runtime.CompilerServices;
4

5
using static System.FormattableString;
6
internal static class Program
7
{
8
    private static void Main() => Trace.WriteLine(Invariant(
9
        // $"Machine name: {Environment.MachineName}." is compiled to:
10
        FormattableStringFactory.Create("Machine name: {0}.", Environment.MachineName)));
11
}

So the conclusion is, to fix Code Analysis CA1305 for C# 6.0 string interpolation, FormattableString.Invariant has to be called for every occurrence of $ syntax. This is still very annoying. Hope there can be another syntactic sugar for this, for example, a $$ prefix to call FormattableString.Invariant.

Also, MSDN and many other articles are inaccurate about interpolated string and FormattableString. MSDN says:

There are implicit type conversions from an interpolated string

In .NET, the term “implicit type conversion” is usually about runtime behavior, implemented by calling a type conversion operator defined with the implicit keyword. However, as demonstrated above, interpolated string becomes FormattableString/IFormattable at compile time.