C#: Enum.TryParse() succeeds when passing "-1" even if the enum doesn't contain that value

I want to print the value of an enum only if its gets parsed correctly. As stated in Enum.TryParse() docs:
> Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. The return value indicates whether the conversion succeeded.

> Returns
Boolean
true if the conversion succeeded; false otherwise.

Now, considering the example below, I would expect that the call succeeds only if I try to parse strings like "first" or "1", which are name/values of TestEnum.

But if I try to parse the string "-1", the call still succeeds and I get -1 as value, how's that even possible??

Example:

using System;

public class HelloWorld
{
    public enum TestEnum
    {
        first = 0,
        second = 1,
        third = 2
    }
    
    public static void Main(string[] args)
    {
        TestEnum testEnum;
        bool res;
        
        res = Enum.TryParse("first", out testEnum);
        if (res)
            Console.WriteLine ("TEST 1 - res: " + res.ToString() + ", value: " + testEnum.ToString());
            
        res = Enum.TryParse("third", out testEnum);
        if (res)
            Console.WriteLine ("TEST 2 - res: " + res.ToString() + ", value: " + testEnum.ToString());
            
        res = Enum.TryParse("1", out testEnum);
        if (res)
            Console.WriteLine ("TEST 3 - res: " + res.ToString() + ", value: " + testEnum.ToString());
            
        
        res = Enum.TryParse("-1", out testEnum);
        if (res)
            Console.WriteLine ("TEST 4 - res: " + res.ToString() + ", value: " + testEnum.ToString());
            
        res = Enum.TryParse("fourth", out testEnum);
        if (res)
            Console.WriteLine ("TEST 5 - res: " + res.ToString() + ", value: " + testEnum.ToString());
    }
}

Output:

TEST 1 - res: True, value: first
TEST 2 - res: True, value: third
TEST 3 - res: True, value: second
TEST 4 - res: True, value: -1        // <-- How??

Link to the code: https://onlinegdb.com/1MIOnOFl6

Actually, an enum is an integer and can hold all values a normal integer can hold. In your case,

TestEnum test1 = TestEnum.first;

will create an integer of value 0. But it is also possible to create a variable

TestEnum test2 = (TestEnum)-1;

Because -1 is a valid integer and can be assigned to TestEnum. This is also the reason why you typically write code like this if you use a switch with an enum:

switch(test)
{
   case TestEnum.first: DoSomething(); break;
   case TestEnum.second: DoSomethingElse(); break;
   case TestEnum.third: DoSomethingDifferent(); break;
   default: throw new Exception("invalid value for test");
}

You need the default clause because you can not rely that your enum variable is only one of the values first, second or third.

You can also change the underlying type of your enum. For example, if you declare your enum like

public enum TestEnum : uint { first = 0, second = 1, third= 2}

The assignement above will be invalid (because -1 is not a valid value for uint. Also, res = Enum.TryParse("-1", out testEnum); will return false in that case.

If you wonder why such a behaviour can make sense, consider enums with flags option:

[Flags]
public enum Options
{
None = 0,
Option1 = 1,
Option2 = 2,
Option3 = 4,
Option4 = 8
}

Here you can write Options options = Options.Option1 | Options.Option2, which has the value 3 which is not defined in the enum above.

As noted in the comments, you can use the Enum.IsDefined method if you want to check whether the value is really defined. You can check whether the numeric value or the string is defined in your enum.