C# делегаты и анонимные функции

#c_sharp #делегаты #анонимная_функция

Имеется следующий блок кода : 

delegate int StrMod(int a);
static void main()
{
StrMod strmod = delegate{return 10;};
Console.WriteLine(strmod(5));
}


Консоль:


  10


Почему на 4 строку компилятор не ругается? Ведь входные параметры анонимной функции
не соответствуют параметрам делегата.
    

Ответы

Ответ 1

Вы здесь объявляете делегат с помощью анонимного метода.

StrMod strmod = delegate{return 10;};


Согласно документации об анонимных методах, у анонимного метода допускается опускать
список параметров, если они вам не нужны внутри метода(в отличии от лямбд выражений,
где список параметров нужно указывать всегда явно). В этом случае, анонимный метод
может быть преобразован к делегату с различной сигнатурой. 


  Anonymous methods enable you to omit the parameter list. This means
  that an anonymous method can be converted to delegates with a variety
  of signatures.


Поэтому этот код компилируется успешно.

Ко/контрвариантность у делегата

#c_sharp #делегаты

Есть такой делегат

delegate void Del(string z);


И ему присваивается метод 

public void Foo(object z)
{

}


Присваивание происходит нормально, за счет вариантности. Однако если в параметре
делегата стринг поменять на int тогда компилятор уже возмущается. Почему ? Полагаю,
что это как-то связано с ссылочным/структурным типом. Но ведь все они идут от object
    

Ответы

Ответ 1

Вы правы, вариантность делегатов ограничена ссылочными типами.

Вот нормативная цитата из C# language reference (лежит в \VC#\Specifications\1033\CSharp
Language Specification.docx), раздел 15.2 (перевод мой):

15.2 Совместимость делегатов

Метод или делегат M называется совместимым с делегатным типом D, если выполняются
следующие условия:


У D и M одинаковое количество параметров, и каждый параметр в D имеет одинаковые
модификаторы ref/out, как и соответствующий параметр в M.
Для каждого параметра, не содержащего ref/out, существует тождественное преобразование
(§6.1.1) или неявное ссылочное преобразование (§6.1.6) из типа параметра в D в тип
соответствующего параметра в M.
Для каждого ref-/out-параметра, тип параметра в D в точности тот же, что и в M.
Существует тождественное или неявное ссылочное преобразование из возвращаемого типа
в M к возвращаемому типу в D.




Это значит, что типы параметром должны быть либо одинаковы (с точностью до разницы
между object и dynamic), либо тип параметра должен быть ссылочным подтипом типа параметра
в D. Это исключает значимые типы.

Групповые делегаты

#c_sharp #делегаты

Action a1 = () => Console.Write(1); 
Action a2 = () => Console.Write(2); 
Action a3 = () => Console.Write(3); 
((a1 + a2 + a3) - (a1 + a2))(); 
((a1 + a2 + a3) - (a1 + a3))();


Увидел данный пример и стало интересно. Как в данном случае отрабатывает удаление
делегата. Что происходит при (a1 + a2) и (a1 + a3), и почему первый вариант удаляет
как надо а второй не срабатывает вовсе?
    

Ответы

Ответ 1

Пускай a1 + a2 + a3 превращается в делегат, который условно обозначим [a1, a2, a3],
a1 + a2 -- [a1, a2], a1 + a3 -- [a1, a3].

При вычитании в [a1, a2, a3] ищется кусок подряд, который равен вычитаемому. Для
[a1, a2] такой кусок найдётся, начиная с индекса 0, а для [a1, a3] -- нет. Поэтому
при вычитании [a1, a2, a3] - [a1, a2] получается [a3], а при вычитании [a1, a2, a3]
- [a1, a3] подходящий кусок не находится, и вычитание не происходит.



Смысл такого правила в том, что если уж делегат получен сложением одного списка с
другими, то это первый список будет найден в суммарном делегате как подсписок. Поэтому
вычитание в этом случае имеет смысл.



Цитата из стандарта, параграф 7.8.5:


  ... Результатом является новый список вызова, состоящий из списка первого операнда
