LINQ inheritance "Down-Cast" with a new Property

Question

I have the following two classes:

public class Base
{
    public int Id { get; set; }
    public string PropertyA { get; set; }
}

[NotMapped]
public class Derived : Base
{
    public string PropertyB { get; set; }
}

And I have the following Query:

var baseQ = from b in db.Bases
            let propertyB = SomeCalculation()
            select new { Base = b, PropertyB = propertyB };

This works as is. What i want is something like this (Pseudo-Code):

List<Derived> list =  (from b in db.Bases
                      let propertyB = SomeCalculation()
                      select new { Base = b, PropertyB = propertyB }).ToList();

Is it possible to "Down-Cast" the selection to a derived class, or do I have to write a Constructor for the Derived class which looks something like this:

public Derived(Base b, string b) { ... }

My final solution: I changed the Derived Class to the following (since you even can't use a string.Format in the object initializer):

public class Derived
{
    public Base Base { get; set; }
    public string PropertyB { get; set; }

    public string CalculatedProperty { get { ... } }//For string.Format and other stuff
}

And I'm doing the assignement as follows:

List<Derived> list =  (from b in db.Bases
                      let propertyB = SomeCalculation()
                      select new Derived { Base = b, PropertyB = propertyB }).ToList();

score 3 · Accepted Answer · answered Nov 22 '11 at 15:57

3

You can't cast in this case since what your query returns is an anonymous type. Instead, you could use an object initializer to set the properties to the Derived class:

List<Derived> list = (from b in db.Bases
                     let propertyB = SomeCalculation()
                     select new Derived
                     {
                         Id = b.Id,
                         PropertyA = b.PropertyA,
                         PropertyB = propertyB
                     }).ToList();

If you have a ton of properties you could take the approach you suggested, or add a Data Transfer Object (DTO) that contains your properties, then use a library like AutoMapper to perform the mapping for you.

answered Nov 22 '11 at 15:57

Ahmad Mageed

94,561
19
163
174

Assuming `db` is a datacontext this will throw the old 'Cannot constructor a `Derived` because it's a non-scalar' type error. You'll need to retrieve the `Bases` to a collection before performing the select. – Kirk Broadhurst Nov 23 '11 at 04:51
In my case, DB is a DbContext. So, this is working. I will go with a Constructor for my class. A DTO seems like too much for this simple scenario. :) – Shion Nov 23 '11 at 06:52
@Kirk: You are right! This won't work. I somehow overread part of you answer. So is the way to dos this the object initializer? :) – Shion Nov 23 '11 at 06:57

Reza ArabQaeni · Answer 2 · 2011-11-23T07:45:11.523

1

List<Derived> list = db.Bases.ToList()
.Select(p => new Derived()
                 {
                     Id = b.Id,
                     PropertyA = b.PropertyA,
                     PropertyB =  SomeCalculation(),
                 }).ToList();;

edited Nov 23 '11 at 07:45

answered Nov 23 '11 at 01:49

Reza ArabQaeni

4,848
27
46

This will return an empty list, because none of the `Bases` are `DerivedTypes` - we can see that a `DerivedType` is actually a `Base` with an extra calculated property (`let propertyB = SomeCalculation()`) – Kirk Broadhurst Nov 23 '11 at 04:50
1

Altough this works, it's not what I need. The calculation uses stuff from inside the Query (it's not actually a method). The other thing is: This will select every Base in my DataBase. Wouldn't be very efficient ;). – Shion Nov 23 '11 at 07:43

score 0 · Answer 3 · answered Nov 23 '11 at 22:16

The accepted answer won't work because EF won't let you construct concrete types in the database. The workaround - it does allow you to select anonymous types.

Building on Ahmad's answer:

var aList = (from b in db.Bases
             let propertyB = SomeCalculation()
             select new 
             {
                 Id = b.Id,
                 PropertyA = b.PropertyA,
                 PropertyB = propertyB
             }).ToList(); 

List<Derived> list = (from a in aList
                      select new Derived
                      {
                          Id = a.Id,
                          PropertyA = a.PropertyA,
                          PropertyB = a.PropertyB
                      }).ToList();

Calling ToList on your query forces the query to be executed and the data to be retrieved into your application (i.e. it will no longer be executed in the database). aList is now a list in memory, so you can select the items into new Derived objects.

In simplest terms, the problem is that everything up until you call ToList is compiled into a SQL query (to improve efficiency). This is normally a good thing, but the issue is that your database has no concept of Derived and the query select new Derived can't be converted into SQL.

I agree with you. Unfortunately, the accepted answer works as well. It compiles, it runs, and it gets the desired results. I'll check if there are any performance differences between that solution and your new solution. Thanks. — Shion, Nov 24 '11 at 07:25
@Shion If it works, go with it. I didn't think that it would. — Kirk Broadhurst, Nov 24 '11 at 11:12

LINQ inheritance "Down-Cast" with a new Property

3 Answers3