Как вы видите .NET / C# 5.0?

    Совсем недавно мы получили релиз .NET / C# 4.0. Мы много говорили (и еще будем говорить) о новых возможностях и нововведениях новой платформы и языка. Но уже можно сделать какие-то выводы и подумать, что же мы хотим увидеть в новой версии .NET / C# 5.0?


    Tuple Packaging and Unpackaging


    В 4.0 появился новый тип данных Tuple, который можно использовать таким образом:

    var data = new Tuple<string,int>(“John Doe”, 42);

    Было замечательно использовать Tuple в сокращенном виде, например:

    public stringintdouble ReturnMyTuple()
    {
        return "Hello World!"424.2;
    }

    или

    public Tuple<stringintdouble> ReturnMyTuple()
    {
        return "Hello World!"424.2;
    }

    // elsewhere: item1 is a string, item2 is an int, item3 is a double. 
    var item1, item2, item3 = ReturnMyTuple();

    Enums, Generics


    Было бы хорошо передавать enums в generic методы, например:
    public void DoSomething<T>(enum) where T: System.Enum { ... }

    Еще можно сделать enums классами (как это сейчас в Java).

    А почему бы в generic методы не добавить поддержку операторов?
    T Add<T>(T a, T b)
    {
        return a + b;
    }

    In Keyword и Ranges


    Простой способ проверить входит ли переменная в определенный набор или диапазон значений:
    if (in (123)) { }
     
    if (in [5..10]) { }
     
    if (in [12, 4..8, 10]) { }

    Свойства-расширения


    Сам иногда задумывался, почему бы не сделать кроме методов-расширений еще и свойств-расширений. Т.е. вместо
    var value = someObject.Value();

    писать просто
    var value = someObject.Value;

    Умный switch


    Давайте расширим switch для поддержки выражений, условий и т.д.:
       switch (anInt)
        {
            case 12: 
                Console.WriteLine("1 or 2");
                break;
            case 3..9:
                Console.WriteLine("3 to 9");
                break;
            case >= 10:
                Console.WriteLine("10 or higher");
                break;
            default:
                …
        }
     
        switch (aString)
        {
            case "one""two":
                Console.WriteLine("1 or 2");
                break;
            case "three":
                Console.WriteLine("3");
                break;
            default:
                …
        }
     
        switch (aString)
        {
            case .IsNullOrEmpty():
                …
            case .Length > 100:
                …
            case .Contains("foo"):
                …
         }


    Кстати, VB.NET поддерживает такой синтаксис.

    Автоматические флаги у Enums


    В принципе, хорошая идея:
    [Flags]
    public enum MyFlags
    {
        Value1,   // 1
        Value2,   // 2
        ValueCombining1And2 = Value1 | Value2, // 3
        Value3,   // 4
        Value4,   // 8
        ValueCombining3And4 = Value3 | Value4 // 12    
    }

    Более продвинутая проверка на null


    Часто необходимо использовать свойство некоторого свойства объекта, что приводит к большой череде проверок. Почему бы не сделать так:
    MyClass value=null;
    int something=value.x.y ??? 0; // здесь можно использовать тройной символ ?
    //something is now 0

    Или например вместо
    var obj = Foo();
    Bar value = null;
    if(obj.Bar != null && obj.Bar.Something != null)
    {
      value = obj.Bar.Something.DoSomething();
    }
     

    писать
    var obj = Foo();
    var value = obj?.Bar?.Something?.DoSomething();

    Группировка исключений


    Ну что-то типа такого:
    try
    {
    }
    catch (ArgumentOutOfRangeException)
    catch (ArgumentNullException)
    {
       // Catch a ArgumentOutOfRangeException or a ArgumentNullException
    }
     


    Хотя что-то похожее можно делать и сейчас — обрабатывать необходимые исключения в порядке важности, а все остальные — с помощью общего Exception.

    Еще...


    Множественное наследование, виртуальные методы-расширения, возможность обрабатывать файлы с длинными именами… Вы можете поучаствовать в обсуждении этого вопроса на stackoverflow.

    А что бы вы хотели увидеть в .NET / C# 5.0 и какие из выше перечисленных идей вы хотели бы использовать?
    Поделиться публикацией

    Похожие публикации

    Комментарии 75

      +1
      >Умный switch
      может, стоит использовать паттерн Strategy или Command?
        –1
        >// elsewhere: item1 is a string, item2 is an int, item3 is a double.
        >var item1, item2, item3 = ReturnMyTuple();
        а это вообще от ПХПшников, похоже:))
        list($a, $b, $c) = mysql_fetch_row($res);
          +3
          В Nemerle и F# кортежи поддерживаются внутри языка. Синтаксис таков:

          Nemerle:
          def (x, y ,z) = GetTuple();

          F#:
          let name, age, color = get_person (… );;
            0
            Да pattern matching очень хотелось бы видеть хотя бы в таком виде.

            Кстати для Mono есть патчи, реализующие это tirania.org/blog/archive/2009/Dec-23.html
            +1
            Tuple есть во многих продвинутых языках… Даже lua позволяет возвращать два значения (хотя это и не совсем tuple).
              +1
              Это от Питона.

              def func():
              return 1, 2, 3

              a, b, c = func()
              +2
              Мне умный switch третьего типа совсем не понравился:
              switch (aString)
              {
              case .IsNullOrEmpty():

              case .Length > 100:

              case .Contains(«foo»):

              }

              Это же говнокодом попахивает, CLR для каждого case придется вызывать метод, а это уже не быстрый switch, а просто синтаксический сахар над IFами.
              +3
              Хотел бы иметь в арсенале некоторые встроенные подходы аспектно-ориентированного программирования.
                –1
                Может я отстал от времени, но чем не устраивает PostSharp?
                  +2
                  нужно читать «встроеные»
                +3
                Жду поддержку мета-программирования.
                  –18
                  >как это сейчас в Java
                  хватит слизывать все с божественного языка!
                    0
                    >>возможность обрабатывать файлы с длинными именами
                    Это случайно не os-depend функциональность?
                      +1
                      Видел список нововведений C# 4.0 Задавал себе вопрос- неужели это кому то надо?
                      В итоге понравилось, применяю.
                      Сейчас смотрю на список, что Вы предлагаете и опять тоже самое: Неужели кому то надо?
                      Интересно, примут ли эти новинки… То что предлагаете по части Tuple лично меня пугает.
                      Нет строгости как то!
                        +2
                        Отчасти согласен. Но когда-то я не мог понять зачем необходимы лямбда-выражения — они казались очень сложными и не понятными. А сейчас не знаю, чтобы без них делал.
                          +2
                          Tuple нужны. Бывает нужно вернуть два-три значения и приходится изворачиваться, чтобы выглядело красиво, а с tuples все красиво выглядит, если синтаксис не перегружен.
                            0
                            Я не спорю что Tuble нужны. Меня шокирует вот такие способы

                            public string, int, double ReturnMyTuple()
                            {
                            return «Hello World!», 42, 4.2;
                            }
                            Функция возвращающая несколько типов, не объединенных в один тип tuple на мой взгляд убивает строгость.
                              0
                              Главное, чтобы компилятор их объединял :)
                              Ведь если что местами поменять — оно же не скомпилится :) Вроде безопасно.
                                +2
                                круглые скобки спасут?

                                public (string, int, double) ReturnMyTuple()
                                {
                                return («Hello World!», 42, 4.2);
                                }
                                0
                                Часто за собой замечал, что когда возникает желание вернуть пару значений из функции, скорее всего надо возращать какую-то сущность, полями которой и будут возвращаемые значения
                                  0
                                  Кортежи (tuple) — это и есть та самя сущность, чтобы не создавать мелкий класс, который нужен только здесь и там, где вызывается. В результате получаем удобство и скорость разработки.
                                  Конечно, когда вы возвращаете Point, то нужен класс, потму что, скорее всего, потребуются какие-то методы.
                                  А когда вы возвращаете текстовое сообщение и флаг критичности сообщения, то обычно можно обойтись и кортежем.
                              +5
                              Некоторые «пожелания» очень сомнительны.
                                0
                                Как минимум мне не хватает алгебраических типов данных и pattern-matching'а.

                                Если мечтать, то хочу метапрограммирование как в Nemerle.

                                Точно известно, что можно будет использовать compiler-as-a-service, правда, благодаря ребятам из mono это возможно и сейчас.
                                  0
                                  По-моему, синтаксические красявости убивают понимание.
                                  Апофеоз краткости — это c++, в котором в одну строку можно столько всякой логики засунуть (с циклами, проверками, инкрементированием, побитовыми операциями), что смысл выполняемого кода пропадает совсем.

                                  То же касается и Ваших предложений по Tuple и var.
                                  Например, в случае
                                  var value = someObject.Value;
                                  метод без скобок — это указатель на метод, который уже сейчас можно присваивать делегату, но уж никак не вызов метода без параметров, для меня по крайней мере.
                                    –1
                                    Спасибо за комментарий, но справедливости ради нужно заметить, что моих предложений здесь нет — я всего лишь отобрал интересные, на мой взгляд, пожелания.

                                    А вот то, что можно кучу логики запихнуть в одну строку не всегда оправдано — всегда нужно сохранять компромисс между краткостью и читабельностью.
                                    0
                                    а по поводу Enum в C# — меня реализация устраивает, зато смущает реализация аннотаций в Java (они же атрибуты в C#) — через @interface.
                                      0
                                      Хочу managed компилятор и compiler as service.
                                      +9
                                      1. Множественное наследование, виртуальные методы-расширения — это адский идиотизм, убивать сразу тех, кто даже подумывает чтобы ввести это с C# или Java.

                                      2. В случае с if (x in [1, 2, 4..8, 10]) { } вы просто будете подталкивать говнокодеров к хардкоду, а не выносить параметры приложения в конфиги.

                                      3. Автофлаги приведут к неподдерживаемому коду и адской несовместимости между версиями приложения.

                                      4. про ??? я уже молчу. а чё, давайте введём ???? и ?????

                                      ну и далее по списку…

                                      из полезного я увидел только дополнительные ограничения в дженериках. вот этого да, действительно не хватает.
                                        +1
                                        Хочется тупо пометить свойство аттрибутом [NotifyPropertyChanged] и не писать в каждом set'e OnPropertyChanged(«XXX») без AOP. (synt. sugar)
                                          0
                                          Без АОР как-то некрасиво получается. Предлагаете фиксированный интерфейс жестко прошить в компилятор?
                                            0
                                            Да я какбэ просто мечтаю без задумки о реализации =)
                                              0
                                              АОП позволяет реализовать подобные вещи довольно красиво. У PostSharp есть видео, в котором все показано. АОП — это просто!
                                              Честно говоря, удивлен, что в C#4 не реализовали «нативный» АОП.
                                                0
                                                Поправлюсь — в первом комментарии я имел ввиду без стороннего АОПа 8)
                                          0
                                          Даешь компактный синтаксис для создания массивов как в Actionscript3!
                                          var array = [1,2,4,15,99];

                                          А для динамических объектов:
                                          var dynObj = {fieldValue:10, fieldText:«test»};

                                          Снять ограничения дженериков по части мат. операций.
                                          Добавить Range'ы.
                                            +2
                                            1. var array = new[] {1,2,4,15,99};

                                            3. Enumerable.Range(1, 10)
                                              0
                                              1) Я маленько неточно выразился, не массив, а аррэй/вектор, т.е. чтобы в него добавлять/удалять можно было. Ну и new[] не очень радует… Правда C# от него, скорее всего, никуда не денется. Но спасибо за вариант.

                                              3) if( a in Enumerable.Range(1,10) ) сработает?
                                                0
                                                1) Это можно уже в .Net 3.5
                                                var list = new List {1,3,4,4,5,5,6};
                                                var dict = new Dictionary { {1,2}, {2,3}};
                                                  0
                                                  Вот от List и от Dictionary бы избавиться — об этом и речь. Ведь для чего это нужно? Чтобы по месту создавать данные объекты, не писать лишнего, и чтобы это читалось хорошо, сравните:

                                                  test.SendData( new List{1,3,5} );
                                                  test.SendData( [1,3,5] );

                                                  Второй вариант приятнее гораздо.
                                                    0
                                                    А мне это как раз не нравиться.
                                                    Если SendData будет иметь кучу перегрузок:

                                                    public void SendData(object o){...}
                                                    public void SendData(List list){...}
                                                    public void SendData(ArrayList list){...}
                                                    public void SendData(int[] array){...}

                                                    или что ещё хуже
                                                    public void SendData(T data){...}
                                                    то компилятору будет сложно понять какой из этих методов надо вызывать.
                                                      0
                                                      Вроде не должно, я dynamic в C# не использовал еще, но вроде там это решается.
                                                    0
                                                    Парсер лох, съел мои генерики.
                                                    0
                                                    if (a.In(Enumerable.Range(1,10)) сработает
                                                      0
                                                      3) if( Enumerable.Range(1,10).Contains(a) ) сработает
                                                    +1
                                                    2. Есть же анонимные типы
                                                    var person = new { Name=«Мальчик», Wish=«хочет», City=«Тамбов» };
                                                      0
                                                      А этот объект можно потом куда-то передать именно как динамический и потом в другом уже классе или даже модуле обращаться к его полям?

                                                      Т.е. нечно такое:
                                                      otherObj.do( person );
                                                      Чтобы otherObj смог разобраться что там внутри? Ну и поля каждый раз разные можно передавать.
                                                        +1
                                                        Может Javascript устроит?
                                                          –1
                                                          А это ветка не про C# случаем? Причем тут javascript?
                                                          Мне в шарпе не хватает тех плюшек, что есть в Actionscript.
                                                          Про проверку на null я уже молчу:
                                                          [AS3]: if( object ) ...;
                                                          [C#] if( object != null ) ...;

                                                          Этого даже просить бессмысленно — оно не укладывается в стандарт C#.
                                                            +3
                                                            >> [AS3]: if( object ) ...;
                                                            Нафиг такой говнокод.
                                                            А если уже так нужно перегрузите оператор неявного приведения к bool
                                                              0
                                                              И что в нем плохого? Что меньше писать нужно?
                                                              Или он таит в себе опасность какую-то?
                                                              Вы не путайте опасность приведения типов и данный случай. Здесь ничего плохого произойти не может в принципе.
                                                                0
                                                                Надо чтобы было не «меньше писать», а легче читать.
                                                                  –1
                                                                  Т.е. строка
                                                                  if( obj1 != null || obj2 != null )

                                                                  читается лучше, нежели

                                                                  if( obj1 || obj2 )

                                                                  ? (при условии, что вы понимаете, что это значит)
                                                                  +1
                                                                  bool? some;
                                                                  … код… код… код…

                                                                  if (some) {} // ???? тут !null или true??
                                                                    0
                                                                    Поэтому я и сказал выше, что это не укладывается в стандарт C#.
                                                                    Именно из-за nullable типов такой синтаксис теперь сделать нельзя.
                                                                      +1
                                                                      и слава богу
                                                                  0
                                                                  От записи
                                                                  if( object1 || object2 )
                                                                  {… }

                                                                  Вы будете вообще в шоке, но при этом здесь нет приведения типов!
                                                              +1
                                                              Для таких целей служат другие языки ;) Хотя с dynamic поизвращаться можно, но я бы просто так писать не стал.
                                                                0
                                                                Я тоже год назад сказал бы, что так писать нельзя и плохо, и опасно.
                                                                А оказалось встречаются ситуации, когда это и не слишком опасно и удобно и быстро и нужно.
                                                                И C# служит ровно для тех же целей, раз он dynamic, значит можно и нужно (если, конечно, производительность не критична).
                                                                  +1
                                                                  Эээ… какбэ C# ниразу не dynamic, просто в .NET 4 ввели новый динамический тип dynamic. И ввели его руководствуясь в основном двумя причинами:
                                                                  1. Взаимодействие с COM
                                                                  2. Взаимодействие с динамическими языками на базе .NET (IronPython, IronRuby, etc.)
                                                                    0
                                                                    Правильно: новый _статический_ тип dynamic
                                                          +3
                                                          Реально не хватает группировки исплючений
                                                            0
                                                            > обрабатывать необходимые исключения в порядке важности, а все остальные — с помощью общего Exception.
                                                            Это некрасивый костыль, Pokemon Exception Handling
                                                              +4
                                                              Вижу примерно так:
                                                              sys_call:
                                                              int 0x80
                                                              ret
                                                              start:
                                                              push msg_len
                                                              push msg
                                                              push 1
                                                                0
                                                                Мне бы хотелось увеличения мощности стандартных .NET-классов, особенно, в плане математики.
                                                                Что мне очень понравилось в .NET 4.0 — это классы BigInteger и Complex. Но их можно было бы реализовать с более богатым функционалом (посмотреть хотя бы BigInteger из Java), а так же добавить много новых классов. Скажем класс BigDecimal (который, опять таки, в Java есть), класс для работы с матрицами произвольных размерностей и т.д.
                                                                  0
                                                                  попахивает оверхедом. Сделают еще один перл, будут потом девелоперы плеваться, передавая код друг-другу.
                                                                  Динамика для C# — зло.
                                                                    –5
                                                                    Я вижу его в гробу. А что?
                                                                      +1
                                                                      я правильно понимаю, что статья — вольная фантазия автора на тему синтаксиса, не имеющая никакой обратной связи с объективной реальностью?
                                                                        0
                                                                        Больше всего меня расстраивает отсутствие возможности сделать атрибут вида
                                                                        [Validator(v => v >= 10)]
                                                                        int MyProp { get; set; }

                                                                        ну или хотя бы просто генериков в атрибутах, или хотя бы адекватных параметров по умолчанию, так как те, что появились в C# 4.0 не работают с атрибутами.

                                                                        А что вы имеете в виду под автофлагами? Назначение атрибута [Flags] всем enum'ам по умолчанию? Зачем?
                                                                          0
                                                                          Вопрос про флаги снят, не заметил, что в примере явные значения элементам enum'а не задаются.
                                                                            0
                                                                            [Validator(v => v >= 10)]
                                                                            int MyProp { get; set; }

                                                                            Посмотрите в сторону DataContracts
                                                                              0
                                                                              Code Contracts? Это было бы логичным, но к ним нет доступа из reflections, а следовательно по ним невозможно сгенерироватоь соответствующие валидаторы в web application.
                                                                            0
                                                                            А Вы на Python случаем не писали? Практически половина синтаксических конструкций в нем используется.
                                                                              +1
                                                                              Extension properties были бы очень кстати — ведь в F# сделали.
                                                                                0
                                                                                все кроме автоматических флагов у Enums есть в F#.
                                                                                  0
                                                                                  Я хотел бы увидеть вложенные методы (http://pfight.wincode.org/?p=38)

                                                                                  Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.

                                                                                  Самое читаемое