使用Lambda表达式从其他表中选择属性

Question

I am less experienced with Lambda expression for .NET and trying to get data from SQL using lambda expression. With below query, I am able to get data back, but do not want to use include to get all properties from other tables.

public IEnumerable<ResourceGroup> GetAllServersByApplication(string application_name, string environment_name, string status)
{
    var query = _context.ResourceGroup
        .Include(a => a.Application)
        .Include(t => t.Type)
        .Include(e => e.ServersGroup).ThenInclude(e => e.Environment)
        .Include(s => s.ServersGroup).ThenInclude(s => s.Server)
        .Include(s => s.ServersGroup).ThenInclude(s => s.Server).ThenInclude(s => s.Status)
        .Where(a => a.Application.Name == application_name && a.ServersGroup.Any(s => s.Environment.Name == environment_name && s.Server.Status.Name == status))
        .ToList();

    return query;
}

Lets take an example of below include statement.

.Include(s => s.ServersGroup).ThenInclude(s => s.Server)

From s.Server , I only want to select Id,ServerName,Status, and IPAddress . These are the properties from Servers class that I created as a model.

What is the easy way to exclude all the includes and only show properties that I am interested in?

Here are my tables and its properties:

Status table:

Id, Name

Application table:

Id, Name

Servers table:

Id, ServerName, Status

Environments table:

Id, Name

ResourceGroup table:

Id, Name, Application_Id, Environment_Id

ServersResourceGroup table:

Id, Server_Id, Resource_Id

UPDATE 1 :

var query = _context.ResourceGroup
                    .SelectMany(rg => rg.ServersGroup
                    .Select(sg => new
                    {
                        ResourceName = rg.Name,
                        ApplicationName = rg.Application.Name,
                        ServerName = sg.Server.ServerName,
                        EnvironmentName = sg.Environment.Name,
                        Status = sg.Server.Status.Name
                    })).Where(a => a.ApplicationName == application_name && a.EnvironmentName == environment_name && a.Status == status).ToList();
        return query;

And error from red line on query variable:

UPDATE 2 :

Here is the query syntax:

var query = from rg in _context.ResourceGroup
                    let app = rg.Application
                    from sg in rg.ServersGroup
                    let env = sg.Environment
                    let srv = sg.Server
                    let stat = srv.Status
                    where app.Name == application_name
                            && rg.ServersGroup.Any(s => s.Environment.Name == environment_name
                                      && s.Server.Status.Name == status)
                    select new
                    {
                        ResourceGroupName = rg.Name,
                        ApplicationName = app.Name,
                        ServerName = srv.ServerName,
                        Alias = srv.Alias,
                        IPAddress = srv.IPAddress,
                        Type = rg.Type.Name,
                        Status = stat.Name
                    };
        return query;

Here is the red line error I get in query variable:

Your help is really appreciated. :)

Thanks,

Ray

Answer 1

With lambda expressions, you can use SelectMany to flatten 1-n associations into a 1 dimensional list (ie parent and child properties side-by-side). In your case, judging from the Where clause, I think only ResourceGroup - ServerGroup is 1 - n, so it should be something like:

var query = _context.ResourceGroup
                    .SelectMany
                     (
                          rg => rg.ServersGroup
                                  .Select(sg => new 
                                  {
                                      ResourceGroup = rg.Name,
                                      Application = rg.Application.Name,
                                      Server = sg.Server.ServerName,
                                      // etc.
                                  })
                     )

Of course it's good to know how to use lambda expressions, but there's really no point in using them when query syntax makes for much better comprehensible code.

The equivalent in query syntax is:

var query = from rg in _context.ResourceGroup
            let app = rg.Application
            from sg in rg.ServersGroup
            let env = sg.Environment
            let srv = sg.Server
            let stat = srv.Status
            where app.Name == application_name
               && sg.ServersGroup.Any(s => s.Environment.Name == environment_name
                                        && s.Server.Status.Name == status)
            select new
            {
                ResourceGroup = rg.Name,
                Application = app.Name,
                Server = srv.ServerName,
                // etc. use any property from rg, app, sg, srv, stat
            };

As you see -

• n - 1 associations are represented by a let statement (which really only helps here to shorten the references in the select )
• 1-n associations are represented by the from ... from syntax, which is query syntax for SelectMany .

I didn't change the Where clause in the query syntax. Maybe you can use ...

            where app.Name == application_name
               && env.Name == environment_name
               && stat.Name == status)

... but note that this is different. The original where returns all ResourceGroup having at least one ServerGroup meeting the condition (and maybe other groups with different environments and statuses). The other where only returns data with environments and statuses equal to the search parameters.

Answer 2

Don't Include all the related tables, but Select all the fields you need. You might find it easier to make a new class to hold the data.

Sorry if I can't make a real query statement here, but your question doens't specify the fields you need.