Linq projection: Get reference of new projected entity - entity-framework

Question

I need to map EF entities to respective DTO. In the example below I have EF entities Parent and Child, and Child entity contains reference to Parent object. I also have ParentDto and ChildDto (DTO), and ChildDto contains reference to ParentDto (not Parent). So, how can I assign ParentDto reference to ChildDto instance in below method:
public Task<List<ParentDto>> Method()
{
return (Context.Set<Parent>()
.Where(someCondition)
.Select(p => new ParentDto
{
// here we map all properties from Parent to ParentDto
... ,
Children = p.Children.Select(c => new ChildDto
{
// here we map all properties from Child to ChildDto
... ,
Parent = ? // reference to newly created ParentDto instance
})
}).ToListAsync();
}

Answer 1

You have to use a variable but you can't do it in a lambda expression. You have to do the mapping in memory after calling ToListAsync():
public Task<List<ParentDto>> Method()
{
var parents = await (Context.Set<Parent>()
.Where(someCondition)
.ToListAsync());
return parents.Select(p =>
{
var parent = new ParentDto();
//map parent properties
parent.Children = p.Children.Select(c => new ChildrenDto
{
//map child properties
});
return parent;
}).ToList();
}

Answer 2

In regular LINQ (not to entities) this isn't possible because of an important feature of object initializers: atomic assignment. As you can read here, an object initialization like...
var c = new Customer() { Name = "Bart", City = "Redmond", Age = 24 };
...is equivalent to...
Customer __t = new Customer();
__t.Name = "Bart";
__t.City = "Redmond";
__t.Age = 24;
Customer c = __t;
So the object is created and fully initialized first and then its reference is exposed. Therefore, if inside the object another object is initialized, the nested object will never be able to grab a reference to its parent during the initialization phase. You can only assign the parent afterwards.
Although in LINQ-to-entities the mechanism of creating objects is entirely different, the initialization logic can be considered identical, and the same restrictions apply.
As you know, in LINQ-to-Entities we can't call instance methods of entities while we're in the query expression. Else you could, for instance, have called some method in Parent that constructs its children (and assigns itself to it as their parent). As it is now, the only thing you can do is construct the Parents with their nested parent.Children first and after that, traverse the parent.Children collections and assign their Parent to them (as in Ufuk's answer).