如何使用linq在C＃中有效过滤包含特定属性的列表

Question

I am busy implementing an api controller that returns a list of devices,

Here is my current helper method:

private List<Device> GetUsersDevices(string userName)
    {
        int userId = -1;
        List<Device> myDevices;
        if (Int32.TryParse(User.Identity.Name, out userId))
        {
            myDevices = db.Devices.Where((x => x.EndUserId == userId && x.Deleted == false)).OrderByDescending(x => x.LastComms).ToList();
            return myDevices;
        }
        return null;
    }

Now this is all good, But I now need to add a rule that it only returns certain devices (one compatible to the end client)

So I want to make a list of the allowed device types for a end client like the psuedo code below:

List endclient1 = device type 1, device type 2 etc. List endclient2 = device type 2, device type 5 etc.

But then I want to filter my list of devices to remove all the unsupported devices. Now I understand that I can just continue adding to the .Where(...) clause in my original statement, but I want to know the most efficient way to go about doing this, And also If the amount of device types grows large it will not be very easy to maintain that line of code. And I would possibly like to have different list of supported devices for different end clients, So if I could filter by a list of allowed devices it will allow me to have one controller serving all the different end clients, and it will just return what device they are allowed.

Other Info that might be needed.

Here is the MyDevice Class

    public class MyDevice
{        
    public MyDevice(long deviceId, string name, string serialNo, string deviceType, int deviceTypeId, bool enabled)
    {
        this.deviceId = deviceId;
        this.name = name;
        this.serialNo = serialNo;
        this.deviceTypeName = deviceType;
        this.deviceTypeId = deviceTypeId;
        this.enabled = enabled;
    }

    public string name { get; set; }
    public long deviceId { get; set; }
    public string serialNo { get; set; }
    public string deviceTypeName { get; set; }
    public int deviceTypeId { get; set; }
    public bool enabled { get; set; }
}

Answer 1

If I understand your question correctly, you want to do something like this:

var allowedDeviceTypes = GetAllowedDeviceTypesForUser(userId);

return db.Devices
  .Where(x => x.EndUserId == userId && x.Deleted == false)
  .Where(x => allowedDeviceTypes.Contains(x.deviceTypeId))
  .OrderByDescending(x => x.LastComms)
  .ToList();

This will be translated to a WHERE deviceTypeId IN (...) clause (assuming you're using LINQ to SQL, Entity Framework or NHibernate), which is efficient enough for a reasonable number of device types.

Note that the method GetAllowedDeviceTypesForUser has nothing to do with LINQ, and you're free to implement it however you want (eg delegate it to another service, add custom rules etc.). As long as you have a way of getting a list of allowed device types, you can pass that to the LINQ query.

Here's a trivial implementation:

private IDictionary<int, IList<int>> _allowedDeviceTypesPerUserId = 
  new Dictionary<int, IList<int>>() {
    { 1, new[] { 1, 2 } },
    { 2, new[] { 2, 5 } },
    // ...
  };

private IList<int> GetAllowedDeviceTypesForUser(int uesrId)
{
    return _allowedDeviceTypesPerUserId[userId];
}

This is assuming the list of allowed devices per user is static. If it's dynamic, you'll have to load it from somewhere, in which case you might also consider using a Join but I'm not sure that's the best idea in your case.

Answer 2

You can take a look at join to give you an intersection of the "all devices" list and the "compatible devices" list, based on a key, in this case deviceId .

In this case, you would do something like (not checked for syntax correctness):

db.Devices.Join(endClientList, d => d.deviceId, ecd => ecd.deviceId, d => d);

This is just from the top of my head, so there may be some errors in there, but you should be able to figure out how to use it if you want.

Answer 3

Unless you have a few billion Devices I think you find plain old LINQ more than efficient:

myDevices = from device in db.Devices
            where device.EndUserId == userId 
              && device.Deleted == false
              && allowedTypes.Contains(device.Type)
            order by device.LastComms
            select device;

It is the most readable and maintainable too!

Another advantage of this is standard LINQ is compilers jitters conversions to SQL can all optimise this standard stuff - have you measured it's speed - is it a problem and have you compared it to alternatives?

Answer 4

I'm not sure I understand your question.But I will do just like this:

    int userId = -1;
    List<Device> myDevices;
    if (Int32.TryParse(User.Identity.Name, out userId))
    {
        myDevices = db.Devices.Where((x => x.EndUserId == userId && x.Deleted == false)).OrderByDescending(x => x.LastComms).ToList();
        var result1 = myDevices.Where(x=>x.name==someName);
        var result2 = myDevices.Where(x=>x.deviceId >someDeviceId );
        var result3 = myDevices.Where(x=>x.serialNo.Contains("someSerialNo"));
        ....
        return resultN.ToList();
    }

or

myDevices = from item in db.Devices
            where item.name == someName && item.deviceId == someDeviceId && ...
            where ...
            OrderByDescending item.LastComms
            select item;