23 messaggi dal 09 marzo 2009
Salve,
vorrei aggiungere al SampleDataSource un metodo, che mi permetta di recuperare tutti i groups che hanno dei items che a sua volta hanno la proprietà Attivato="True".

quindi il mio sampledata.json è del tipo:

{"Groups":[
{
"UniqueId": "Group-1",
"Title": "Group Title: 1"
"Items":
[
{
"UniqueId": "Group-1-Item-1",
"Title": "Item Title: 1",
"Attivato": "true",

.....
}
]
},
{
"UniqueId": "Group-2",
......
.......



partendo dal metodo che recupera tutti i groups:

public static async Task<IEnumerable<SampleDataGroup>> GetGroupsAsync()
{
await _sampleDataSource.GetSampleDataAsync();
return _sampleDataSource.Groups;
}

vorrei crearne un altro, che recupera solo tutti i gruppi che hanno uno o + Item con Attivato=True.
del tipo

public static async Task<IEnumerable<SampleDataGroup>> GetGroupsAttivatoAsync()
{
await _sampleDataSource.GetSampleDataAsync();
return _sampleDataSource.Groups.Where(group => ((group.Items).Where((item) => item.Attivato == "True"));

}

mi da l'errore: Non è possibile convertire l'espressione lambda nel tipo delegato previsto, perchè alcuni tipi restituiti non sono convertibili...
Come si potrebbe scrivere correttamente la query?
inoltre:
Ho visto sul web altri approcci... del tipo:
nel sampledatasource c'è solo il metodo che carica tutti i groups,
mentre nella pagina di riferimento nel LoadState,
private async void navigationHelper_LoadState(object sender, LoadStateEventArgs e)

var groups = await SampleDataSource.GetGroupsAsync();

una volta caricati tutti i groups si cicla:
foreach (var group in groups)
{
var matchingItems = group.Items.Where(
item =>
item.Title......

}

per filtrare i gruppi in base ad un Searchbox ...
nel mio caso ho dei valori di ricerca fissi, quindi non è meglio caricare meno gruppi possibile già dal sampleDataSource?
o sono costretto a caricarli tutti e poi filtrarli?
Grazie tanto...
11.886 messaggi dal 09 febbraio 2002
Contributi
Ciao,
proviamo a lavorare su questa, che faceva parte della tua intuizione iniziale.
return _sampleDataSource.Groups.Where(group => ((group.Items).Where((item) => item.Attivato == "True"));


La Where si aspetta che tu fornisca un predicato, ovvero una lambda che restituisce true/false.
Al momento, invece, la tua lamba sta restituendo un elenco di elementi (te ne rendi conto portando il mouse sulla seconda Where, quella innestata dentro la prima).
Al posto della seconda Where dovresti usare l'extension method Any che invece restituisce proprio il true/false che ci serve. Restituirà true se almeno uno degli elementi risponde al criterio (Attivo == "true"), mentre restituirà false se non ce n'era nemmeno uno.
Quindi prova qualcosa del tipo:
public static async Task<IEnumerable<SampleDataGroup>> GetGroupsAttivatoAsync()
{
await _sampleDataSource.GetSampleDataAsync();
return _sampleDataSource.Groups.Where(group => group.Items.Any(item => item.Attivato == "true"));
}

Questo restituirà (se ho scritto bene) tutti i gruppi che hanno almeno un item attivato.

ciao,
Moreno
Modificato da BrightSoul il 04 maggio 2016 00.04 -

Enjoy learning and just keep making
23 messaggi dal 09 marzo 2009
... si funziona. Grazie Moreno, per la tuo continuo e professionale supporto.
Ti volevo chiedere, sempre a riguardo il SampleDataSource.cs la differenza concettuale tra il metodo base:

public static async Task<IEnumerable<SampleDataGroup>> GetGroupsAsync()
{
await _sampleDataSource.GetSampleDataAsync();

return _sampleDataSource.Groups;
}

e quello che mi hai aiutato a scrivere.....
o meglio quello di base, restituisce una collezione groups, che posso scorrere anche staticamente, come scrivendo groups[0], groups[1]... groups[0].items[0]..... ecc (per esempio come viene fatto nel template Hub nelle varie sezioni)

mentre questa cosa non è possibile farla nel metodo che mi hai aiutato a creare.... perchè restituisce un System.Linq.Enumerable.WhereWnumerableIteration... vero?.. o mi perdo qualcosa?
grazie
11.886 messaggi dal 09 febbraio 2002
Contributi
Ciao, prego :)


la differenza concettuale tra il metodo base e quello che mi hai aiutato a scrivere

Non ci sono differenze, infatti entrambi restituiscono un IEnumerable<SampleDataGroup> (non ha importanza quale sia il tipo derivato effettivamente restituito, perché l'utilizzatore si troverà tra le mani un un IEnumerable<SampleDataGroup> e normalmente lavorerà con le caratteristiche supportate da quello).

Con nessuno dei due metodi puoi accedere agli elementi dell'elenco usando l'indexer (ovvero accedere usando groups[0], groups[1], ecc..).
Infatti, come vedi dal sorgente, l'interfaccia IEnumerable<T> espone giusto un metodo (più uno ereditato) e non vi è traccia dell'indexer.

Se sei stato in grado di usarlo è perché, dopo aver invocato GetGroupsAsync(), hai usato un .ToList() o un .ToArray() sul valore restituito dal metodo, il che lo ha convertito in ICollection, che invece espone un indexer, come vedi qui.

Quindi, se hai la necessita di usare l'indexer (ovvero di accedere randomicamente alla collezione), usa prima un .ToList().

var elenco = await GetGroupsAttivatoAsync();
//Converto a collezione
var collezione = elenco.ToList();
//Accedo ad un elemento in particolare
var elemento = collezione[2];


ciao,
Moreno
Modificato da BrightSoul il 05 maggio 2016 20.55 -

Enjoy learning and just keep making

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.