Prevent z .NET „podnoszenia” zmiennych lokalnych

Question

Mam następujący kod:

string prefix = "OLD:"; 
Func<string, string> prependAction = (x => prefix + x); 
prefix = "NEW:"; 
Console.WriteLine(prependAction("brownie")); 

Ponieważ kompilator zastępuje zmienną prefiksu z zamknięciem „NEW: brownie” jest drukowany na konsoli.

Czy istnieje prosty sposób, aby uniemożliwić kompilatorowi podniesienie zmiennej prefiksu, nadal korzystając z wyrażenia lambda? Chciałbym sposób dokonywania moją pracę Func identycznie:

Func<string, string> prependAction = (x => "OLD:" + x); 

Powodem muszę to chciałbym serializacji wynikowy delegata. Jeśli zmienna przedrostkowa znajduje się w klasie niezdolnej do serializacji, powyższa funkcja nie będzie serializować.

Jedynym sposobem wokół to widzę w tej chwili jest stworzenie nowej klasy można zaszeregować który przechowuje ciąg jako zmienną Członkowskim oraz ma metodę ciąg poprzedzić:

string prefix = "NEW:"; 
var prepender = new Prepender {Prefix = prefix}; 
Func<string, string> prependAction = prepender.Prepend; 
prefix = "OLD:"; 
Console.WriteLine(prependAction("brownie")); 

z klasą pomocnika:

[Serializable] 
public class Prepender 
{ 
    public string Prefix { get; set; } 
    public string Prepend(string str) 
    { 
     return Prefix + str; 
    } 
} 

Wydaje się, że jest to bardzo dużo pracy, aby kompilator był "głupi".

Answer 1

Widzę teraz podstawowy problem. Jest głębszy niż początkowo sądziłem. Zasadniczo rozwiązaniem jest zmodyfikowanie drzewa wyrażeń przed serializowaniem go przez zastąpienie wszystkich poddrzew, które nie zależą od parametrów ze stałymi węzłami. Jest to najwyraźniej nazywane "funcletization". Istnieje wyjaśnienie tego here.

Answer 2

Co o tym

string prefix = "OLD:"; 
string _prefix=prefix; 
Func<string, string> prependAction = (x => _prefix + x); 
prefix = "NEW:"; 
Console.WriteLine(prependAction("brownie")); 

Answer 3

Jak o:

string prefix = "OLD:"; 
string prefixCopy = prefix; 
Func<string, string> prependAction = (x => prefixCopy + x); 
prefix = "NEW:"; 
Console.WriteLine(prependAction("brownie")); 

?

Answer 4

Lambdas automatycznie "zasysa" zmienne lokalne, obawiam się, że to po prostu sposób, w jaki działają z definicji.

Answer 5

Jest to dość powszechny problem czyli zmienne są modyfikowane przez zamknięcie niezamierzone - o wiele prostsze rozwiązanie jest tylko, aby przejść:

string prefix = "OLD:"; 
var actionPrefix = prefix; 
Func<string, string> prependAction = (x => actionPrefix + x); 
prefix = "NEW:"; 
Console.WriteLine(prependAction("brownie")); 

Jeśli używasz ReSharper to rzeczywiście zidentyfikować miejsca w kodzie gdy istnieje ryzyko wystąpienia nieoczekiwanych skutków ubocznych, takich jak ten - jeśli więc plik jest "zielony", kod powinien być w porządku.

myślę, że w pewnym sensie byłoby miło, gdybyśmy mieli trochę cukru składniowej w tej sytuacji, więc możemy napisać ją jako jedną wkładką tj

Func<string, string> prependAction = (x => ~prefix + x); 

Jeżeli jakiś operator prefiks spowodowałoby wartość zmiennej, która ma zostać obliczona przed skonstruowaniem anonimowego delegata/funkcji.

Answer 6

Istnieje już kilka odpowiedzi tutaj wyjaśniających, w jaki sposób można uniknąć lambda "podnoszenia" zmiennej. Niestety to nie rozwiązuje twojego podstawowego problemu. Niezdolność do serializowania lambda nie ma nic wspólnego z tym, że lambda "podniosła" zmienną. Jeśli wyrażenie lambda potrzebuje do obliczenia instancji klasy bez serializacji, ma to doskonały sens, że nie można jej serializować.

W zależności od tego, co faktycznie próbujesz zrobić (nie mogę zdecydować z twojego postu), rozwiązaniem byłoby przeniesienie nieusuwalnej części lambda na zewnątrz.

Na przykład zamiast:

NonSerializable nonSerializable = new NonSerializable(); 
Func<string, string> prependAction = (x => nonSerializable.ToString() + x); 

zastosowanie:

NonSerializable nonSerializable = new NonSerializable(); 
string prefix = nonSerializable.ToString(); 
Func<string, string> prependAction = (x => prefix + x); 

Answer 7

Cóż, jeśli mamy zamiar mówić o "problemach" tu, lambdas pochodzą z funkcjonalnego programowania świecie, aw czysto funkcjonalne programowanie językowe, , nie ma zadań, więc twój problem nigdy by się nie pojawił, ponieważ wartość prefiksu nigdy by się nie zmieniła. Rozumiem, że C# uważa, że ​​fajnie jest importować pomysły z programów funkcjonalnych (ponieważ FP to fajne!), Ale bardzo trudno jest to zrobić ładnie, ponieważ C# jest i zawsze będzie imperatywnym językiem programowania.

Answer 8

Teraz pojawia się problem: lambda odnosi się do klasy zawierającej, której nie można przekształcić do postaci szeregowej. Następnie wykonaj coś takiego:

public void static Func<string, string> MakePrependAction(String prefix){ 
    return (x => prefix + x); 
} 

(Uwaga na słowo kluczowe statyczne). Następnie lambda nie musi odwoływać się do klasy zawierającej.

Answer 9

Wystarczy dokonać innego zamknięcia ...

Powiedz coś:

var prepend = "OLD:"; 

Func<string, Func<string, string>> makePrepender = x => y => (x + y); 
Func<string, string> oldPrepend = makePrepender(prepend); 

prepend = "NEW:"; 

Console.WriteLine(oldPrepend("Brownie")); 

havn't testowałem go jeszcze tak nie mam dostępu do VS w tej chwili, ale normalnie, to jak rozwiązuję taki problem.