There's a small issue with m:n relations I think, as 'PathElementCreator.CreateRelation' can't handle 2 relations. I'll add that code.

(edit) ok the code compiles, I'll now port the unittests for prefetch paths over to the new API and give it a spin It will be tomorrow for a new release though.

I just ran into the m:n issue myself Sorry about that.

This should fix it:

/// <summary>
/// Creates the prefetch path element.
/// </summary>
/// <returns>ready to use prefetch path element</returns>
public IPrefetchPathElementCore CreatePrefetchElement()
{
    IRelationCollection relationsBetweenSourceAndDestination = _sourceInstance.GetRelationsForFieldOfType(_propertyName);
    IEntityRelation pathElementRelation = (IEntityRelation)relationsBetweenSourceAndDestination[0];
    IRelationCollection filterRelations = null;
    RelationType typeOfPathElementRelation = pathElementRelation.TypeOfRelation;

    if(relationsBetweenSourceAndDestination.Count>1)
    {
        // m:n relation
        // obtain the relations again, as we've to reset the aliases on the pathElementRelation, so we need to prevent from modifying the relation
        // inside the collection.
        filterRelations = _sourceInstance.GetRelationsForFieldOfType(_propertyName);
        pathElementRelation.SetAliases(string.Empty, pathElementRelation.AliasEndEntity);
        typeOfPathElementRelation = RelationType.ManyToMany;
    }
    else
    {
        pathElementRelation = (IEntityRelation)relationsBetweenSourceAndDestination[0];

    }

    if(_isSelfServicing)
    {
        return new PrefetchPathElement(
            CreateEntityCollectionSelfServicing(),
            pathElementRelation, _sourceInstance.LLBLGenProEntityTypeValue,
            _destinationInstance.LLBLGenProEntityTypeValue,
            0,
            null,
            null,
            filterRelations,
            _propertyName,
            typeOfPathElementRelation
            );
    } 
    else 
    {
        return new PrefetchPathElement2(
            CreateEntityCollectionAdapter(),
            pathElementRelation, _sourceInstance.LLBLGenProEntityTypeValue,
            _destinationInstance.LLBLGenProEntityTypeValue,
            0,
            null,
            null,
            filterRelations,
            null,
            _propertyName,
            typeOfPathElementRelation
            );
    }
}

I had a bit of a problem writing this:

.WithPath(new PathEdge<OrderEntity>(CustomerEntity.PrefetchPathOrders,
                           new PathEdge<EmployeeEntity>(OrderEntity.PrefetchPathEmployee)),
                   new PathEdge<EmployeeEntity>(CustomerEntity.PrefetchPathEmployeeCollectionViaOrder));

with your code. The main hickup I had was: do I have to specify another Subpath or not? But it turned out to be not the case:

.WithPath(customerPath => customerPath
        .Prefetch<OrderEntity>(c => c.Orders).SubPath(orderPath => orderPath.Prefetch(o => o.Employee))
        .Prefetch<EmployeeEntity>(c => c.EmployeeCollectionViaOrder));

What I'm a bit struggling with, but that's the same as with my api I think, is that it's not that intuitive at first, also because of the classes in the tooltip info. But I think that's unavoidable... After you realize you've to specify .Prefetch for nodes at the same level and .SubPath for nodes below the current level, it's ok

I really like the way you have solved it via the lambdas, very clever

I'll change 'Limit' into 'LimitTo' (or is LimitBy better english? )

Otis wrote:

I really like the way you have solved it via the lambdas, very clever

Thanks

Otis wrote:

I'll change 'Limit' into 'LimitTo' (or is LimitBy better english? )

I think LimitTo sounds better.

Ok LimitTo it is

Selfservicing has some issues with destination type, ('OrderCollection' is the destination type instead of OrderEntity), will fix that. All adapter tests run already so almost there (the issue is introduced by me cleaning up GetPrefetchElementType )

(edit) ok DONE

I'll now cram in Skip and a WithPath(IPrefetchPath(2)) overload and will release a new build

I thought of some tiny issue... sorting on related entity's fields:

var q = (from od in metaData.OrderDetail
         where od.ProductId > 10
         select od).WithPath(p => p.Prefetch<OrderEntity>(od => od.Order).OrderBy(o => o.Customer.Country));

With the pathedge stuff, this isn't possible, as you have to specify the sortexpression, but you can't specify a relation collection to join the related entity with. I realize this is an oversight, however for the pathedges this isn't really addable, it would otherwise require awkward relation object additions.

What I'll try to do is to wrap the lambda passed into OrderBy()/OrderByDescending() to add these to a new SortClauseExpression list inside pathedge, as these handle the correlation relations automatically.

I said something stupid here... ignore

Ah right, I assumed that creating the PrefetchPathElement was necessary as PathEdge<T> requires it in the ctor. If this isn't the case, then this certainly simplifies things a bit.

Jez wrote:

Ah right, I assumed that creating the PrefetchPathElement was necessary as PathEdge<T> requires it in the ctor. If this isn't the case, then this certainly simplifies things a bit.

Nah, my bad, it is altered later on indeed. I overlooked that fragment in my code.

Ok, works!

It's available

Woohoo