NotNullIfNotNullOrEmpty and NotNullIfNotNullOrWhiteSpace attributes

[Foxtrek64]

Hi all,

Hopefully opening this in the right repo.

I was working on some code with file paths and writing a helper function which accepts a file name and performs some cleanup (including stripping characters contained within Path.GetInvalidFileNameChars()).

One of the first guards in the code is to look to see if the provided file name is null or white space, and if so, return null.

I can annotate the function with [NotNullIfNotNull(nameof(fileName))], but this is technically not correct. It is true that if fileName is null, the return value is null. However, if fileName is not null but is empty or white space, the function also returns null.

Would a theoretical NotNullIfNotNullOrWhiteSpaceAttribute be able to function as expected here or would we run into issues because we cannot guarantee that fileName is constant?

Example of use

// "Safer" is used here because this function does not guarantee safety
// for any file system.
[return: NotNullIfNotNullOrWhiteSpace(nameof(fileName))]
public static string? CreateSaferFileName(string? fileName)
{
    if (string.IsNullOrWhiteSpace(fileName))
    {
        return null;
    }

    // Method impl
    return fileName;
}

[elgonzo]

How would that work, considering that the compiler needs to know the actual string instance that would be passed to the method, something that would only happen during run-time and not during build/compile time?

Imagine this simple example:

public record Foo(string Bar);

string json = File.ReadAllText(pathToSomeJsonFile); 
//
// file might contain the json: { "Bar": "        " }
// or the file might contain any other json like { "Bar": "Snafu" } for example
//
Foo f = JsonSerializer.Deserialize<Foo>(json);
string? result = CreateSaferFileName(f.Bar);
Console.WriteLine(result.Length);

What is the compiler supposed to do here given your hypothetical NotNullIfNotNullOrWhiteSpaceAttribute?

All the compiler knows is that the type of f.Bar is string, so its value is supposed to be not null. Therefore, for a [return: NotNullIfNotNull(nameof(fileName))] decorated CreateSaferFileName method, it would now deem result.Length to be safe (i.e., not to cause a NRE).

Checking the content of a string instance can only be a run-time check for any string instances not known during compile time. It can't possibly be a compile-time check, hence why a code-analysis attribute like NotNullIfNotNullOrWhiteSpaceAttribute can't really work in such cases. The only string instances the compiler would be possibly able to know about not being empty or only white-spaces during compile time are string constants/literals defined in the source code the compiler is processing and strings composed of other component strings of which at least one is a non-empty/non-white-space string constant/literal, so the usefulness of such an attribute would be quite limited...

[Foxtrek64]

That's what I'd suspected, thanks.