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);
}
}
