是否可以缓存 lambda 表达式中计算的值？
https://stackoverflow.com/questions/66382
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
下面代码中的ContainsIngredients方法中，是否可以缓存 p.成分 value 而不是多次显式引用它？这是一个相当简单的示例，我只是为了说明目的而编写的，但我正在处理的代码引用了内部深处的值 p 例如。 p.InnerObject.ExpectiveMethod().Value
编辑：我正在使用 PredicateBuilder http://www.albahari.com/nutshell/predicatebuilder.html
public class IngredientBag
{
private readonly Dictionary<string, string> _ingredients = new Dictionary<string, string>();
public void Add(string type, string name)
{
_ingredients.Add(type, name);
}
public string Get(string type)
{
return _ingredients[type];
}
public bool Contains(string type)
{
return _ingredients.ContainsKey(type);
}
}
public class Potion
{
public IngredientBag Ingredients { get; private set;}
public string Name {get; private set;}
public Potion(string name) : this(name, null)
{
}
public Potion(string name, IngredientBag ingredients)
{
Name = name;
Ingredients = ingredients;
}
public static Expression<Func<Potion, bool>>
ContainsIngredients(string ingredientType, params string[] ingredients)
{
var predicate = PredicateBuilder.False<Potion>();
// Here, I'm accessing p.Ingredients several times in one
// expression. Is there any way to cache this value and
// reference the cached value in the expression?
foreach (var ingredient in ingredients)
{
var temp = ingredient;
predicate = predicate.Or (
p => p.Ingredients != null &&
p.Ingredients.Contains(ingredientType) &&
p.Ingredients.Get(ingredientType).Contains(temp));
}
return predicate;
}
}
[STAThread]
static void Main()
{
var potions = new List<Potion>
{
new Potion("Invisibility", new IngredientBag()),
new Potion("Bonus"),
new Potion("Speed", new IngredientBag()),
new Potion("Strength", new IngredientBag()),
new Potion("Dummy Potion")
};
potions[0].Ingredients.Add("solid", "Eye of Newt");
potions[0].Ingredients.Add("liquid", "Gall of Peacock");
potions[0].Ingredients.Add("gas", "Breath of Spider");
potions[2].Ingredients.Add("solid", "Hair of Toad");
potions[2].Ingredients.Add("gas", "Peacock's anguish");
potions[3].Ingredients.Add("liquid", "Peacock Sweat");
potions[3].Ingredients.Add("gas", "Newt's aura");
var predicate = Potion.ContainsIngredients("solid", "Newt", "Toad")
.Or(Potion.ContainsIngredients("gas", "Spider", "Scorpion"));
foreach (var result in
from p in potions
where(predicate).Compile()(p)
select p)
{
Console.WriteLine(result.Name);
}
}
解决方案
难道你不能简单地在一个单独的静态函数中编写你的布尔表达式吗？你可以从你的 lambda 调用它 - 将 p.Ingredients 作为参数传递...
private static bool IsIngredientPresent(IngredientBag i, string ingredientType, string ingredient)
{
return i != null && i.Contains(ingredientType) && i.Get(ingredientType).Contains(ingredient);
}
public static Expression<Func<Potion, bool>>
ContainsIngredients(string ingredientType, params string[] ingredients)
{
var predicate = PredicateBuilder.False<Potion>();
// Here, I'm accessing p.Ingredients several times in one
// expression. Is there any way to cache this value and
// reference the cached value in the expression?
foreach (var ingredient in ingredients)
{
var temp = ingredient;
predicate = predicate.Or(
p => IsIngredientPresent(p.Ingredients, ingredientType, temp));
}
return predicate;
}
其他提示
你有没有考虑过 记忆化?
基本思想是这样的；如果您有一个昂贵的函数调用，则有一个函数将在第一次调用时计算昂贵的值，但此后返回缓存的版本。该函数如下所示；
static Func<T> Remember<T>(Func<T> GetExpensiveValue)
{
bool isCached= false;
T cachedResult = default(T);
return () =>
{
if (!isCached)
{
cachedResult = GetExpensiveValue();
isCached = true;
}
return cachedResult;
};
}
这意味着你可以这样写；
// here's something that takes ages to calculate
Func<string> MyExpensiveMethod = () =>
{
System.Threading.Thread.Sleep(5000);
return "that took ages!";
};
// and heres a function call that only calculates it the once.
Func<string> CachedMethod = Remember(() => MyExpensiveMethod());
// only the first line takes five seconds;
// the second and third calls are instant.
Console.WriteLine(CachedMethod());
Console.WriteLine(CachedMethod());
Console.WriteLine(CachedMethod());
作为一般策略，它可能会有所帮助。
好吧，在这种情况下，如果你不能使用 Memoization，那么你会受到很大的限制，因为你实际上只能使用堆栈作为缓存：您无法在所需的范围内声明新变量。我能想到的（我并不是说它会很漂亮）可以做你想做的事情，但保留你需要的可组合性，就像......
private static bool TestWith<T>(T cached, Func<T, bool> predicate)
{
return predicate(cached);
}
public static Expression<Func<Potion, bool>>
ContainsIngredients(string ingredientType, params string[] ingredients)
{
var predicate = PredicateBuilder.False<Potion>();
// Here, I'm accessing p.Ingredients several times in one
// expression. Is there any way to cache this value and
// reference the cached value in the expression?
foreach (var ingredient in ingredients)
{
var temp = ingredient;
predicate = predicate.Or (
p => TestWith(p.Ingredients,
i => i != null &&
i.Contains(ingredientType) &&
i.Get(ingredientType).Contains(temp));
}
return predicate;
}
您可以根据需要将多个 TestWith 调用的结果组合成一个更复杂的布尔表达式 - 在每次调用时缓存适当的昂贵值 - 或者您可以将它们嵌套在作为第二个参数传递的 lambda 中以处理复杂的深层层次结构。
不过，阅读代码会非常困难，并且由于您可能会在所有 TestWith 调用中引入更多堆栈转换，因此它是否会提高性能将取决于 ExpenseCall() 的开销有多大。
请注意，正如另一个答案所建议的那样，原始示例中不会有任何内联，因为据我所知，表达式编译器没有进行这种级别的优化。
在这种情况下我会说不。我假设编译器可以发现它使用 p.Ingredients 变量 3 次，并将变量保留在堆栈或寄存器或它使用的任何内容附近。
汹涌的智力有完全正确的答案。
我只是想建议您可以从您正在使用的类型中删除一些空值和异常，以便更友好地使用它们。
public class IngredientBag
{
private Dictionary<string, string> _ingredients =
new Dictionary<string, string>();
public void Add(string type, string name)
{
_ingredients[type] = name;
}
public string Get(string type)
{
return _ingredients.ContainsKey(type) ? _ingredients[type] : null;
}
public bool Has(string type, string name)
{
return name == null ? false : this.Get(type) == name;
}
}
public Potion(string name) : this(name, new IngredientBag()) { }
然后，如果您在此结构中有查询参数...
Dictionary<string, List<string>> ingredients;
您可以像这样编写查询。
from p in Potions
where ingredients.Any(i => i.Value.Any(v => p.IngredientBag.Has(i.Key, v))
select p;
PS，为什么是只读？
不隶属于 StackOverflow
