static void Main(string[] args) { List <int> lst = new List <int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; //costruisco una lista di interi FilterInt filterOdd = new FilterInt(IsOdd); //costruisco un delegate con dentro un metodo ben preciso //List<int> result = FilterInts(lst, filterOdd); //invoco il delegate passandogli i parametri //List<int> result2 = FilterInts(lst, IsEven); //MyDelegate lambda = (i, s) => //{ // if (i > s.Length) // return true; // else // return false; //}; //NewDelegate new_lambda = () => { return true; }; //List<int> result = FilterInts(lst, i => (i % 2) == 1); //lambda expression List <int> result = FilterInts(lst, i => (i & 1) == 1);//altro modo con l'&: fa l'end bit a bit foreach (var item in result) { Console.WriteLine(item); } Console.ReadLine(); }
static void Main(string[] args) { List <int> lst = new List <int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; FilterInt filterOdd = new FilterInt(IsOdd); List <int> result1 = FilterInts(lst, filterOdd); List <int> result2 = FilterInts(lst, IsEven); MyDelegate lamda = (i, s) => { if (i > s.Length) { return(true); } else { return(false); } }; NewDelegate newLambda = () => { return(true); }; //List<int> result = FilterInts(lst, i => (i % 2) == 1); List <int> result = FilterInts(lst, i => (i & 1) == 1); foreach (var item in result) { Console.WriteLine(item); } }
static void Main(string[] args) { List <int> lst = new List <int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; FilterInt filterOdd = new FilterInt(IsOdd); List <int> result = FilterInts(lst, IsOdd); //posso fare il filtro IsEven, senza cambiare FilterInts //non creo il delegate, lo crea direttamente il compilatore //List<int> result = FilterInts(lst, IsEven); //terzo metodo //List<int> result = FilterInts(lst, i => (i % 2) == 1); MyDelegate lambda = (i, s) => { if (i > s.Length) { return(true); } else { return(false); } }; NewDelegate newlambda = () => { return(true); }; foreach (var item in result) { Console.WriteLine(item); } Console.ReadLine(); }
static void Main(string[] args) { /*il Main passa a FilterInts una lista di interi e un Delegate. * FilterInts riceve questa lista, cicla su ciascun elemento e per ognuno * stabilisce, applicando il filtro, se l'elemento andrà a far parte della nuova lista. * Il Delegate punterà ad un metodo che, dato un intero, decide se, ad esempio, è pari o dispari */ List <int> lst = new List <int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; //1° modo FilterInt filterOdd = new FilterInt(IsOdd); List <int> result = FilterInts(lst, filterOdd); //2° modo List <int> result2 = FilterInts(lst, IsEven); //nel primo caso passo davvero un delegate, nel secondo caso il passaggio è implicito: lo fa il compilatore. //è una facility sintattica. //3° modo //lambda-expression List <int> result3 = FilterInts(lst, i => (i % 2) == 1); /*avremmo potuto scrivere: * List<int> result3 = FilterInts(lst, i => (i & 1) == 1); * & è l'operatore "and bitwise", che per ogni bit mi restituisce true se sono entrambi 1 e false se uno dei due è 0 (vede 1 come true e 0 come false). * Quindi facendo i&1 otterrò tutti 0 per le prime cifre, invece per l'ultima otterrò 1 se "i" in binario termina con 1, cioè se è dispari, mentre otterrò 0 se * "i" termina con 0, cioè se è pari. */ //l'input è sempre un delegate: nel primo caso passo davvero il delegate, nel secondo caso passo //il nome di un metodo, che poi viene trasformato in un delegate, nel terzo passo una lambda-expression, //che è sintatticamente un delegate. Essa è una funzione che ha un parametro di input (a sx della freccia) //ed un parametro di output (a dx della freccia). In questo caso i parametri vengono letti del tipo richiesto da //FilterInt, che è ciò che prende in input la funzione FilterInts foreach (var item in result) { Console.WriteLine(item); } foreach (var item in result2) { Console.WriteLine(item); } //cosa a caso sotto per provare: MyDelegate l = (i, s) => { if (i > s.Length) { return(true); } else { return(false); } }; //questo ora è un delegate a cui è assegnato il metodo "l". Questo si può dare poi in pasto ad un metodo che prende in input un //parametro di tipo MyDelegate. }
//ti do una lista di interi, mi restituisci la lista filtrata public static List <int> FilterInts(List <int> inputlst, FilterInt filter) { List <int> resultList = new List <int>(); //lista vuota foreach (var item in inputlst) { if (filter(item)) //ivoco il metodo IsOdd { resultList.Add(item); //qui avrò solo i numeri dispari } } return(resultList); }
public static List <int> FilterInts(List <int> inputList, FilterInt filter) { List <int> resultList = new List <int>(); foreach (var item in inputList) { if (filter(item)) { resultList.Add(item); } } return(resultList); }
public static List <int> FilterInts(List <int> inputList, FilterInt filter) { List <int> resultList = new List <int>(); foreach (var item in inputList) { if (filter(item)) { resultList.Add(item); } //qui si sta invocando il metodo IsOdd } return(resultList); }
// creo un metodo che mi ritorna una lista di interi a partire da una lista di interi e u // e da un delegate (FilterInts non sa come impleenta il filreo FilterInt fitler) public static List <int> FilterInts(List <int> inputlst, FilterInt filter) //metodo y a cui voglio passare metodo x { List <int> resultList = new List <int>(); // creo lista vuota, va creata ma non inizializzata foreach (var item in inputlst) { if (filter(item)) // filter è un delegate che contiene l'indirizzo di IsOdd, quindi sto invocando il metodo col putnatore { resultList.Add(item); } } return(resultList); }
static void Main(string[] args) { List <int> lst = new List <int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // costruisco lsita input //passaggio di un metodo x a un metodo y FilterInt filterOdd = new FilterInt(IsOdd); // costruisco il filtro che è un delegate di tipo FilterInt //1 List<int> result = FilterInts(lst, filterOdd); //passo il delegate //2 oppure List <int> result= FilterInts(lst, IsEven); // passo direttamente il metodo e lui fa il delegate // 3 oppure lambda expression (che è un delegate sintatticamente List <int> result = FilterInts(lst, i => (i % 2) == 1); // la stessa lambda expression posso scriverla cosi: List<int> result = FilterInts(lst, i => (i & 2) == 1); // & bit a bit foreach (var item in result) { Console.WriteLine(item); } }