I started with C# in the .NET Framework 1.1 days.
It has changed a lot since then (obviously) but recent events have made me realize just how long I have been holding onto my old-school development patterns.
Here is my list of things I am proactively going to learn about:
- Pattern matching
- Target-typed new()
- Covariant return types
- Local functions
- Nullable reference types
- Null conditional operators
- Anything Linq
I still write Data Transfer Objects (DTO) and sometime name them that. This is from my J2EE days.
Properties may have replaced getter and setter methods and calling it a model doesn't change the fact it is just data.
I need to look into records.
because I still use
if..then..else. After watching a video recently from @ShawnWildermuth I realize just how outdated some of my language patterns are.
Pattern matching look powerful and I've just been lazy in this regard.
This one holds potential b/c I prefer to initialize all of my class members in the constructor for debugging purposes.
They are class members so
var is not an option. Less typing and letting the compiler figure it out is a win.
Covariant return types
this is more of a knowing thing to keep in my back pocket. I have created tuples to return things like this before. It works but this may be better.
They seem like a frivolous thing but maybe they are not. My initial take on them was for reducing complexity in longer functions. I did not see any real benefit over a private method.
Nullable reference types
This is the default now. I don't think about it much and I get caught by the compiler a lot. I am also using
<warningsaserrors>Nullable</warningsaserrors> so I don't miss out on the fun.
Null conditional operators
I use null coalescing when checking parameters but that is pretty much it. Time to up my null check game now that I am committing to the warning as errors setting.
Honestly I hate Linq. I don't know why but I avoid it all of the time. It might be time to get some solid Linq knowledge under my belt.