Синтаксический сахар C#

Синтаксический сахар – довольно полезный инструмент для программиста, несмотря на столь пренебрежительно-гламурное название. Для начала, что вообще такое «синтаксический сахар»? Стандартная википедия дает такое определение: «Синтаксический сахар – синтаксические возможности, применение которых не влияет на поведение программы, но делает использование языка более удобным для человека». Вообще, насчет применения синтаксического сахара существует множество противоположных мнений. Кто-то скажет, что это очень мощная штука, облегчающая жизнь, а кто-то возразит, что это излишество, к тому же, мешающее думать.

На самом же деле синтаксический сахар это способ представить длинный код в боле компактном, лаконичном и читабельном виде. Рассмотрим ряд примеров.

Тернарный оператор. Допустим, у нас есть некоторое условие, в зависимости от которого мы присваиваем значение переменной:

 

        static void Main(string[] args)
        {
            int val = 1;
            string my_var="Число ";
            if (val > 0)
            {
                my_var = my_var + "положительное";
            }
            else
            {
                my_var = my_var + "отрицательное";
            }
            Console.WriteLine(my_var);
            Console.ReadLine();
        }

Благодаря тернарному оператору, весь код можно записать короче:

        static void Main(string[] args)
        {
            int val = 1;
            string my_var="Число ";
            my_var = my_var + (val > 0 ? "положительное" : "отрицательное");
            Console.WriteLine(my_var);
            Console.ReadLine();
        }

Операции +=,-=,*=,/*. На самом деле и этот код можно сократить:

        static void Main(string[] args)
        {
            int val = 1;
            string my_var="Число ";
            my_var += (val > 0 ? "положительное" : "отрицательное");
            Console.WriteLine(my_var);
            Console.ReadLine();
        }

Краткая проверка на null. В данном примере на null переменная проверяется условным оператором:

namespace Sugar1
{
    public class MyClass
    {
        public void some_method()
        {
            Console.WriteLine("Calling some_method");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass a = null;
            if(a!=null)
            {
                a.some_method();
            }         
            Console.ReadLine();
        }
    }
}

Сокращенный вариант:

    public class MyClass
    {
        public void some_method()
        {
            Console.WriteLine("Calling some_method");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass a = null;
            a?.some_method();
            Console.ReadLine();
        }
    }

Замечу, что в старых версиях C#, например в той версии, которая в Visual Studio 2010 данный синтаксис не работает. В версии Visual Studio 2015 Он уже есть. В промежуточных – не знаю, не проверял.

Кто-то, возможно, спросит, для чего делать проверку на null? А для того, чтобы программа не вылетела с исключением, так как у не инициализированного указателя мы не можем вызвать метод – объекта то еще не существует.

Псевдонимы. Предположим, что у нас сесть тип со множеством вложенных нэймспейсов, например вот такой Domen.Submomen.SubSubDomen.MyClass, см пример:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace sugar2
{
    class Program
    {
        static void Main(string[] args)
        {
            Domen.Submomen.SubSubDomen.MyClass a = new Domen.Submomen.SubSubDomen.MyClass();
            a.some_methon();
            Console.ReadLine();
        }
    }
}

Можно сделать код более лаконичным, введя псевдоним:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyClassAlias = sugar2.Domen.Submomen.SubSubDomen.MyClass;

namespace sugar2
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClassAlias a = new MyClassAlias();
            a.some_methon();
            Console.ReadLine();
        }
    }
}

Переменное число аргументов. Очень удобно, когда в функции можно указать любое число аргументов, например, для вывода их на печать (как команда print в старом добром бэйсике), или, например, просуммировать эти аргументы. C# позволяет подобные выкрутасы. Правда, все аргументы типизированы, но это можно обойти, елси тип сделать object. Давайте рассмотрим парочку примером. Сначала суммирование:

 

        static int sum(params int[] numbers)
        {
            int res = 0;
            foreach (int a in numbers)
            {
                res += a;
            }
            return res;
        }

Функция суммирует аргументы типа int. Пример использования:

            Console.WriteLine(sum(1, 2, 3));
            Console.WriteLine(sum(8, 1, 1,5));

А вот функция с любым типом аргументов (выводит на печать):

        static void print(params object[] objs)
        {
            foreach (object a in objs)
            {
                Console.Write(a);
            }
        }

Пример использования:

print(1, " число равно=", 2.3);

Перечисление флагов. Очень интересная возможность. Есть в C# такая конструкция, как перечисления, которая позволяет задавать именованные числовые константы. Например:

    public enum Color
    {
        Red,
        Yellow,
        Green
    }

Теперь, если нам надо закодировать, например, красный цвет, мы можем обратиться к Colors.Red:

Colors color = Colors.Red;

А потом проверить его, например, в операторе условия или в свитче:

            switch (color)
            {
                case Colors.Red:
                    Console.WriteLine("Красный");
                    break;
                case Colors.Green:
                    Console.WriteLine("Зеленый");
                    break;
                case Colors.Yellow:
                    Console.WriteLine("Желтый");
                    break;
            }

Но мало кто знает, что можно сделать перечисления флагов. Например, вот так:

    [Flags]
    public enum MyFlags
    {
        flag1=0x0,
        flag2=0x1,
        flag3=0x2,
        flag4 = 0x4
    }

Как с ними работать? Например, вот так:

            MyFlags a = (MyFlags)3;
            Console.WriteLine(a);

Программа выдаст:

flag2, flag3

Очень легко проверить наличие флага, используя метод HasFlag:

            Console.WriteLine(a.HasFlag(MyFlags.flag3));
            Console.WriteLine(a.HasFlag(MyFlags.flag4));