C# к C#, функциям языка удобства

Если вы хотите поговорить о количестве сохраненного кода, то самыми большими сахарными запоминающими устройствами (IMO) являются те, которые вы используете:

итерационные блоки

Пример:

public static IEnumerable<int> Get() {yield return 1; yield return 2;}

сохранено:

• написание IEnumerable реализации
• написание IEnumerator реализации
• состояния обработки регистратора; видели ли вы , насколько это ужасно? Серьёзно.

захваченные переменные (анонные методы / lambdas)

Пример:

var list2 = list1.FindAll(x => (x.Value % 10) == find);

сохранен:

• написание класса для удержания состояния
  • в сложных случаях вложенное состояние
• инициализирующее обертку состояния
• пишущее метод на этом компиляторе

Expression lambda compiler

Пример (сверху):

Expression<Func<Foo,bool>> pred = x => (x.Value % 10) == find;

Сохранилось:

• yeuch - много древовидного кода; очень, очень сложный; в вышеприведенном я вижу (не в определенном порядке) Expression. Parameter, Expression.Property, Expression.Field, Expression.Constant, Expression.Equal, Expression.Modulo, Expression.Lambda... combine ;-p

используется синтаксический сахар

using(x) 
{
    ...
}

Maps to

try {
    // Code
}
finally
{
    if(x != null)
        ((IDisposable)x).Dispose();
}

From- вещь в LINQ - синтаксический сахар

from x in l where y select z;

транслируется в

l.Where(x => y).Select(x => z);

Оператор ?: , который проверяет булевое или логическое выражение и возвращает первое значение, если тест возвращает true, и второе значение, если тест возвращает false:

условие ? first_expression : second_expression

Что по сути означает:

var x;
if (condition)
{
    x = first_expression;
}
else
{
    x = second_expression
}

Используя оператор ?:, можно записать int x = условие ? 10 : 20; вместо того, чтобы записывать целое оператор if.

Анонимные типы:

var message = new { Message = "Hello, world!", MessageID = 1 };

переведено на

<>f__AnonymousType0<string, int> message =
    new <>f__AnonymousType0<string, int>("Hello, world!", 1);

где

[CompilerGenerated]
[DebuggerDisplay(
    @"\{ Message = {Message},
    MessageID = {MessageID} }",
    Type="<Anonymous Type>"
 )
]
internal sealed class <>f__AnonymousType0<
    <Message>j__TPar,
    <MessageID>j__TPar
> {
    // Fields
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly <Message>j__TPar <Message>i__Field;
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly <MessageID>j__TPar <MessageID>i__Field;

    // Methods
    [DebuggerHidden]
    public <>f__AnonymousType0(
        <Message>j__TPar Message,
        <MessageID>j__TPar MessageID
    ) {
        this.<Message>i__Field = Message;
        this.<MessageID>i__Field = MessageID;
    }

    [DebuggerHidden]
    public override bool Equals(object value) {
        var type = value as <>f__AnonymousType0<
            <Message>j__TPar,
            <MessageID>j__TPar
        >;
        return (((type != null) && 
            EqualityComparer<<Message>j__TPar>.Default.Equals(
                this.<Message>i__Field, 
                type.<Message>i__Field)
            ) &&
            EqualityComparer<<MessageID>j__TPar>.Default.Equals(
                this.<MessageID>i__Field,
                type.<MessageID>i__Field)
            );
    }

    [DebuggerHidden]
    public override int GetHashCode() { 
        int num = 0x2e22c70c;
        num = (-1521134295 * num) +
            EqualityComparer<<Message>j__TPar>.Default.GetHashCode(
                this.<Message>i__Field
            );
        return ((-1521134295 * num) +
            EqualityComparer<<MessageID>j__TPar>.Default.GetHashCode(
                this.<MessageID>i__Field)
            );
    }

    [DebuggerHidden]
    public override string ToString() {
        StringBuilder builder = new StringBuilder();
        builder.Append("{ Message = ");
        builder.Append(this.<Message>i__Field);
        builder.Append(", MessageID = ");
        builder.Append(this.<MessageID>i__Field);
        builder.Append(" }");
        return builder.ToString();
    }

    // Properties
    public <Message>j__TPar Message {
        get {
            return this.<Message>i__Field;
        }
    }

    public <MessageID>j__TPar MessageID {
        get {
            return this.<MessageID>i__Field;
        }
    }
}

Выражения лямбды - еще один пример.

var myZombies = myMonsters.Where(monster => monster.Kind == MonsterKind.Zombie);

вытягивает делегата лямбда в свой собственный метод со странным названием.

Вы можете использовать рефлектор и переключаться между версиями на C# в диалоге опций, чтобы увидеть различия в том, как такие вещи будут разрешаться.

Методы расширения.

Если это метод расширения:

static class ObjectExtensions
{
    public void ExtensionMethod(this object obj)
    {
        // Do something here...
    }
}

И вы вызываете obj.ExtensionMethod()

Он преобразует в:

ObjectExtensions.ExtensionMethod(obj)

Если у вас случайно есть версия C# компилятора, поддерживающая методы расширения, вы можете обманом заставить компилятор разрешить использовать методы расширения в версиях .Net до 3. 5, создав System.Runtime.CompilerServices.ExtensionAttribute, вот так: (Это совершенно безопасно, так как компилятор отображает методы расширения в стандартную IL)

namespace System.Runtime.CompilerServices
{
    using System;

    internal sealed class ExtensionAttribute : Attribute
    {
    }
}

LINQ в целом (особенно с использованием синтаксиса запроса LINQ), по сути, является основным C # /. Чистая функция удобства, которая заменяет логику для петель / итераторов / комплексной логики.

Инициализации объекта являются довольно синтаксическим сахаром:

 public class Book
{
 public string Author { get; set; }
 public string Title { get; set; }
}

Book book = new Book() {Author = "John Smith", Title = "C# Syntax"};

Вышеупомянутый это еще один способ написать:

Book book = new Book();
book.Author = "John Smith";
book.Title = "C# Syntax";

Неявные типы:

var book = new Book() {Author = "John Smith", Title = "C# Syntax"};

1. для , , в то время как , , ... в то время как , выключатель - противоречивый ответ :)

   Вы можете заменить его некоторым кодом, основанным на , если и GOTO .

2. Блокировка () {} может быть переведено на Monitor.enter () и Monitor.exit () в TRY - наконец-то с проверкой нулевой проверки (см. . Это? )