Ik heb je vraag opnieuw gelezen, vooral het laatste deel waar je zei dat je al .Ancestors
hebt, en nu is het logischer.
Doe dit om uw lijst met te verwijderen items te bekijken:
List itemsToDelete = myItems
.Where(i => i.Id == myItemId)
.SelectMany(i => i.Ancestors)
.Concat(myItems)//Want to delete these too, not just the ancestors
.ToList()
;
Vervolgens kunt u foreach
door het resultaat halen en ze uit de oorspronkelijke lijst verwijderen.
I'd suggest keeping these in a Dictionary
or a HashSet
instead of a list, since removal will be way faster.
For a HashSet
, you'll have to implement Equals
and GetHashCode
, or create an IEqualityComparer
implementation to provide those methods.
Voor bewerking:
I wouldn't write my code this way. I'd simply create a Dictionary
instead of a list. It will do a lookup way faster than anything involving ancestors/tree traversal.
Maar hier is hoe te bereiken wat u probeert te bereiken:
Als u Linq to Objects gebruikt (in tegenstelling tot Linq to SQL of Linq to Entities), maakt u een eigenschap met de naam Parent
op MyClass
, van het juiste type, in plaats van proberen om ze te linken met Id
.
Dan kunt u een eigenschap Voorouders
vrij eenvoudig maken:
public IEnumerable Ancestors
{
get
{
MyClass current = this;
while(current != null)
{
current = current.Parent;
yield return current;
}
}
}
Als u de klasse niet kunt bewerken, maakt u een uitbreidingsmethode met de naam GetAncestors
.
Dan kun je iets gebruiken dat erg lijkt op de code die je in je vraag hebt geschreven:
List itemsToDelete = myItems
.Where(i => i.Ancestors.Any(a => a.Id == myItemId))
.ToList();
Linq to Entities
Als u Linq voor entiteiten gebruikt, maakt u een navigatie-eigenschap van het type MyClass
om naar het bovenliggende element te navigeren en hetzelfde te doen. Houd er rekening mee dat dit re-query's kan veroorzaken. Weet niet zeker of de Linq kan of zou worden vertaald in een hiërarchische query.