с удалёнными элементами списка второго операнда, при условии, что второй список является
непрерывным (нетривиальным) подсписком первого [...] В противном случае, результатом
является вычитаемое.

Групповые делегаты

#c_sharp #делегаты

Action a1 = () => Console.Write(1); 
Action a2 = () => Console.Write(2); 
Action a3 = () => Console.Write(3); 
((a1 + a2 + a3) - (a1 + a2))(); 
((a1 + a2 + a3) - (a1 + a3))();


Увидел данный пример и стало интересно. Как в данном случае отрабатывает удаление
делегата. Что происходит при (a1 + a2) и (a1 + a3), и почему первый вариант удаляет
как надо а второй не срабатывает вовсе?
    

Ответы

Ответ 1

Пускай a1 + a2 + a3 превращается в делегат, который условно обозначим [a1, a2, a3],
a1 + a2 -- [a1, a2], a1 + a3 -- [a1, a3].

При вычитании в [a1, a2, a3] ищется кусок подряд, который равен вычитаемому. Для
[a1, a2] такой кусок найдётся, начиная с индекса 0, а для [a1, a3] -- нет. Поэтому
при вычитании [a1, a2, a3] - [a1, a2] получается [a3], а при вычитании [a1, a2, a3]
- [a1, a3] подходящий кусок не находится, и вычитание не происходит.



Смысл такого правила в том, что если уж делегат получен сложением одного списка с
другими, то это первый список будет найден в суммарном делегате как подсписок. Поэтому
вычитание в этом случае имеет смысл.



Цитата из стандарта, параграф 7.8.5:


  ... Результатом является новый список вызова, состоящий из списка первого операнда
с удалёнными элементами списка второго операнда, при условии, что второй список является
непрерывным (нетривиальным) подсписком первого [...] В противном случае, результатом
является вычитаемое.

Разница между Invoke и обычным вызовом делегата через ()

#c_sharp #делегаты

В чём разница между Invoke и обычным вызовом делегата через () в C#?
    

Ответы

Ответ 1

Для делегатов разницы между вызовом через d.Invoke(список аргументов) и d(список
аргументов) нет.

При этом генерируется одинаковый IL-код: вызов через скобки транслируется в Invoke.
(Проверка.)

Интересное синтаксическое отличие состоит в том, что проверка на null с Invoke-синтаксисом
проще: d?.Invoke(список аргументов).

Документация: Common Patterns for Delegates / Handling Null Delegates.

Также для вызова через рефлексию вам понадобится использовать Invoke, т. к. скобки
на уровне рефлексии никак не представлены.

Когда обычно нужно использовать делегаты?

#c_sharp #делегаты

Изучаю C#, прошу разъяснить про делегаты - которые предназначены для ситуаций, когда
требуется передать методы другим методам в качестве параметров! Но кода это надо? И зачем? 
Большое спасибо!
    

Ответы

Ответ 1

Реализация обработчиков событий и событийной модели как таковой. Скажем, кликаете
на кнопку, и при клике что-то происходит. Чтобы сообщить программе, какое именно "что-то"
должно произойти, применяют делегаты
LINQ и любые другие элементы функционального программирования в C# - там все основано
на делегатах и их  "сокращенных" вариантах - лямбда-функциях
Они также весьма полезны при реализации многопоточных и асинхронных программ
Вообще для реализации коллбэков. Например, функций сортировки. Чтобы сообщить программе,
как именно нужно сортировать пользовательские типы данных, в метод сортировки необходимо
передать другой метод, позволяющий сравнивать экземпляры сортируемого типа

А вообще очень любопытно, по какому источнику вы изучаете язык, что в нем этого не
написано?

C# Короткая запись метода с помощью анонимного делегата

#c_sharp #делегаты

Подскажите пожалуйста, как реализовать 
Вот исходный код

vm.RegisterCommand('+', v => Inc(v));
private static void Inc(IVirtualMachine v)
{
    if (v.Memory[v.MemoryPointer] == (char)255)
        v.Memory[v.MemoryPointer] = (char)0;
    else
        v.Memory[v.MemoryPointer]++;
}


