Можем ли мы получить личность делегата?

Ответ 1

Один (относительно наивный) подход состоял бы в том, чтобы использовать Expression<Func> вместо Func сами, так как у них гораздо более подробная информация, что позволяет анализировать материал. Например.

Expression<Func<int, int, int>> delegate1 = (a, b) => a + b;
Expression<Func<int, int, int>> delegate2 = (a, b) => a + b;
Expression<Func<int, int, int>> delegate3 = (a, b) => a - b;
var id1 = id(delegate1);
var id2 = id(delegate2);
var id3 = id(delegate3);
Debug.Assert(id1 == id2);
Debug.Assert(id1 != id3);

где id столь же тривиально, как:

public static string id(Expression<Func<int, int, int>> expression)
{
    return expression.ToString();
}

проходит тесты.

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

Ответ 2

Вам нужно работать на уровне Expression здесь. Компилятор С# не гарантирует, что идентичные lambdas получат один и тот же объект-делегат. Эта оптимизация не выполняется прямо сейчас, но есть проблема GitHub. Даже если он будет выполнен, он будет работать на одной сборке одновременно, что может быть недостаточно для вас. Если делегат фиксирует значения закрытия, это никогда не будет работать.

Я как-то сделал это для того, чтобы автоматически скомпилировать запросы SQLQLQ 2 SQL с учетом запроса. Нетрудно сравнить деревья выражений. ToString не является полной верностью и медленнее. Вам нужно будет написать свой собственный класс сравнения. Я думаю, что там код для этого в Интернете в качестве отправной точки.

В качестве примера, когда вы сравниваете константные выражения, вы не можете просто сделать ReferenceEquals(val1, val2). Вы должны на самом деле особым случаем многих типов, таких как примитивные типы в штучной упаковке. Они могут иметь одинаковое значение, но в коробке с разными идентификаторами объектов.

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

Вы также получите проблемы с GC, потому что деревья выражений могут удерживаться на произвольных объектах. В принципе, замыкание может случайным образом удерживать локальные переменные неожиданным образом. Так что я сделал, чтобы санировать деревья, прежде чем их кешировать. Я удалил из них все константы, которые не были безопасными.

Можно ли создать идентификатор делегата, чтобы отличить его от другого делегата?

Да, но он включает в себя ручное сравнение и хэширование дерева выражений.

Ответ 3

Здесь нужно использовать Dictionary<T1, T2> для хранения идентификатора строки и наших делегатов (строка Key содержит отсортированное выражение, объединенное со значением из некоторого вызова вызова [это генерирует UID какого-то типа]), а значение - наш делегат Func. Выражение компилируется только в первый раз, когда мы преобразуем наше выражение, преобразованное в строку в ID, в _delegatesMapping:

public class Funker
{
    private static Dictionary<string, string> _delegatesMapping;
    private static Dictionary<string, Func<int, int, int>> _delegates;
    public static Funker Instance { get; private set; }

    static Funker()
    {
        _delegatesMapping = new Dictionary<string, string>();
        _delegates = new Dictionary<string, Func<int, int, int>>();
        Instance = new Funker();
    }

    private Funker() { }

    public Func<int, int, int> this[Expression<Func<int, int, int>> del]
    {
        get
        {
            string expStr = del.ToString();

            var parameters = del.Parameters;

            for (int i = 0; i < parameters.Count; i++)
                expStr = expStr.Replace(parameters[i].Name, String.Concat('_' + i));

            Func<int, int, int> _Del = null;

            if (!_delegatesMapping.ContainsKey(expStr))
            {
                _Del = del.Compile();
                _delegatesMapping.Add(expStr, new String(expStr.OrderBy(ch => ch).ToArray()) + "|" + _Del(55, 77));
            }

            if (!_delegates.ContainsKey(_delegatesMapping[expStr])) _delegates.Add(_delegatesMapping[expStr], _Del ?? del.Compile());
            return _delegates[_delegatesMapping[expStr]];
        }
    }
}

Нам нужен этот _delegatesMapping для хранения наших записей UID в формате Expression string → UID. Это также позволяет нам выполнять быстрый (почти n(1)) поиск, а не вычислять UID каждый раз, когда нам это нужно.

Итак, вся операция выглядит так:

Выражение → textExp → новая запись в _delegatesMapping (textExp → UID) новая запись в _delegates[UID]

И при обращении к нему все обратное. Сначала мы получаем UID, чем делегат:

Выражение → textExp → _delegates [_delegatesMapping [textExp]] (возвращает делегат, если он существует в словаре).

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

class Program
{        

    static void Main(string[] args)
    {
        var funker = Funker.Instance;

        var del1 = funker[(a, b) => a + 71 + 12 + b];
        var del2 = funker[(hello, world) => 71 + hello + world + 12];
        var del3 = funker[(a, c) => a + 17 + 21 + c];

        Debug.Assert(del1 == del2);
        Debug.Assert(del1 == del3);
    }
}

Вывод:

true
false

P.S. Но поскольку SWeko уже написал в своем ответе:

Обратите внимание, что это не полное решение и имеет много и много вопросы. Если вам нужно всестороннее сравнение, вам нужно будет с учетом полного характера выражения, включая (но не слишком ограниченные) типы, входящие и выходящие из выражения, вызовы методов, закрытие доступа и т.д. и т.д.