using System;

using System.Collections.Generic;

using System.Linq;

using static System.Console;

​

//C# 7 is coming soon in VS 2017

//Try out some of the new features without having to install VS 2017 RC

​

//Source 1: http://www.c-sharpcorner.com/article/top-10-new-features-of-c-sharp-7-with-visual-studio-2017/

//Source 2: https://docs.microsoft.com/en-us/dotnet/articles/csharp/csharp-7

​

public class Program

{

    public static void Main()

    {

        //Small helper functions available only in the scope of parent function

        NestedFunctions();

        //Declare binary literals

        BinaryLiterals();

        //Declare out variable inside the method call

        OutVariables();

        //Declare tuples inline

        EnhancedTuples();

        //Access tuple members directly without using tuple name

        TupleDeconstruction();

        //Use expression bodied methods for properties, constructor and distructor

        ExpressionBodiedMembers();

        //Check for variable type in switch cases

        SwitchExpressions();

        //You can now throw exceptions inline in conditional expressions, null coalescing expressions, and some lambda expressions

        ThrowExceptionsInExpressions();

    }

​

    public static void NestedFunctions()

    {

        WriteFeatureHeader("Nested functions", "Small helper functions available only in the scope of parent function");

        void Add(int x, int y)

        {

            WriteLine($"Sum of {x} and {y} is : {x + y}");

        }

​

        void Multiply(int x, int y)

        {

            WriteLine($"Multiply of {x} and {y} is : {x * y}");

            Add(30, 10);

        }

​

        Add(20, 50);

        Multiply(20, 50);

    }

​

    public static void BinaryLiterals()

    {

        WriteFeatureHeader("Binary Literals", "Declare binary literals");

        //Represent 50 in decimal, hexadecimal & binary  

        int a = 50; // decimal representation of 50  

        int b = 0X32; // hexadecimal representation of 50 

        int c = 0B110010; //binary representation of 50  

        //Represent 100 in decimal, hexadecimal & binary  

        int d = 50 * 2; // decimal represenation of 100   

        int e = 0x32 * 2; // hexadecimal represenation of 100 

        int f = 0b110010 * 2; //binary represenation of 100  

        WriteLine($"a: {a: 0000} b: {b: 0000} c: {c: 0000}");

        WriteLine($"d: {d: 0000} e: {e: 0000} f: {f: 0000}");

    }

​

    public static void OutVariables()

    {

        WriteFeatureHeader("Enhanced Out Variables", "Declare out variable inside the method call");

        string s = "26-Nov-2016";

        if (DateTime.TryParse(s, out DateTime date))

        {

            WriteLine(date);

        }

    }

​

    public static void EnhancedTuples()

    {

        WriteFeatureHeader("Enhanced Tuples", "Declare tuples inline");

        var numbers = new List<int>{5, 10, 45, 23};

        var aggregate = Aggregate(numbers);

        Console.WriteLine($"Count: {aggregate.count}, Sum: {aggregate.sum}, Avg: {aggregate.avg}");

    }

​

    static (int count, int sum, double avg)Aggregate(IEnumerable<int> numbers)

    {

        int count = numbers.Count();

        int sum = numbers.Sum();

        double avg = (double)sum / (double)count;

        return (count, sum, avg);

    }

​

    public static void TupleDeconstruction()

    {

        WriteFeatureHeader("Tuple Deconstruction", "Access tuple members directly without using tuple name");

        var numbers = new List<int>{5, 10, 45, 23};

        (int count, int sum, double avg) = Aggregate(numbers);

        Console.WriteLine($"Count: {count}, Sum: {sum}, Avg: {avg}");

    }

​

    public static void ExpressionBodiedMembers()

    {

        WriteFeatureHeader("Expression Bodied Members", "Use expression bodied methods for properties, constructor and distructor");

        var customer = new Customer();

        customer.FirstName = " Joe";

        customer.LastName = "     Doe ";

        Console.WriteLine($"Customer Name: {customer.FullName}, Country: {customer.Country}");

    }

    public static void SwitchExpressions()

    {

        WriteFeatureHeader("Switch Expressions", "Check for variable type in switch cases");

        List<object> values = new List<object>

        {

            0,

            1,

            new List<object>

            {

                2, 3, 4 

            },

            new List<object>(),

            null,

            5,

            6

        };

        int sum = Sum(values);

        Console.WriteLine($"Sum is {sum}");

    }

​

    public static int Sum(IEnumerable<object> values)

    {

        var sum = 0;

        foreach (var item in values)

        {

            switch (item)

            {

                case 0:

                    break;

                case int val:

                    sum += val;

                    break;

                case IEnumerable<object> subList when subList.Any():  //use when to add extra switch condition

                    sum += Sum(subList);

                    break;

                case IEnumerable<object> subList:

                    break;

                case null:

                    break;

                default:

                    throw new InvalidOperationException("unknown item type");

            }

        }

        return sum;

    }

​

    class Customer

    {

        //Expression bodies constructor

        public Customer() => Country = "USA"; 

​

        //Expression bodied destructor

        ~Customer() => Console.WriteLine("Customer terminated..."); 

​

        private string _firstName;

        public string FirstName

        {

            get => _firstName;   //Use expression bodies methods for get/set

            set => _firstName = value.Trim();

        }

​

        private string _lastName;

        public string LastName

        {

            get => _lastName;

            set => _lastName = value.Trim();

        }

​

        public string Country

        {

            get;

        }

​

        private string _fullName;

        public string FullName  =>  $"{FirstName} {LastName}" ; 

    }

​

    public static void ThrowExceptionsInExpressions()

    {

        WriteFeatureHeader("Throw Exceptions in Expressions", "You can now throw exceptions inline in conditional expressions, null coalescing expressions, and some lambda expressions");

        try

        {

            var a = Divide(10, 0);  

        }

        catch (DivideByZeroException e)

        {

            Console.WriteLine($"Caught exception: {e.Message}");

        }

    }

    public static double Divide(int x, int y) 

    {  

        return y != 0 ? x % y : throw new DivideByZeroException();  

    }  

​

    public static void WriteFeatureHeader(string name, string description)

    {

        Console.WriteLine();

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

        Console.WriteLine($"{name}".ToUpper());

        Console.WriteLine($"{description}");

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

        Console.WriteLine();

    }

}