Хочу заменить на что то вроде 

vm.RegisterCommand('+', b => (b.Memory[b.MemoryPointer] == 255) ? 1 : 2 );


на 1:2 не обращайте внимания это для сокращения кода
    

Ответы

Ответ 1

Ну у вас по сути сложение по модулю, поэтому можно записать вместо if что-то вроде
v.Memory[v.MemoryPointer] = (char)((v.Memory[v.MemoryPointer] + 1) % 256), ну и, соответственно,
в виде лямбды:

vm.RegisterCommand('+', v =>
    v.Memory[v.MemoryPointer] = (char)((v.Memory[v.MemoryPointer] + 1) % 256));


Если IVirtualMachine.Memory – это реально byte-массив, то код можно сократить:

vm.RegisterCommand('+', v => v.Memory[v.MemoryPointer]++));


Если вы хотите переписать свой метод дословно, то это будет выглядеть так:

vm.RegisterCommand('+', v =>
{
    if (v.Memory[v.MemoryPointer] == (char)255)
        v.Memory[v.MemoryPointer] = (char)0;
    else
        v.Memory[v.MemoryPointer]++;
});


Но это не улучшает читаемость, а даже скорее наоборот.

А с использованием тернарного оператора, например, так:

vm.RegisterCommand('+', v =>
    v.Memory[v.MemoryPointer] = (char)(v.Memory[v.MemoryPointer] == 255
                                       ? 0
                                       : (v.Memory[v.MemoryPointer] + 1)
                                      ));

c# сделать функцию параметром функции

#c_sharp #aspnet #функции #делегаты #параметры

Есть множество функций типа flipImageV. До и после кода в этих функциях должны быть
одинаковые строки кода. Что бы в каждой функции типа flipImageV их не писать, хочу
сделать одну, куда буду передавать нужную функцию на выполнение...

Вот универсальная функция, куда передаю выбранную функцию типа flipImageV:

protected void editImage(delegate func) {
        currentImage.ImageUrl = @"..\images\img0.jpg";
        func();
        photo.Save(@"~\" + imagePath);
    }


Функция типа flipImageV:

protected void flipImageV(object sender, EventArgs e) {
        photo.FlipVertical();
    }


Использование того шаблона: 

editImage(flipImageV);


или

protected void flipImageV(object sender, EventArgs e) {
        editImage(photo.FlipVertical());
    }


Что должно быть вместо delegate func? Как это лучше сделать?
    

Ответы

Ответ 1

Используйте просто Action:

protected void editImage(Action func) {
    currentImage.ImageUrl = @"..\images\img0.jpg";
    func();
    photo.Save(@"~\" + imagePath);
}


Вызывать как-то так:

editImage(() => photo.FlipVertical());




Если вам нужно непременно передавать внутрь функцию наподобие flipImageV, которая
получает два игнорируемых аргумента, можно так:

editImage(() => flipImageV(null, EventArgs.Empty));

Рефлексия в c#. Как получить исходный код метода?

#c_sharp #рефлексия #делегаты

Как получить исходный код метода? У меня есть функция которая принимает делегат Predicate
и мне нужно вывести исходный код функции, которую туда передали.
Сама функция

public string GetSource(Predicate match) {
  Console.WriteLine("Source method");
}


Применение этой функции

GetSource(x => x.Name == "name");


Результат вызова функции в консоли: x.Name == "name"
    

Ответы

Ответ 1

Похожие вещи делаются в C# через так называемые деревья выражений. Эта тема сложная,
которая требует ознакомления, и её невозможно осветить в одном ответе на Stack Overflow.

Если вкратце, то для начала вы должны объявить параметр не как Func, Action
или Predicate, а как Expression> или Expression>.

public string GetSource(Expression> expression)
{
    . . .
}


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

На зато вы можете разобрать его на составные части. В случае x.Name == "name" в корне
дерева будет находиться объект типа BinaryExpression со свойством NodeType равным ExpressionType.Equal.

Левый и правый дочерние узлы этого узла будут представлять x.Name и "name" соответственно.
Проще всего пройтись в отладчике по этому дереву и посмотреть, какие объекты там встречаются.

Чтобы вывести всё это на экран, можно просто вызвать метод expression.ToString().
Но в сложных случаях придётся формировать строку из дерева выражения самостоятельно.


Ответ 2

С помощью рефлексии нельзя получить исходный код метода, так как рефлексия возвращает
только ту информацию, которая есть в скомпилированной сборке. Рефлексия может дать
IL-байткод метода, но не исходный код, ей неоткуда взять его. Исходный код нужно получать
из каких-то других источников:

1) Отладочные символы 

Если получение исходного кода необходимо только на машине, где ведется разработка,
можно воспользоваться отладочными символами. В PDB-файлах, генерируемых компилятором,
хранится информация о соответствии строк файлов исходного кода инструкциям в IL-байткоде
(именно благодаря этому отладчик может при возникновении исключения может указать на
конкретную строку). Определив положение начала и конца метода, считать его код из исходников
- дело техники. В символах присутствует каждый метод, который физически есть в сборке,
в том числе и анонимные, поэтому решение вполне применимо и для условий из лямбда-выражений.   

Так как символы ссылаются на исходники по абсолютным путям, чтобы он сработал на
других машинах, проект понадобится перенести на них в точности по такому же пути, как
он был расположен на машине разработчика. Естественно, необязательно распространять
проект целиком - главное, чтобы файл с нужным методом был доступен.  

Формат PDB не документирован, однако существует несколько библиотек с открытым исходным
кодом от Microsoft для работы с ним, например Microsoft.Diagnostics.Runtime.

2) Декомпиляция

