在 EF 查询中重用子查询

Question

I'm working with an unfortunately designed database where I need to essentially convert 8 columns to a 'sublist' for the row, and I'm using Entity Framework. I want to do it all in SQL/IQueryable so filtering etc can be applied afterwards.

I have the below code at the moment

 public static IQueryable<DTOs.Customer> ToDTO(this IQueryable<Customer> query, DBContext context)
    {
        return from c in query
            select new DTOs.Customer
            {
                CustomerID = c.CustomerID,
                AnalysisCodes = new List<AnalysisCodeWithValue>()
                {
                    context.AnalysisCodeMapping.Where(a => a.PropertyName == nameof(c.AnalysisCode1))
                        .Select(
                            a => new AnalysisCodeWithValue() {Name = a.AnalysisCode.Name, Value = c.AnalysisCode1})
                        .FirstOrDefault(),
                    context.AnalysisCodeMapping.Where(a => a.PropertyName == nameof(c.AnalysisCode2))
                        .Select(a => new AnalysisCodeWithValue {Name = a.AnalysisCode.Name, Value = c.AnalysisCode2})
                        .FirstOrDefault(),
                    context.AnalysisCodeMapping.Where(a => a.PropertyName == nameof(c.AnalysisCode3))
                        .Select(
                            a => new AnalysisCodeWithValue() {Name = a.AnalysisCode.Name, Value = c.AnalysisCode3})
                        .FirstOrDefault(),
                    context.AnalysisCodeMapping.Where(a => a.PropertyName == nameof(c.AnalysisCode4))
                        .Select(a => new AnalysisCodeWithValue {Name = a.AnalysisCode.Name, Value = c.AnalysisCode4})
                        .FirstOrDefault(),
                    context.AnalysisCodeMapping.Where(a => a.PropertyName == nameof(c.AnalysisCode5))
                        .Select(
                            a => new AnalysisCodeWithValue() {Name = a.AnalysisCode.Name, Value = c.AnalysisCode5})
                        .FirstOrDefault(),
                    context.AnalysisCodeMapping.Where(a => a.PropertyName == nameof(c.AnalysisCode6))
                        .Select(a => new AnalysisCodeWithValue {Name = a.AnalysisCode.Name, Value = c.AnalysisCode6})
                        .FirstOrDefault(),
                    context.AnalysisCodeMapping.Where(a => a.PropertyName == nameof(c.AnalysisCode7))
                        .Select(
                            a => new AnalysisCodeWithValue() {Name = a.AnalysisCode.Name, Value = c.AnalysisCode7})
                        .FirstOrDefault(),
                    context.AnalysisCodeMapping.Where(a => a.PropertyName == nameof(c.AnalysisCode8))
                        .Select(a => new AnalysisCodeWithValue {Name = a.AnalysisCode.Name, Value = c.AnalysisCode8})
                        .FirstOrDefault()
                }.Where(a => a != null && a.Value != string.Empty)
            };
    }

This works but as you can see thee's a lot of repetition for each 'analysis code'. I tried making the subquery a method that takes the property name and value, but EF complains that it can't convert the method call to SQL. Is there any way I can tidy this up to avoid the complicated repetition?

I'm also aware this may be slow, so I'm open to any other suggestions. Unfortunately we are unable to create any views, functions or SP's on the server

Thanks :)

Answer 1

It seems you have a sequence of Customers and a sequence of string Properties of the customer.

For every customer you want one new object. This new object contains the ID of the customer and a list of AnalysisCodeWithValues; one AnalysisCodeWithValue per property, containing the name of the property and the customer's value of this property

Let's do this using extension methods. See extension methods demystified

A procedure that takes a Customer, and a sequence of PropertyInfos that needs to be extracted from this customer. The return value is a sequence of AnalysisCodeWithValues; one AnalysisCodeWithValue per PropertyInfo, containing the name of the property and the string value.

public static IEnumerable<AnalysisCodeWithValue> ExtractProperties(this Customer customer, 
    IEnumerable<PropertyInfo> properties)
{
    // TODO: add Argument NULL checks

    foreach (PropertyInfo property in properties)
    {
        yield return new AnalysisCodeWithValues()
        {
             Name = property.Name,
             Value = property.GetValue(customer).ToString(),
        };
    }
}

Obviously this would lead to problems if GetValue would return null. You could use the null conditional operator for this to prevent problems:

Value = property.GetValue(customer)?.ToString() ?? String.Empty,

But since you are not interested in empty values anyway I'd go for:

foreach (PropertyInfo property in properties)
{
    string stringValue = property.GetValue(customer)?.ToString();
    if (!String.IsNullOrEmpty(stringValue))
    {
        yield return new AnalysisCodeWithValues()
        {
             Name = property.Name,
             Value = stringValue,
        };
    }
}

Usage would be:

Customer customer = ...
var allCustomerProperties = typeof(Customer).GetProperties()
     .Where(property => property.CanRead);
var customerPropertyValues = customer.ExtractProperties(allCustomerProperties);

Similarly if you have a sequence of Customers and a sequence of Properties you want to extract:

var result = myCustomers.Select(customer => new
{
    CustomerId = customer.Id,
    AnalysisCodes = customer.ExtractProperties(allCustomerProperties)
        .ToList();
}

This is a nice solution if you want most properties of a Customer. You can't make any typing errors that the compiler won't detect, because you don't type the names of the properties

Alas this won't work if you only want a few properties of the customers. In that case I'd go for delegates that extract the value. Added bonus: you can request for any value in the delegate, not only properties. You can call any function, even combine properties.

Disadvantage: you'll have to type the names per value that you want in your end result. Obviously, because you want to create your own values.

Input: a sequence of KeyValuePairs, where the Key is the Name of the AnalysisCodeWithValue and the value is the delegate that extracts the value from the Customer. Something like this:

var propertyToGet = new KeyValuePair<...>(
    "AnalysisCode1",
    customer => customer.AnalsysCode1);

or for more difficult value:

var propertyToGet = new KeyValuePair<...>(
    "Full name",
    customer => customer.FirstName + " " + customer.LastName);

The function will be like:

 public static IEnumerable<AnalysisCodeWithValue> ExtractProperties(this Customer customer, 
    IEnumerable<KeyValuePair<string, Func<Customer, object>> delegates)
{
    foreach (var requestedProperty in delegates)
    {
        var propertyValue = requestedProperty.Value(customer);
        string stringValue = propertyValue?.ToString();
        if (!String.IsNullOrEmpty(stringValue))
        {
            yield return new AnalysisCodeWithValues()
            {
                 Name = requestedProperty.Key,
                 Value = stringValue,
            };
        }
    }
}

usage:

var requestedProperties = new KeyValuePair<string, Func<Customer, object>>[]
{
    new KeyValuePair<string, Func<Customer, object>>(
        "Full customer name",
        customer => customer.FirstName + " " + customer.LastName),

    new KeyValuePair<string, Func<Customer, object>>(
        "Birthday",
        customer => customer.Birthday),

    new KeyValuePair<string, Func<Customer, object>>(
    {
         "Certificates after Year 2000",
         customer => customer.CalculateCertificates(new DateTime(2000, 1, 1,))
    },
}

Advantages: you can use the descriptions you like; you can use any function you like. The compiler will detect it if you make any typing errors.

Disadvantage: more code to type.

It is up to you to decide whether the advantages weigh up to the disadvantages