Manage data in a .NET Framework application using .NET Framework 2.0 system types (System namespace)
Eccezioni: System.Exception è la classe base di tutte le eccezioni ed interrompono il flusso normale di lavoro dell’applicazione per un errore. Un’eccezione viene gestita dall’applicazione o dal gestore degli errori predefiniti.
Riassumento le eccezioni si intercettano con Try- Catch, dove il catch puo’ essere catch(1), catch(2)... per distinguere a priori su diversi tipi di eccezioni e prenderle in modo gerarchizzato...
Dopo il blocco Try-Catch il Finally viene sempre eseguito, in genere utilizzato per liberare risorse.
C’e’ un ApplicationException che indica un errore irreversibile, ma la guida consiglia di derivare le proprie eccezioni da System.Exception.
Per generare un’eccezione si usa: throw new myException(..parametri);
http://msdn2.microsoft.com/it-it/library/system.exception(VS.80).aspx
Boxing/Unboxing. E’ la tecnica con cui si passano da ValueType a ReferenceType.
object o = i; BOX: dove i è il classico intero o un altro valueType
int i = (int)o; UNBOX: per ottenere il valore indietro.
Ma per sapere cosa c’e’ dentro ad un oggetto.. if (o is int)....
http://www.csharpfriends.com/Articles/getArticle.aspx?articleID=38
TypeForwardedToAttribute: specifica un tipo che si trova in un altro assembly e serve per riorganizzare la posizione delle classi negli assembly senza dover modificare i chiamanti e quindi l’intera applicazione L’idea è semplice
stato iniziale:
· In un assembly A c’e’ una classe X con i suoi metodi
· Altri assembly dell’applicazione utilizzano la classe.
Dopo la ristrutturazione:
· In un assembly B c’e’ la classe X con i suoi metodi, stesso namespace
· Dall’assembly A è stata CANCELLATA la classe X
· Nell’assembly A è stata inserito il riferimento all’assembly B
· Nell’assembly A è stata messa una direttiva del tipo:
[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(mionamespace.X)]
· Nell’applicazione vengono messi i due nuovi assembly A e B
· L’applicazione non viene ricompilata, continua a pensare di guardare la libreria A, quest'ultima fa poi la ridirezione a B.
J A me ricorda il concetto della dichiarazione extern, anche se quella era solo per la compilazione, non per il runtime.
http://msdn2.microsoft.com/en-us/library/system.runtime.compilerservices.typeforwardedtoattribute.aspx
Manage data in a .NET Framework application using .NET Framework 2.0 system types (System namespace)
Generics: fanno riferimento a classi e metodi che lavorano allo stesso modo su differenti tipi di oggetti. Quando vengono istanziati, necessitano sempre di un tipo di dati, cosi’ da dargli un “preciso significato” e rappresentano l’implementazione in C# dei template del C++.
Uno dei vantaggi dei generics è quello di far risparmiare sul boxing/unboxing: la collezione generica “List” è l’equivalente di “ArrayList”, se ci mettiamo degli interi o dei double o un altro valueTypes non c’e’ boxing per inserire i dati e unboxing per leggere, cosa decisamente apprezzabile in termini di performance.
Gli esempi in rete implementano tutti gli stack.
Allora faccio una lista :
public class myList1< T > {
….
public void Add(T newValue) {…….}
}
E la cosa bella è che in una lista di interi dichiarata con non ci posso mettere dei double e fare confusione. :-)
Voglio pero’ fare in modo che la lista sia sempre ordinata, indipendentemente dal tipo di contenuto. Faccio una lista 2 e gli dico che il tipo T, implemente l’interfaccia IComparable, cosi’ che poi posso fare una funzione di Add sfrutti il metodo CompareTo. (I tipi di base sono tutti derivati da IComparable!).
public class myList2<T> where T : System.IComparable<T>
{
const int minSize = 10;
private T[] myData = new T[minSize];
private int size=0;
public void Add(T newValue)
{ //tralascio tutti gli oggetti piu' piccoli
int destPos = 0;
for (; destPos < size && myData[destPos].CompareTo( newValue)< 0; destPos++) ;
//sposto tutti quelli piu' grandi
for (int moveThis = size-1; moveThis >= destPos; moveThis--)
myData[moveThis + 1] = myData[moveThis];
//inserisco nel posto libero il mio
myData[destPos] = newValue;
//aggiorno la dimensione ed eventualmente allargo l'array
size++;
if (size == myData.Length) enlargeArray();
}
public void Display(string msg)
{
Console.WriteLine(msg);
for (int i = 0; i < size; i++)
Console.WriteLine(myData[i].ToString() + " ");
}
public void enlargeArray() {...}
}
Deve andare con i tipi di base, con i double, con qualsiasi cosa che implementi l’IComparer, anche un ValueType. Modifico la classe PuntoStruct di alcuni giorni fa:
public struct PuntoStruct: IComparable < PuntoStruct >
{
private double _x, _y, _z;
public PuntoStruct(double x1, double y1, double z1) {…}
public int CompareTo( PuntoStruct other)
{
//faccio un ordinamento solo per X, tanto per provare
return (_x.CompareTo(other._x));
}
public override string ToString() {
return (string.Format("x = {0}, y ={1}, z = {2}", _x, _y, _z)); }
};
Se la uso posso istanziare tranquillamente sia una lista di interi:
myList2<int> lista2 = new myList2<int>();
che una lista dei miei punti
myList2<PuntoStruct > listaPunti = new myList2<PuntoStruct>();