Если исходники недоступны или нет символов, можно воспользоваться одним из декомпиляторов,
чтобы восстановить их из байткода на лету. Например, библиотека ICSharpCode.Decompiler,
движок декомпилятора ILSpy, поддерживает декомпиляцию типа в синтаксическое дерево,
которое можно обойти и найти нужный метод. В том числе, с помощью нее программа можно
спокойно декомпилировать саму себя! Правда, чтобы корректно обрабатывать лямбды, придется
отключить подстановку кода анонимных методов - в противном случае мы их в синтаксическом
дереве не найдем.

Пример получения исходного кода метода двумя данными способами:

using System;
using System.Text;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Diagnostics;
using System.Reflection;
using Microsoft.Diagnostics.Runtime;
using Microsoft.Diagnostics.Runtime.Utilities.Pdb;
using ICSharpCode.Decompiler;
using ICSharpCode.Decompiler.CSharp;
using ICSharpCode.Decompiler.CSharp.Syntax;

namespace ConsoleTest1
{
    class Program
    {       
        public static string GetSourceFromPdb(Predicate match)
        {            
            int token = match.Method.MetadataToken;

            //построим путь к файлу символов
            string module_path = match.Method.Module.FullyQualifiedName;
            string pdb_path = Path.Combine(
                Path.GetDirectoryName(module_path),
                Path.GetFileNameWithoutExtension(module_path) + ".pdb"
                );            

            StringBuilder sb = new StringBuilder();
            PdbReader reader = new PdbReader(pdb_path);

            using (reader)
            {
                //найдем метод в символах
                var func = reader.GetFunctionFromToken((uint)token);                

                foreach (PdbSequencePointCollection coll in func.SequencePoints)
                {
                    //считываем файл исходников
                    string[] lines = File.ReadAllLines(coll.File.Name, System.Text.Encoding.UTF8);
                   

                    //найдем номера строк в файле, соответствующие началу и концу метода
                    var points_sorted = coll.Lines.
                        Where((x)=> x.LineBegin <= lines.Length
&& x.LineEnd<=lines.Length).
                        OrderBy((x) => x.Offset);
                    PdbSequencePoint start = points_sorted.First();
                    PdbSequencePoint end = points_sorted.Last();   

                    bool reading = false;
                    int index_start;                    
                    int index_end;

                    //считаем код метода из исходников
                    for(int i=1; i<=lines.Length;i++)
                    {
                        string line = lines[i-1];
                        index_start = 0;
                        index_end = line.Length;

                        if (!reading)
                        {
                            if (i >= start.LineBegin)
                            {
                                //первая строка
                                reading = true;
                                index_start = start.ColBegin - 1;
                                if (index_start < 0) index_start = 0;                    
                            }
                        }                        

                        if (reading)
                        {
                            if (i >= end.LineEnd)
                            {
                                //последняя строка
                                index_end = end.ColEnd - 1;
                                if (index_end > line.Length) index_end = line.Length;

                                sb.AppendLine(line.Substring(index_start, index_end
- index_start));
                                break;
                            }

                            //считывание текущей строки
                            sb.AppendLine(line.Substring(index_start, index_end -
index_start));
                        }  
                    }      
                }

            }

            return sb.ToString();
        }

