CS8524 warning is not correct

[sheam]

I believe your section on getting a warning because of an unhandled switch case is incorrect. I don't CS8524 has anything to do with switch statements. I think the error is actually CS8509, and it will fire as long as there is no default case.

---

Document Details

⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

• ID: ca98e1b9-588d-23a7-5a6d-a76bce0aabdc
• Version Independent ID: 5fcf7ff3-3a9c-d8df-9b7f-1b6bbcf188e0
• Content: Use patterns in objects - C# tutorial
• Content Source: docs/csharp/tutorials/exploration/patterns-objects.md
• Product: dotnet-csharp
• Technology: csharp-get-started
• GitHub Login: @BillWagner
• Microsoft Alias: wiwagn

[BillWagner]

Thanks for asking @sheam

The article is correct. You can verify that by downloading the source and removing this pragma

I'll close this as answered.

[sheam]

Actually, the code you gave me does not give the CS8524 warning. All I get is the CS8509 warning. Even if I use pragma to disable the CS8509, the CS8524 warning does not work.

You can verify that by downloading the source below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// This file contains versions of the code used in the patterns & objects tutorial
namespace InterimSteps
{
    // <APIDesign>
    public enum WaterLevel
    {
        Low,
        High
    }
    public class CanalLock
    {
        // Query canal lock state:
        public WaterLevel CanalLockWaterLevel { get; private set; } = WaterLevel.Low;
        public bool HighWaterGateOpen { get; private set; } = false;
        public bool LowWaterGateOpen { get; private set; } = false;

        // Change the upper gate.
        public void SetHighGate(bool open)
        {
            throw new NotImplementedException();
        }

        // Change the lower gate.
        public void SetLowGate(bool open)
        {
            throw new NotImplementedException();
        }

        // Change water level.
        public void SetWaterLevel(WaterLevel newLevel)
        {
            throw new NotImplementedException();
        }

        public override string ToString() =>
            $"The lower gate is {(LowWaterGateOpen ? "Open" : "Closed")}. " +
            $"The upper gate is {(HighWaterGateOpen ? "Open" : "Closed")}. " +
            $"The water level is {CanalLockWaterLevel}.";
    }
    // </APIDesign>

    public class CanalLockV2
    {
        // Query canal lock state:
        public WaterLevel CanalLockWaterLevel { get; private set; } = WaterLevel.Low;
        public bool HighWaterGateOpen { get; private set; } = false;
        public bool LowWaterGateOpen { get; private set; } = false;

        // <FirstImplementation>
        // Change the upper gate.
        public void SetHighGate(bool open)
        {
            HighWaterGateOpen = open;
        }

        // Change the lower gate.
        public void SetLowGate(bool open)
        {
            LowWaterGateOpen = open;
        }

        // Change water level.
        public void SetWaterLevel(WaterLevel newLevel)
        {
            CanalLockWaterLevel = newLevel;
        }
        // </FirstImplementation>
    }

    public class CanalLockV3
    {
        // Query canal lock state:
        public WaterLevel CanalLockWaterLevel { get; private set; } = WaterLevel.Low;
        public bool HighWaterGateOpen { get; private set; } = false;
        public bool LowWaterGateOpen { get; private set; } = false;

        // <SecondImplementation>
        // Change the upper gate.
        public void SetHighGate(bool open)
        {
            if (open && (CanalLockWaterLevel == WaterLevel.High))
                HighWaterGateOpen = true;
            else if (open && (CanalLockWaterLevel == WaterLevel.Low))
                throw new InvalidOperationException("Cannot open high gate when the water is low");
        }
        // </SecondImplementation>

#pragma warning disable CS8509 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.
        private void SetHighGateV2(bool open)
        {
            // <ThirdImplementation>
            HighWaterGateOpen = (open, HighWaterGateOpen, CanalLockWaterLevel) switch
            {
                (false, false, WaterLevel.High) => false,
                (false, false, WaterLevel.Low) => false,
                (false, true, WaterLevel.High) => false,
                (false, true, WaterLevel.Low) => false, // should never happen
                (true, false, WaterLevel.High) => true,
                (true, false, WaterLevel.Low) => throw new InvalidOperationException("Cannot open high gate when the water is low"),
                (true, true, WaterLevel.High) => true,
                (true, true, WaterLevel.Low) => false, // should never happen
            };
            // </ThirdImplementation>
#pragma warning restore CS8509 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.
        }
    }
}

[ErikvO]

This is a weird one.

I have a switch expression in my code that has this problem. It has been in there for some time now.
During compilation CS8509 was raised, so I used #pragma warning disable CS8509 to suppress the warning.
I checked in the change into my repository. Since then, multiple builds on the build server were run without any issue.

Now suddenly (after an update perhaps?) the same code is now throwing CS8524, both locally and on the build server. The code has not been touched in the mean time.
When changing the pragma disable to suppress CS8524 instead of CS8509 the warning is gone. I expected CS8509 to be raised again, but it wasn't.

It looks like there was a change in the CS8509 behavior or is not even present any more.
I was unable to find a list of compiler warnings that both list CS8509 and CS8524 to see what the actual difference is.

Can anybody clarify this? @BillWagner ?

[binki]

I think the change is dotnet/roslyn#47066 . It looks like that should have landed in 16.8. Unnamed enum values now get warning CS8524 instead of CS8509. This allows you to do something like adding CS8509 to your WarningsAsErrors property (because this is likely a bug) while possibly globally suppressing CS8524 (because this is less likely to be a bug) if you aren’t interested in seeing that warning.

Prior to this change, you would have to include a default expression in every switch statement. If you added a new value to an enum, it wouldn’t be possible to trigger a compiler error (because the default expression would mark that new enum value as handled instead of raising a warning). So this change is a feature. If you can require people to use the latest version of Visual Studio, you might want to switch to suppressing CS8524 and might even consider adding CS8509 to your WarningsAsErrors setting.

[binki]

To further clarify, the likely reason there is confusion is that 16.8 was released 2020-11-10: https://docs.microsoft.com/en-us/visualstudio/releases/2019/release-notes-v16.8#visual-studio-2019-version-168-releases