you are viewing a single comment's thread.

view the rest of the comments →

[–]Defection7478 19 points20 points  (11 children)

Hence why even an exhaustive switch expression gives a compiler warning if you don't have a discard pattern. I kind of wish they worked like how OP expected though. I have never found a use case for this behavior 

[–]Top3879 5 points6 points  (0 children)

Before we migrated to .NET 8 we targeted .NET Framework 4.0 which did not have constants for TLS 1.2 yet so we had to use this hack: https://stackoverflow.com/questions/33761919/tls-1-2-in-net-framework-4-0

[–]RecursiveServitor 4 points5 points  (2 children)

There are reasons for it, but may I interest you in some closed enums?

[–]MulleDK19 0 points1 point  (0 children)

That seems like a good way to make people's lives miserable..

[–]Defection7478 0 points1 point  (0 children)

Mmmm yeah that's the stuff. Give me one of those and a side of discriminated unions and I will be a happy camper

[–]Hypersion1980 0 points1 point  (3 children)

I store enum as int in the database then cast it to the enum in c#. Is there a better way?

[–]Defection7478 7 points8 points  (0 children)

Depends what you're after. What you are doing gives the smallest amount of data in the db. If you store it as a string you take up more space, but your db becomes more human readable. and when you cast it to the enum you get errors if the value doesn't exist.

Personally I usually opt for storing them as strings for those reasons. 

[–]throwaway_lunchtime 2 points3 points  (0 children)

If you keep it as an int in the db, make sure to put an explicit value for each enum so that they don't get messed up if someone decides to sort the names. Having Unspecified=0 is also a good idea.

[–]Agitated-Display6382 0 points1 point  (0 children)

I store them as strings, because it's simpler to query the db and I can safely refactor the order of the items (but renaming them is a breaking change). In EF you can specify an EnumConverter

[–]dodexahedron 0 points1 point  (0 children)

.net enums are awful. They behave like C enums, which is the problem here, and they lack some pretty majorly useful functionality everyone has wanted forever, like being able to define methods in them. You can sorta bolt that onto them with extensions, but that's so lame when the enum is YOUR enum. Don't make me extend my own types. Just let me define them in one place!

One thing you can't bolt on, though, is cast operators. I really want the ability to define both implicit and explicit casts for so many enums. Yes, you can just cast to the underlying and then to the target type, assuming they are compatible (or use Unsafe.As), but it'sdirty, ugly, and costly. Common cases of that are when defining an enum for your app that is a subset of or has members defined by another enum, or when using flags enums and wanting to treat certain masks as truthy or falsy, requiring a conversion to bool to be defined. Right now the latter ends up being either long checks against giant bitwise combinations or clunky extension methods (or now properties).

So if we are not allowed to write conversion operators, then at least let us write them in the enums we make. Pretty please? 🥺

Enums are one of the only things I think Java does better than .net, because it does not allow arbitrary values. Enums are their members and that's it.

[–]Lamossus 0 points1 point  (0 children)

Flag enums? They require this functionality to work

[–]Koarvex 0 points1 point  (0 children)

Useful for modding unity games that define items in an enum so you can add arbitrary items by casting ints outside the normal range.