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

        LocalFunctions();

        //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 LocalFunctions()

    {

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

        int Add(int x, int y)

        {

            var sum = x + y;

            WriteLine($"The sum of {x} and {y} is {sum}");

            return sum;

        }

​

        int Multiply(int x, int y)

        {

            var result = x * y;

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

            return result;

        }

​

        Add(20, 50);

        Multiply(20, 50);

    }

​

    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);

        }

        string stringInt = "675";

        if (int.TryParse(stringInt, out int result))

            WriteLine(result);

    }

​

    public static void EnhancedTuples()

    {

        /* previously had named members (i.e. .Item1, .Item2…)

            now Value Tuples (now structs)

            Not immutable, tuples are*/

        // Example

            var stringAndNumber = ("programming is fun", 7);

        // Name them

            var namedStringAndNumber = (word: "programming is fun", number: 7);

        // Or

            var numbers = (One:1, Two: DateTime.Now, Three: new {Pizza = "y", Toppings = "z"});

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

        /*

        var numbers2 = 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();

    }

}