Is Pure attribute useless? [closed]

Question

I found PureAttribute in .NET source code (System.Diagnostics.Contracts.PureAttribute) and here is the summary:

Indicates that a type or method is pure, that is, it does not make any visible state changes. I checked here lowered C#

I checked ever in debug mode Debug -> windows -> Disassembly and the code is exactly the same. So what is the different? I found that "There is a contract" etc. or "if we send the same parameters always we get the same result". Ok, got it. But if it changes nothing, why does it exist? No performance? No readability? And what is that contract?

I expect get answers for these questions:

• If it changes nothing why does it exist? No performance? No readability?
• What is that contract?

Answer 1

The original purpose of the [Pure] attribute appears to have been to support the old "Code Contracts" analysis, which sadly is no longer being developed.

The [Pure] attribute is not used in any code analysis:

This attribute is not enforced by the current analysis tools

Now the only purpose is for documenting the fact that a method does not cause any observable state change - but unfortunately no code analysis tools that I know of actually enforce this.

There is one ReSharper warning which is provoked by the [Pure] attribute: If you ignore the return value of a pure method, ReSharper will warn you. Other than that, nothing seems to warn you if you modify observable state in a pure method or change the state of a pure parameter, as the following code demonstrates:

using System;
using System.Diagnostics.Contracts;

namespace Console1;

public static class Program
{
    static void Main(string[] args)
    {
        CalculateSomething(); // Resharper warning: "Return value of pure method not used".
        ChangeSomething();    // Resharper warning: "Return value of pure method not used".
        DoSomething();        // No warnings.
    }

    [Pure] public static int CalculateSomething()
    {
        return _field;
    }

    [Pure] public static int ChangeSomething()
    {
        _field = 1; // Provokes NO warning.
        return 42;
    }

    public static int DoSomething()
    {
        return _field;
    }

    public static void ChangeParameter([Pure] Random rng)
    {
        _ = rng.Next(); // No warning about calling impure method of pure parameter.
    }

    static int _field;

}

Microsoft's Code Analysis will also issue a similar warning, CA1806, if you fail to observe the return value of a pure method.