// Read about this and other fiddles on .NET Fiddle Newsletter https://dotnetfiddle.substack.com/

//

// This fiddle demonstrates new features of C# 9.0 included in .NET 5.0

​

using System;

​

public class Program

{

    public static void Main()

    {

        //IMMUTABLE RECORDS

        //Records  make it easy to create immutable reference types in .NET. Immutable means "unchanging".

        //Some advantages of immutable classes are: always thread safe, easier to test, no need to worry about them changing accidently

        TestRecords();

        //INIT ONLY SETTERS

        //Init only setters can be used instead of "set" on properties to allow to initialize the property value

        //but keep it readonly (unchangeable) after that.

        TestInitOnlySetters();

        //IMPROVED PATTERN MATCHING 

        //Quest for shortening switch statements, until they fully disappear, continues

        TestImprovedPatternMatching();

        //TARGET TYPE NEW

        //When declaring classes using new you don't need to specifcy class name on right side if it is already declared on the left

        TestTargetTypeNewExpression();

        //COVARIANT RETURNS

        //Return derived classes from overriden methods

        //For ex.  CustomerService.Create can return Customer while override VipCustomerService.Create can return VipCustomer

        TestCovariantReturns();

    }

    public static void WriteHeading(string heading, string description)

    {

        Console.WriteLine("\n\n====================================================");

        Console.WriteLine(heading);

        Console.WriteLine(description + "\n");

    }

    //====================================

    //Immutable records

    public static void TestRecords()

    {

        WriteHeading("Immutable Records", "An easy way for immutable structures");

        var customer1 = new CustomerRecord("Ahnold", "S1");

        var customer2 = customer1 with {LastName = "S2"};  //This copies customer1 record and initalizes LastName to S2.  Note that LastName has set; modifier for this to work.

        var customer1Copy = customer1; //This makes full copy of customer1 record, not just a reference

        if (customer1 != customer2)

            Console.WriteLine("Customer1 is not same as Customer2");

        if (customer1 == customer1Copy)

            Console.WriteLine("Customer1 is same as Customer1Copy");

    }

    public record CustomerRecord

    {

        public string FirstName {get;}

        public string LastName {get; set;}

        public CustomerRecord(string firstName, string lastName) => (FirstName, LastName) = (firstName, lastName);

    }

    //====================================

    //Init only setters

    public static void TestInitOnlySetters()

    {

        WriteHeading("Init Only Setters", "Define property that can be set during class initialization, but read-only after that");

        Console.WriteLine("Uncomment line 88 to see that Init Only properties can't be changed after init.  Note that the error occurs in compile time.");

        var customer = new CustomerWithInitName{ FirstName="Boris", LastName="Johnson",  Age = 45};

        //Uncomment this line to see compiler error that FirstName can't be edited after initalization

        //customer.FirstName = "Borya";

​

        //Age on the other hand is editable

        customer.Age += 10;

    }

    public class CustomerWithInitName

    {

        public string FirstName {get; init;}

        public string LastName {get; init;}

        public int Age {get; set;}

    }

​

    //====================================

    //Improved pattern matching

    public static void TestImprovedPatternMatching()

    {

        WriteHeading("Improved Pattern Matching", "Pattern matching introduced in C# 8 has been further expanded");

        var customer = new Customer { FirstName = "D", LastName = "Trump", Age = 74 };

​

         var ageGroup =  customer.Age switch

         {

                 <= 20          => AgeGroup.Young,

                 > 20 and <= 50 => AgeGroup.Adult,

                 > 50           => AgeGroup.Old

         };

        FiddleHelper.Dump(customer);

        Console.WriteLine("\nThis customer belongs to Age Group: " + ageGroup);

    }

    public enum AgeGroup

    {

        Young,

        Adult,

        Old

    }

    //====================================

    // Target type new expression

    public static void TestTargetTypeNewExpression()

    {

        WriteHeading("Target Type New", "Instantiating new class does not require repeating class name on right side");

        Customer customer = new() { FirstName = "J", LastName = "Biden", Age = 78 };

        FiddleHelper.Dump(customer);

    }

    public class Customer

    {

        public string FirstName {get; set;}

​

        public string LastName {get; set;}

​

        public int Age {get; set;}

    }

    //=======================================

    //Covariant returns

    public static void TestCovariantReturns()

    {

        WriteHeading("Covariant Returns", "Override of a method can now return a more derived return type than the method it overrides");

        var customerService = new CustomerService();

        Customer customer = customerService.Create();

        var vipCustomerService = new VipCustomerService();

        VipCustomer vipCustomer = vipCustomerService.Create();

        Console.WriteLine("customer is of type: " + customer.GetType().Name);

        Console.WriteLine("vipCustomer is of type: " + vipCustomer.GetType().Name);

    }

    public class VipCustomer : Customer

    {

        int NumOfBling {get; set;}

    }

​

    public class CustomerService

    {

        public virtual Customer Create()

        {

            return new Customer();

        }

    }

    public class VipCustomerService : CustomerService

    {

        public override VipCustomer Create()

        {

            return new VipCustomer();

        }

    }

}