public class Person
    {
        public string FirstName { get; set; }
    }

    public class PersonWithCtor
    {
        public PersonWithCtor(string firstName)
        {
            this.FirstName = firstName;
        }

        public string FirstName { get; set; }
    }

Person person = new Person();

var person = new Person();

Person person = new();

Person person = new("User 1");

var personList = new List<Person>
        {
            new ("User 1"),
            new ("User 2"),
            // ...
        };

public void Adopt(Person p)
{
    //...
}

public void CallerMethod()
{
    this.Adopt(new Person("User 1"));
    // C# 9.0
    this.Adopt(new("User 1"));
}

XmlReader.Create(reader, new XmlReaderSettings() { IgnoreWhitespace = true });
// C# 9.0
XmlReader.Create(reader, new() { IgnoreWhitespace = true });

Person person = new
{
   FirstName = "User 2"
};

Person person = new()
{
   FirstName = "User 2"
};

private ConcurrentDictionary<string, ObservableList<Cat>> _catsBefore = new ConcurrentDictionary<string, ObservableList<Cat>>();

private ConcurrentDictionary<string, ObservableList<Cat>> _cats = new(); // C# 9.0

public ObservableCollection<Friend> Friends { get; } = new();

public interface IAnimal
{
}

public class Dog : IAnimal
{
}

public class Cat : IAnimal
{
}

Cat cat = null;
Dog dog = new();
IAnimal animal = cat ?? dog;

(int a, int b) t = new(1, 2); // "new" is redundant

(int a, int b) t = new(); // OK; same as (0, 0)

public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                .AddEnvironmentVariables();
            Configuration = builder.Build();
        }

public IConfiguration Configuration { get; }

public Startup(IConfiguration configuration)
{
     Configuration = configuration;
}

public static void Main(string[] args)
        {
            BuildWebHost(args).Run();
        }

        public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .Build();

public static IWebHost BuildWebHost(string[] args)
{
  return WebHost.CreateDefaultBuilder()
    .ConfigureAppConfiguration((ctx, cfg) =>
    {
      cfg.SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("config.json", true) // require the json file!
        .AddEnvironmentVariables();
    })
    .ConfigureLogging((ctx, logging) => { }) // No logging
    .UseStartup<Startup>()
    .Build();
}

static void Main(string[] args)
{
  MainAsync().GetAwaiter().GetResult();
  Console.ReadLine();
}

private static async Task MainAsync()
{
   using (StreamReader reader = File.OpenText("Program.cs"))
   {
       var message = await reader.ReadToEndAsync().ConfigureAwait(false);
       Console.Write(message);
   }
}

static async Task Main(string[] args)
{
   using (StreamReader reader = File.OpenText("Program.cs"))
   {
      var message = await reader.ReadToEndAsync().ConfigureAwait(false);
      Console.Write(message);
   }
   Console.ReadLine();
}

using System;
using System.IO;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
namespace ConsoleCS71
{
    internal class Program
    {
        private static async Task Main(string[] args)
        {
            StreamReader reader = File.OpenText("message.txt");
            try
            {
                string str = await reader.ReadToEndAsync();
                string message = str;
                str = (string)null;
                Console.Write(message);
                message = (string)null;
            }
            finally
            {
                if (reader != null)
                    reader.Dispose();
            }
            reader = (StreamReader)null;
            Console.ReadLine();
        }
        [SpecialName]
        private static void <Main>(string[] args)
        {
          Program.Main(args).GetAwaiter().GetResult();
        }
    }
}

namespace ConsoleApp5
{
    class Class1
    {
        static void Main(string[] args)
        {
        }
    }

    class Class2
    {
        static void Main(string[] args)
        {
        }
    }
}