OneOf

You can write very functional C#. Our codebase is a mix with some aspects being functional (`ErrorOr`[0] being a big part of it as well as `OneOf`[1]) and OOP. Our core, common services all return `ErrorOr` to allow fluent call chaining at the top of the stack (controllers). Modern C# features like `switch` expressions[2] (not `switch-case`) and pattern matching mean that it is possible to write very terse, expressive code. Extension members and methods[3] go a long way as well by making the builder pattern easier to implement. Overall, it's up to the team to make use of the tools provided by the C# team. You can write C# in a very OOP heavy way (as is possible with TS in the case of Nest.js); you can also write in in a very functional way given many of the functional features adopted from F# over the years. It's up to the team. [0]

That is tedious with or without a source generator, mainly because there's a much better way to do it: public Optional<string> Name; With Optional being something like: class Optional<T> { public T? Value; public bool IsSet; } I'm actually partial to using IEnumerable for this, and I'd reverse the boolean: class Optional<T> { public IEnumerable<T> ValueOrEmpty; public bool IsExplicitNull; } With this approach (either one) you can easily define Map (or "Select", if you choose LINQ verbiage) on Optional and go delete 80% of your "if" statements that are checking that boolean. Why mess with source generators? They're just making it slightly easier to do this in a way that is really painful. I'd strongly recommend that if you find yourself wanting Null to represent two different ideas, then you a

I think people who last looked at C# 10 years ago or haven't adapted to new language features seriously don't know how good C# is these days. Switch expressions with pattern matching are absolutely killer[0] for its terseness. Also, it is possible to use OneOf[1] and Dunet[2] to get access to DU [0] https://timdeschryver.dev/blog/pattern-matching-examples-in-... [1] https://github.com/mcintyre321/OneOf [2] https://github.com/domn1995/dunet

I just glanced at the page, so I might be off, but to me it looks like this is only a solution for the special case of exceptions? Why would I want to use this instead of a more general approach to discriminated unions, eg. like: https://github.com/mcintyre321/OneOf If I would use your library I would need a separate solution for every other case. Take care, Martin

While we wait for the official discriminated union feature, the OneOf package is a pretty good stand-in: https://github.com/mcintyre321/OneOf

There's also OneOf (https://github.com/mcintyre321/OneOf) as well which feels more ergonomic to me (having used both). Practical example in a short write up here: https://chrlschn.dev/blog/2024/07/csharp-discriminated-union...

You can largely already pretty easily incorporate DUs using OneOf[0] and Dunet[1]. A practical example of using this: https://chrlschn.dev/blog/2024/07/csharp-discriminated-union... [0] https://github.com/mcintyre321/OneOf [1] https://github.com/domn1995/dunet

This[0] lib implements F#-style discriminated unions. The way I've used it is to make my outer layers return "Result" types that wrap the DTO, error, etc. under one umbrella. It allows for pattern matching your results which makes error handling easier and also allows your models to evolve over time without changing your function signatures at the edge. [0] https://github.com/mcintyre321/OneOf

It's possible to add DUs in C# today with some third party packages. - https://github.com/domn1995/dunet - https://github.com/mcintyre321/OneOf Quite good and ergonomic with the source generators removing a lot of the boilerplate. I have a practical example here using OneOf with .NET Channels: https://chrlschn.dev/blog/2024/07/csharp-discriminated-union...

> Would you recommend going in with .NET Core/Vscode/EF Core on macOS today, if you were to start a fresh backend project? "It depends". I also do a lot of work with Firebase and there, I prefer doing backend using TypeScript and Node on Cloud Functions. The front-end integration is really tight and Firebase is designed to work that way as a stack. That said, I'll still develop pure back-end workloads (e.g. async jobs) alongside my Firebase stack using C# and deploy into Cloud Run Jobs. If you're building a pure backend, I'd choose .NET 8 with confidence because the overall DX feels better than Node to me. EF Core is really, really good; I prefer it to Prisma and the handful of alternatives on Node for relational DBs. I think .NET gives senior devs more "reach" (while still being approachable for junior devs) because it is multi-th

Until that feature lands there's this https://github.com/mcintyre321/OneOf which is pretty nice.

DU is available in C# via packages like OneOf and Dunet. Dunet is really good. https://github.com/mcintyre321/OneOf https://github.com/domn1995/dunet It's on the roadmap and will arrive at some point: https://github.com/dotnet/csharplang/blob/main/proposals/dis...

Agree. For now, you can get a reasonable DU via an [external library](https://github.com/mcintyre321/OneOf). [Nick Chapsas Video on Usage](https://www.youtube.com/watch?v=7z-xjijYfcI).

C# can be much better, or it can be much the same. It depends on which implementation you use. Standardisation is an issue here, the system library has the "Nullable<T>" struct (1), but not a standard Result<T, E> class (or struct). Popular libraries such as "OneOf" use a class type. The single-valued "OneOf" type is effectively an "Option<T>" (2) Nullable<T> itself is not exactly the same as Option<T> since it does not cover types that already allow nulls. It adds nulls rather then removing them. Many people roll their own Option<T> or Result<T,E> type, since it's easy enough to start, and it's usually a class type. 1) https://learn.microsoft.com/en-us/dotnet/api/system.nullable... 2) https://github.com/mcintyre321/OneOf/blob/master/OneOf/OneOf...