Question: I need to consume the services of a number of third party systems on my applications homepage. The data pertaining to these downstream systems are updated at different intervals and ideally my system will surface the latest data. It's not a scalable solution for my system to generate requests to each of these downstream systems each time a user hits my homepage. What strategy can i use to ensure the data i surface is current without effecting the reliability of these downstream systems?

Is a consumer/producer strategy most suitable for this requirement?

Answer: 
Have the method accept an expression, just as the method you're passing it to does:

```
public class Foo
{
    public void UpdateEmployeeOrders(IEnumerable<Employee> employees,
         Expression<Func<Employee, object>> selector)
    {
        foreach (var employee in employees)
        {
            UpdateSpecificEmployeeOrder(employee.id, selector);
        }
    }
}

```

Also, since the only thing we ever do with `employees` is iterate over it, we can type the parameter as `IEnumerable` instead of `ICollection`. It provides all of the guarantees that this methods needs, while allowing a broader range of possible input types.
You have the answer in your answer... you're using lambdas... so pass a delegate in your method. 

```
public void SaveEmployeeDisplayOrder<T>(ICollection<Employee> employees, Func<Employee, T> fetchProperty)
{
   //some code

   foreach( var employee in employees)
   {
      UpdateSpecificEmployeeOrder(employee.id, fetchProperty(employee));
   }
}

```

Then you would call it similar to what you had:

```
SaveEmployeeDisplayOrder(employees, e => e.EmployeeDisplayOrder);

```

or

```
SaveEmployeeDisplayOrder(employees, e => e.EmployeeEnrollOrder);

```