        public static AstNode FindNode(AstNode root,string match)
        {            
            //поиск метода в синтаксическом дереве
            var children = root.Children;

            foreach (AstNode x in children)
            {
                var s = x.ToString();
                if (s == match && x.Parent.NodeType == NodeType.Member)
                {
                    return x.Parent;
                }

                AstNode res = FindNode(x, match);
                if (res != null) return res;
            }
            return null;
        }

        public static string GetSourceDecompiled(Predicate match)
        {        
            string module_path = match.Method.Module.FullyQualifiedName;            

            var settings = new DecompilerSettings();
            settings.AnonymousMethods = false; //отключим подстановку кода анонимных
методов         

            var decompiler = new CSharpDecompiler( module_path, settings );            

            //декомпилируем тип, содержащий метод
            SyntaxTree tree = decompiler.DecompileType(
                new ICSharpCode.Decompiler.TypeSystem.FullTypeName(match.Method.DeclaringType.FullName)
                );

            //найдем метод в синтаксическом дереве
            var children = tree.Children.ToList();
            AstNode res = null;
            foreach (var x in children)
            {
                res = FindNode(x, match.Method.Name);
                if (res != null) break;
            }

            string s = "";
            if (res != null) s = res.ToString();
            return s;
        }        

        static void Main(string[] args)
        {
            string source;
            Console.WriteLine("*** Source from PDB: ***");
            source = GetSourceFromPdb( (s) =>  s == "Test"  ||  s.Length==0);
           
            Console.WriteLine(source);            

            Console.WriteLine("*** Decompiled source: ***");
            source = GetSourceDecompiled((s) => s == "Test" || s.Length==0);
           
            Console.WriteLine(source);            

            Console.ReadKey();
        }
    }    
}


Результат:

*** Source from PDB: ***
s == "Test"  ||  s.Length==0

*** Decompiled source: ***
[CompilerGenerated]
private static bool 
b__6 (string s)
{
        return s == "Test" || s.Length == 0;
}

Ковариантность и контрвариантность в делегатах Action и Func [дубликат]

#c_sharp #action #делегаты

        
             
                
                    
                        
                            This question already has answers here:
                            
                        
                    
                
                        
                            В чем суть ковариантности и контравариантности делегатов?
                                
                                    (2 ответа)
                                
                        
                                Закрыт 2 года назад.
            
                    
Почему параметры T1, T2,... являются контрвариантными (in T1, in T2,...) в Action? 

И почему возвращаемый тип в Func является ковариантным (out TResult)? 
    

Ответы

Ответ 1

На пальцах: если вам требуется парикмахер для собак (Action), подойдёт универсальный
парикмахер для животных (функция, принимающая на вход Animal).

Поэтому переменной типа Action можно присвоить выражение типа Action.



Наоборот, если вам нужно раздобыть какое угодно животное (Func), то магазин
по продаже котяток подойдёт (Func).

Поэтому переменной типа Func можно присвоить выражение типа Func.



Более подробно: В чем суть ковариантности и контравариантности делегатов?, Контравариантность
обобщенных делегатов С#.


Ответ 2

Делегаты Action контрвариантны потому что там, где вы можете использовать экземпляр
класса-предка, там же вы можете использовать и экземпляр потомка. Пример: 

Action act1 = str => { int i  = str.Length; }; 
Action