Question

I have an object which has a property that contains an IEnumerable of objects. Each object in the IEnumerable has a property that is also an IEnumerable. I am attempting to capture a larger list of the inner property. Unfortunately, the lambda expression that I am using is returning an OrderedEnumerable. I’d like to just retrieve a simple IEnumerable.

public class OrgForm
{
    public string OrgNum { get; set; }

    public IEnumerable<CustomerForm> CustomerFormList
    {
        get
        {
            var list = from cf in OrgCustomerList
                       where cf.Customer.AssignedOrg == OrgNum
                       select cf;

            return list;
        }
    }
}

Use of CustomerFormList

OrgForm of = new OrgForm();
IEnumerable<Machine> machines = of.CustomerFormList
                                  .Select(cf => cf.ActiveMachines);

Edit

So after prompting from Jon Skeet and Mark Byers I looked a little deeper and found that ActiveMachines had been modified to perform an OrderBy so now the return of an OrderedEnumerable makes sense (my bad for not reading code set change comments).

public class CustomerForm
{
    public IEnumerable<Machine> ActiveMachines
    {
        get
        {
            var active = Customer.MachineList.ToList()
                .Where(m => "a".Equals(m.MachineStatus)
                            && !m.ToReapp);

            return active.OrderBy(m => m.MachineCategory);
        }
    }
}

This is great except machines doesn’t allow me to write something like this as it sees each item in machines as an enumerable based on the category.

foreach (KeyValuePair<int, string[]> kvp in trueUpPt)
{
    Machine machine = cf.ActiveMachines
        .First(m => m.MachineSk == kvp.Key);
    machine.MachineLicenseBillback.ProjectNum = kvp.Value[0];
    machine.MachineLicenseBillback.TaskNum = kvp.Value[1];
}

Answer 1

OrderedEnumerable<T> is an IEnumerable<T> – it’s one particular implementation. Obviously you’ve got to return some implementation (or null) – it’s not going to be an instance of the interface directly.

The code you’ve presented should be fine as it is. It’s declared to return IEnumerable<T> so it shouldn’t make any difference unless you cast the result. Having said that, the property you’ve shown shouldn’t be returning an OrderedEnumerable anyway… Enumerable.Where just returns a new iterator. Admittedly it won’t change the order so you could have an overload for Where(this IOrderedEnumerable<T>) but I don’t believe there’s one in the standard library.

What problem is this actually causing you, and are you using some extra libraries? If you could come up with a short but complete example it would really help.