MemberNotNullIfNotNull

[ds5678]

It's very common for the null status of a member to be dependent on the null status of other values.

[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
public sealed class MemberNotNullIfNotNullAttribute(string member) : Attribute
{
}
public class ExampleClass
{
	public ExampleClass([MemberNotNullIfNotNull(nameof(Name))] string? name, [MemberNotNullIfNotNull(nameof(Parent))] ExampleClass? parent = null)
	{
		Name = name;
		Parent = parent;
	}

	public string? Name { get; set; }

	public ExampleClass? Parent { get; set; }

	[MemberNotNullIfNotNull(nameof(Parent))]
	public string? ParentName => Parent?.Name;
}

[ParsaMehdipour]

In what situation might this be useful?

[ds5678]

Top 2 situations:

• Member not null status can be inferred from the not null status of a method parameter. For example: in a constructor, initializing a maybe null field with a not null parameter value.
• A property get method returns not null conditioned on the not null status of some other member.

[ParsaMehdipour]

Do you mean like the following?

1. Member not null status inferred from a method parameter:

public class Person
{
    private string? _name;

    [MemberNotNullWhen(returnValue: true, member: nameof(_name))]
    public bool TrySetName([NotNullWhen(returnValue: true)] string? name)
    {
        if (string.IsNullOrEmpty(name))
            return false;

        _name = name;
        return true;
    }

    public string GetName()
    {
        if (_name == null)
            throw new InvalidOperationException("Name is not set");
        
        return _name;
    }
}

In this example, the TrySetName method is marked with MemberNotNullWhen. This indicates that when the method returns true, the _name field is guaranteed to be not null. This helps static analysis tools understand that after a successful call to TrySetName, it's safe to call GetName without risking a null reference exception.

2. Property returning not null conditioned on another member's not null status:

public class Employee
{
    public string? FirstName { get; set; }
    public string? LastName { get; set; }

    [MemberNotNullWhen(returnValue: true, nameof(FirstName), nameof(LastName))]
    public bool HasFullName => !string.IsNullOrEmpty(FirstName) && !string.IsNullOrEmpty(LastName);

    [MemberNotNull(nameof(FirstName), nameof(LastName))]
    public string GetFullName()
    {
        if (!HasFullName)
            throw new InvalidOperationException("Full name is not available");

        return $"{FirstName} {LastName}";
    }
}

[ds5678]

No, those are completely different.

1. Using a boolean as an intermediary is not a substitute for actual null status propagation between members.

2. Your example doesn't make sense because GetFullName will never return null, so it's not really conditioned on the other two properties.

[ParsaMehdipour]

Got it
Awsome✌️

[hawkerm]

Yeah, I was thinking I could try and use MemberNotNull/MemberNotNullWhen for similar situations outside of construction, but don't think that currently works either.

For instance, I have a class which gets initialized post construction through an exterior factory which loads/processes data in bits as a file is read.

After that process though (if successful), I'll know the members won't be null. So, it'd be great if I could tell the compiler that somehow so I don't have to worry about the null warnings everywhere I use the properties.

    public static LevelData LoadLevel(string filePath)
    {
        LevelData levelData = new();
        
        // Level Loading Logic from file, etc...
        ...
        levelData.Title = valueFromFile;
        ...
        
        // Maybe I have to call some method for final check or to hook into a bool return for MemberNotNullWhen, but I'm fine with that
        if (levelData.Initialize())
        {
             return levelData;
        }

       throw InvalidOperationException("Level can't be loaded...");
    }
    
    public class LevelData
    {
        public string? Title { get; set; }
        
        /// <summary>
        /// Called by LevelLoader after all data is loaded.
        /// </summary>
        [MemberNotNullWhen(true, nameof(Title))]
        public bool Initialize()
        {
            // Do other processing/checks, just simplified for sake of example
            return Title != null;
        }
    }
    
    [TestMethod]
    public void TestLevelLoading()
    {
        var level = LevelLoader.LoadLevel("Level.txt");

        Assert.AreEqual("I won't be null here...", level.Title); // Shouldn't say that Title might be null here
       // In my case I'm loading some array data, so I get a CS8602 on my array property of a possible null dereference
    }