37 messaggi dal 18 agosto 2006
Ciao a tutti,
Avrei bisogno di un consiglio su come realizzare una Collezione generica che esponga un ulteriore metodo Add il quale oltre ad accettare l'elemento da aggiungere alla lista, accetti anche un oggetto esterno per la comparazione tra gli oggetti presenti in lista e quello appena aggiunto.

Quindi ho pensato di scrivere una cosa del genere:

MyList<T> : List<T> where T : Icomparable
{
public void AddToCompare(T item, IComparable compare)
{
....
}
}

L'Idea sarebbe questa ma non so come implemetare il resto del codice.
Ovviamente qualsiasi altra soluzione e ben accetta.

Grazie Mille
Daniele
Suppongo che la logica che tu vuoi implementare sia di non fare l'inserimento nel caso in cui sia già presente un elemento simile.
invece di usare IComparable potresti usare un Func che dati due elementi ti restituisca un bool.
Qualcosa tipo:
public bool AddToCompare(T newItem, Func<T, T, bool> comparer)
        {
            foreach (var item in this)
            {
                if (comparer(item, newItem))
                    return false;
            }
            return true;
        }


In alternativa, se non hai altre esigenze particolari, visto che erediti direttamente da List<T, potresti anche evitare totalmente di scrivere una classe ed usare un extension method:
public static bool AddToCompare<T>(this List<T> list, T newItem, Func<T, T, bool> comparer) where T :IComparable
        {
            foreach (var item in list)
            {
                if (comparer(item, newItem))
                    return false;
            }
            return true;
        }

Modificato da mizrael il 04 ottobre 2010 09.16 -

Davide Guida
Developer, Data Manager @ Publicis Healthware
http://davideguida.netne.net
37 messaggi dal 18 agosto 2006
Ciao MizRal,
grazie mille per evermi risposto.
Nel caso della classe MyList<T>, potresti farmi un esempio di implementazione del metodo AddToCompare da parte del codice client.

Non ho capito molto bene come devo scivere il codice per il secondo parametro.

Grazie ancora
Func<T, T, bool> può essere un qualunque metodo che prenda in input due istanze degli oggetti da confrontare e ti restituisca un bool.

Supponiamo tu abbia una classe tipo questa:
public class MyClass
{
   public int Value = 0;
}


una possibile implementazione del comparer potrebbe essere:
public bool MyComparer(MyClass a, MyClass b)
{
   return a.Value == b.Value;
}


A questo punto non devi far altro che invocare AddToCompare su un'istanza della tua lista :
var list = new MyList<MyClass>();
list.Add(new MyClass() { Value = 1 });
list.Add(new MyClass() { Value = 2 });
list.Add(new MyClass() { Value = 3 });

// verrà aggiunto
var obj1 = new MyClass { Value = 4 };
list.AddToCompare(obj1, MyComparer); 

// NON verrà aggiunto
var obj2 = new MyClass { Value = 1 };
list.AddToCompare(obj1, MyComparer); 


Davide Guida
Developer, Data Manager @ Publicis Healthware
http://davideguida.netne.net
Scusami, mi sono appena accorto che AddToCompare non aggiunge un bel niente XD
public bool AddToCompare(T newItem, Func<T, T, bool> comparer)
        {
            foreach (var item in this)
            {
                if (comparer(item, newItem))
                    return false;
            }
            this.Add(newItem); // mancava :D
            return true;
        }

Davide Guida
Developer, Data Manager @ Publicis Healthware
http://davideguida.netne.net
37 messaggi dal 18 agosto 2006
Grazie ancora.
Alla prossima.

Ciao Daniele :)
DanEsp ha scritto:
Grazie ancora.
Alla prossima.

Di nulla!
Modificato da mizrael il 04 ottobre 2010 10.21 -

Davide Guida
Developer, Data Manager @ Publicis Healthware
http://davideguida.netne.net

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.
Community
Ultimi messaggi
UTENTI ONLINE
In primo piano

I più letti di oggi

Media
In evidenza
MISC