Meziantou.Analyzer Documentation

Meziantou.Analyzer provides a collection of code analysis rules for C# to improve code quality, performance, security, and design. The rules are categorized into several types:

• Usage: Focuses on correct usage of APIs and language features (e.g., missing StringComparison, IFormatProvider, or CancellationToken).
• Style: Focuses on code readability and formatting (e.g., adding parameter names or trailing commas).
• Performance: Focuses on optimizing code execution (e.g., using Array.Empty<T>(), optimizing StringBuilder, or avoiding unnecessary LINQ calls).
• Design: Focuses on architectural best practices (e.g., making classes sealed, using collection abstractions, or avoiding blocking calls in async methods).
• Security: Focuses on preventing security vulnerabilities (e.g., requiring regex evaluation timeouts or preventing custom certificate validation).

Rules vary in Severity (Info ℹ️, Warning ⚠️, Error ❌) and support for Code Fixes and Configuration.

The MA0100 rule detects instances where a Task, Task<T>, ValueTask, ValueTask<T>, or any type following the awaitable pattern is returned from a method while a disposable resource (like a using block) is still in scope. If the task is not awaited within the method, the resource may be disposed of before the task actually completes, leading to unpredictable behavior or errors.

To fix this, ensure the task is awaited before the scope of the disposable resource ends.

using System;
using System.Threading.Tasks;

class TestClass
{
    // Violates MA0100: scope is disposed before the returned task completes
    Task Demo1()
    {
        using var scope = new Disposable();
        return Task.Delay(1); 
    }

    // Correct: task is awaited before scope ends
    async Task Demo2()
    {
        using var scope = new Disposable();
        return await Task.Delay(1);
    }
}

The CultureInsensitiveTypeAttribute is used to mark types whose ToString() methods and format strings are culture-insensitive. Applying this attribute suppresses culture-related analyzer rules:

• MA0011: IFormatProvider is missing
• MA0075: Do not use implicit culture-sensitive ToString
• MA0076: Do not use implicit culture-sensitive ToString in interpolated strings

You can obtain the attribute via the Meziantou.Analyzer.Annotations NuGet package, or by copying the attribute definition directly into your project. The analyzer identifies it by name and namespace.

using Meziantou.Analyzer.Annotations;

[CultureInsensitiveType]
public struct Ulid
{
    public override string ToString() => "..."; // Culture-insensitive implementation
}

// Usage - no warning
var id = new Ulid();
id.ToString(); // OK - Type is marked as culture-insensitive

In C#, methods containing a yield statement use deferred execution. This means the method body is not executed until the returned IEnumerable is actually enumerated. If you perform argument validation (like checking for null) inside an iterator method, the validation will not occur when the method is called, but rather when the caller starts iterating over the results. This can lead to bugs where invalid arguments are not caught until much later in the program execution.

To fix this, you should validate arguments in a non-iterator wrapper method and then call a private local function or nested method that contains the actual yield logic. This ensures that ArgumentException-derived exceptions (including those thrown via ArgumentNullException.ThrowIfNull or similar static helpers) are thrown immediately upon method invocation.

// INCORRECT: Validation is deferred until enumeration
IEnumerable<int> Sample(string a)
{
    if (a == null)
        throw new System.ArgumentNullException(nameof(a));

    yield return 0;
}

// CORRECT: Validation happens immediately
IEnumerable<int> Sample(string a)
{
    if (a == null)
        throw new System.ArgumentNullException(nameof(a));

    return SampleInternal();

    IEnumerable<int> SampleInternal()
    {
        yield return 0;
    }
}