以后如何使用linq延迟执行为每个项目执行自定义功能？

Question

I have a:

public Dictionary<string,BaseModel> data  { get; set; }

and I would like to achieve the equivalent of this code which I have working now, only using Linq deferred execution.

foreach (KeyValuePair<string, BaseModel> item in data)
{
   T model = (T)item.Value; //each item needs to be cast to T, T inherits from BaseModel
   model.Init(this, personId); //Init is a function I wrote I want to call on each item
   l.Add(model); //currently I am adding each item to a list, but IEnumerable<T> can work
}

I started writing code like:

IEnumerable<T> l = Cache[type].Data.Cast<T>()
                                   .Select(item => item);

but I can't figure out how to call the Init function (each model has one, they all inherit from BaseModel) on every item. I have been reading about predicate delegates and the like but can't find an example of how to do something like (pseduocode):

IEnumerable<T> l = Cache[type].Data.Cast<T>()
                                   .Select(item => item)
                                   .RunMeOnEachItemLater(InitWrapperDelegate);

In case you are wondering what this is for, I have an MVC project and I am implementing a model data cache.

Answer 1

Don't. It is strongly encouraged to use LINQ in a functional style - your predicates shouldn't have side effects. This is precisely because of deferred execution - what that means is that the lambdas you pass to LINQ methods only get executed when they are needed, if at all.

If you want to have sure some side-effect gets called on elements of your IEnumerable , use foreach :

foreach (var model in Cache[type].Data.Select(i=>i.Value).Cast<T>()) {
    model.Init(...);
}

Even then I'd consider caching the result of the LINQ expression in a field or a variable if you need objects you know are initialised:

var models = Cache[type].Data.Select(i=>i.Value).Cast<T>().ToArray();
foreach (var model in models) {
    ...
}

The reason for this is that an IEnumerable isn't guaranteed to return the same items every time it's enumerated. Obviously it will if the underlying type is a collection, but if you know it is you should use ICollection instead of IEnumerable to express this.

If you can't make Init idempotent so that it can be reexecuted everytime you fetch things from the cache, you should probably init your models when you add them to the cache, or otherwise clean up their lifecycle.

Answer 2

您可以像这样使用List(T).ForEach方法：

var l = Cache[type].Data.Cast<T>().ToList().ForEach(InitWrapperDelegate);

Answer 3

Why not to convert your pseudo-code to real code?

public static class MyExtensions
{
  public static IEnumerable<T> RunMeOnEachItemLater(this IEnumerable<T> sequence,
                                                    Action<T> action)
  {
      foreach(T item in sequence)
      {
         action(item);
         yield return item;
      }
  }
}

Now you can execute custom function for each item later using LINQ deferred execution:

IEnumerable<BaseModel> l = Cache[type].Data.Cast<BaseModel>()
                                           .RunMeOnEachItemLater(m => m.Init());

Answer 4

The functional equivalent would be:

var list = data.Values.Cast<T>()
    .Select(x=>
    {
        x.Init(this, personId); 
        return x;
    })
    .ToList();

Note that you can remove the .ToList() to return an IEnumerable<T> and Init calls would run later when the list is being enumerated.