A bit of background. .NET has value types and reference types. Value types such as INT can not ever be null. If you type int myInt = null then you will get a compile time error .NET then introduced nullable value types allowing you to create something like int? myInt , and the compiler will force you to check if it is null before you can use it. Since any reference type could always be null there was no way to ever force them not to be null, and any usage could result in the dreaded "Object reference not set to an instance of an object" exception.

.NET core version 3 added support for C#8's Nullable reference types. To enable these project wide you would add the following to your csproj file

  <PropertyGroup>    
    <Nullable>enable</Nullable>    
    <LangVersion>8</LangVersion>
  </PropertyGroup>

This would force the compiler to also consider all reference types as non nullable unless specified with a "?" but this often meant either some dirty workarounds (public string Name { get; set; } = null!;) or lots of boilerplate. e.g. to make the following POCO (plain old class object) null safe

class MyPoco
{
    public string Name { get; set; } 
    public Address Address { get; set; }
}

We would need add more boilerplate code and always force it to be populated from a constructor

  class MyPoco
  {
      public MyPoco(string name, Address address)
      {
          Name = name;
          Address = address;
      }

      public string Name { get; set; } 
      public Address Address { get; set; }
  }

Finally .NET 7 with C# Language version 11 introduced the required attribute!

We can now simply write:

  class MyPoco
  {
      public required string Name { get; set; } 
      public required Address Address { get; set; }
  }

And the compiler will force us to populate all the required fields

How do you test something with time, and you don't want to inject an ITime, resulting in dependencies heavy code?

public string GetGreeting()  
    {
        var response = "Good " + (DateTime.Now.Hour < 12 ? "morning!" : "afternoon!");
        return response;
    }

Simple, use a functional delagate where you can replace the implementation.

public static class DateTimeProvider  
{
    public static Func<DateTime> Now = () => DateTime.Now;
}

public class Worker  
{
    public string GetGreeting()
    {
        var response = "Good " + (DateTimeProvider.Now().Hour < 12 ? "morning!" : "afternoon!");
        return response;
    }
}

And now it is testable!

[Theory]
[InlineData("2060-10-1 00:00:00", "morning")]
[InlineData("2060-10-1 11:59:59", "morning")]
[InlineData("2060-10-1 12:00:00", "afternoon")]
public void TestGreeting(string forDate, string expect)  
{
    DateTimeProvider.Now = () => DateTime.Parse(forDate);
    var sut = new Worker();
    var greeting = sut.GetGreeting();
    Assert.Contains(expect, greeting);
}