如何解决循环优化或lambda关闭有问题吗？
| 在下面的方法中，我要发送动作的枚举，并希望返回一组ICommands数组，这些数组将调用“ 0”来包装这些动作（relayCommand是必需的）。 问题是，如果我在for每个（甚至是for循环）内部执行此操作，则会得到始终执行参数中传递的第一个动作的命令。 public static ICommand[] CreateCommands(IEnumerable<Action> actions)
{
List<ICommand> commands = new List<ICommand>();
Action[] actionArray = actions.ToArray();
// works
//commands.Add(new RelayCommand(o => { actionArray[0](); })); // (_execute = {Method = {Void <CreateCommands>b__0(System.Object)}})
//commands.Add(new RelayCommand(o => { actionArray[1](); })); // (_execute = {Method = {Void <CreateCommands>b__1(System.Object)}})
foreach (var action in actionArray)
{
// always add the same _execute member for each RelayCommand (_execute = {Method = {Void <CreateCommands>b__0(System.Object)}})
commands.Add(new RelayCommand(o => { action(); }));
}
return commands.ToArray();
}
foreach (var action in actionArray)
{
Action<object> executeHandler = o => { action(); };
commands.Add(new RelayCommand(executeHandler));
}
class RelayExecuteWrapper
{
Action _action;
public RelayExecuteWrapper(Action action)
{
_action = action;
}
public void Execute(object o)
{
_action();
}
}
/// ...
foreach (var action in actionArray)
{
RelayExecuteWrapper rxw = new RelayExecuteWrapper(action);
commands.Add(new RelayCommand(rxw.Execute));
}
/// <summary>
/// A command whose sole purpose is to
/// relay its functionality to other
/// objects by invoking delegates. The
/// default return value for the CanExecute
/// method is \'true\'.
/// </summary>
public class RelayCommand : ICommand
{
#region Fields
readonly Action<object> _execute;
readonly Predicate<object> _canExecute;
#endregion // Fields
#region Constructors
/// <summary>
/// Creates a new command that can always execute.
/// </summary>
/// <param name=\"execute\">The execution logic.</param>
public RelayCommand(Action<object> execute)
: this(execute,null)
{
}
/// <summary>
/// Creates a new command.
/// </summary>
/// <param name=\"execute\">The execution logic.</param>
/// <param name=\"canExecute\">The execution status logic.</param>
public RelayCommand(Action<object> execute,Predicate<object> canExecute)
{
if (execute == null)
throw new ArgumentNullException(\"execute\");
_execute = execute;
_canExecute = canExecute;
}
#endregion // Constructors
#region ICommand Members
[DebuggerStepThrough]
public bool CanExecute(object parameter)
{
return _canExecute == null ? true : _canExecute(parameter);
}
public event EventHandler CanExecuteChanged
{
add { CommandManager.RequerySuggested += value; }
remove { CommandManager.RequerySuggested -= value; }
}
public void Execute(object parameter)
{
_execute(parameter);
}
#endregion // ICommand Members
}
解决方法
每周在StackOverflow上报告此问题的次数。问题在于，在循环内部创建的每个新lambda都共享相同的\“ action \”变量。 Lambda不捕获值，而是捕获变量。也就是说，当你说
List<Action> list = new List<Action>();
foreach(int x in Range(0,10))
list.Add( ()=>{Console.WriteLine(x);} );
list[0]();
List<Action> list = new List<Action>();
foreach(int x in Range(0,10))
{
int y = x;
list.Add( ()=>{Console.WriteLine(y);} );
}
list[0]();
{ Method = {Void <CreateCommands>b__0(System.Object)}}
var firstList = new List<Func<int>>()
{
()=>10,()=>20
};
static int ReturnTen() { return 10; }
static int ReturnTwenty() { return 20; }
...
var firstList = new List<Func<int>>()
{ ReturnTen,ReturnTwenty };
var secondList = new List<Func<int>>();
foreach(var func in firstList)
secondList.Add(()=>func());
class Closure
{
public Func<int> func;
public int DoTheThing() { return this.func(); }
}
...
var secondList = new List<Func<int>>();
Closure closure = new Closure();
foreach(var func in firstList)
{
closure.func = func;
secondList.Add(closure.DoTheThing);
}
foreach(var loopFunc in firstList)
{
var func = loopFunc;
secondList.Add(func);
}
foreach(var loopFunc in firstList)
{
var closure = new Closure();
closure.func = loopFunc;
secondList.Add(closure.DoTheThing);
}
foreach (var action in actionArray)
{
Action<object> executeHandler = o => { action(); };
commands.Add(new RelayCommand(executeHandler)); }
}
foreach (var action in actionArray)
{
Action<object> copy = action;
commands.Add(new RelayCommand(x=>{copy();}));
}
interface ICommand
{
void Print();
}
class CommandA : ICommand
{
public void Print() { Console.WriteLine(\"A\"); }
}
class CommandB : ICommand
{
public void Print() { Console.WriteLine(\"B\"); }
}
public static void Main()
{
var actions = new List<Action>();
foreach (var command in new ICommand[]{
new CommandA(),new CommandB(),new CommandB()})
{
var commandcopy = command;
actions.Add(() => commandcopy.Print());
}
foreach (var action in actions)
action();
}
A
B
B
foreach (var action in actionArray)
{
var myAction = action;
// always add the same _execute member for each RelayCommand (_execute = {Method = {Void <CreateCommands>b__0(System.Object)}})
commands.Add(new RelayCommand(o => { action(); }));
}
commands.Add(new RelayCommand(o => { actionArray[0](); }));
public static ICommand[] CreateCommands(IEnumerable<Action> actions)
{
commands = actions.Select(o => new RelayCommand(o)).ToArray();
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。