.NET Framework
Tipi personalizzati
Ricerca…
Osservazioni
In genere una struct viene utilizzata solo quando le prestazioni sono molto importanti. Poiché i tipi di valore vivono nello stack, è possibile accedervi molto più rapidamente delle classi. Tuttavia, lo stack ha molto meno spazio dell'heap, quindi le strutture dovrebbero essere ridotte (Microsoft consiglia struct s occupare non più di 16 byte).
Una class è il tipo più usato (di questi tre) in C #, ed è generalmente quello che dovresti fare prima.
Un enum viene utilizzato ogni volta che è possibile avere un elenco chiaramente definito di elementi che devono essere definiti solo una volta (in fase di compilazione). Le enumerazioni sono utili ai programmatori come riferimento leggero ad alcuni valori: invece di definire un elenco di variabili constant da confrontare, puoi usare un enum e ottenere il supporto Intellisense per assicurarti di non utilizzare accidentalmente un valore errato.
Definizione di Struct
Le strutture ereditano da System.ValueType, sono tipi di valore e vivono nello stack. Quando i tipi di valore vengono passati come parametro, vengono passati per valore.
Struct MyStruct
{
public int x;
public int y;
}
Passato per valore significa che il valore del parametro viene copiato per il metodo e qualsiasi modifica apportata al parametro nel metodo non viene riflessa all'esterno del metodo. Ad esempio, si consideri il seguente codice, che chiama un metodo denominato AddNumbers , passando le variabili a e b , che sono di tipo int , che è un tipo di valore.
int a = 5;
int b = 6;
AddNumbers(a,b);
public AddNumbers(int x, int y)
{
int z = x + y; // z becomes 11
x = x + 5; // now we changed x to be 10
z = x + y; // now z becomes 16
}
Anche se abbiamo aggiunto da 5 a x all'interno del metodo, il valore di a rimane invariato, perché è un tipo Value, e ciò significa che x era una copia del valore di a valore, ma non in realtà a .
Ricorda, i tipi di valore vivono nello stack e vengono passati per valore.
Definizione di classe
Le classi ereditano da System.Object, sono tipi di riferimento e vivono nell'heap. Quando i tipi di riferimento vengono passati come parametro, vengono passati per riferimento.
public Class MyClass
{
public int a;
public int b;
}
Passato per riferimento significa che un riferimento al parametro viene passato al metodo e tutte le modifiche al parametro si rifletteranno al di fuori del metodo quando ritorna, poiché il riferimento è esattamente allo stesso oggetto in memoria . Usiamo lo stesso esempio di prima, ma prima "intaschiamo" l' int s in una classe.
MyClass instanceOfMyClass = new MyClass();
instanceOfMyClass.a = 5;
instanceOfMyClass.b = 6;
AddNumbers(instanceOfMyClass);
public AddNumbers(MyClass sample)
{
int z = sample.a + sample.b; // z becomes 11
sample.a = sample.a + 5; // now we changed a to be 10
z = sample.a + sample.b; // now z becomes 16
}
Questa volta, quando abbiamo cambiato sample.a a 10 , cambia anche il valore di instanceOfMyClass.a , perché è stato passato per riferimento . Passato per riferimento significa che un riferimento (anche a volte chiamato puntatore ) all'oggetto è stato passato al metodo, anziché una copia dell'oggetto stesso.
Ricorda, i tipi di riferimento vivono nell'heap e vengono passati per riferimento.
Definizione Enum
Un enum è un tipo speciale di classe. La parola chiave enum dice al compilatore che questa classe eredita dalla classe System.Enum astratta. Le enumerazioni vengono utilizzate per elenchi distinti di elementi.
public enum MyEnum
{
Monday = 1,
Tuesday,
Wednesday,
//...
}
Puoi pensare a un enum come un modo conveniente di mappare le costanti ad un valore sottostante. L'enum definito sopra dichiara i valori per ogni giorno della settimana e inizia con 1 . Tuesday verrà automaticamente mappato a 2 , Wednesday 3 , ecc.
Per impostazione predefinita, enum usa int come tipo sottostante e inizia da 0, ma puoi usare uno qualsiasi dei seguenti tipi interi : byte, sbyte, short, ushort, int, uint, long, or ulong e puoi specificare valori espliciti per qualsiasi articolo. Se alcuni elementi sono specificati in modo esplicito, ma alcuni non lo sono, ogni elemento dopo l'ultimo definito verrà incrementato di 1.
Vorremmo utilizzare questo esempio lanciando qualche altro valore a un MyEnum in questo modo:
MyEnum instance = (MyEnum)3; // the variable named 'instance' gets a
//value of MyEnum.Wednesday, which maps to 3.
int x = 2;
instance = (MyEnum)x; // now 'instance' has a value of MyEnum.Tuesday
Un altro utile, anche se più complesso, tipo di enum è chiamato Flags . Decorando un enum con le Flags di attributo, è possibile assegnare un più di un valore variabile alla volta. Si noti che quando si esegue questa operazione è necessario definire esplicitamente i valori nella rappresentazione di base 2.
[Flags]
public enum MyEnum
{
Monday = 1,
Tuesday = 2,
Wednesday = 4,
Thursday = 8,
Friday = 16,
Saturday = 32,
Sunday = 64
}
Ora è possibile confrontare più di un valore alla volta, utilizzando confronti bit a bit o, se si utilizza .NET 4.0 o Enum.HasFlag successive, il metodo Enum.HasFlag .
MyEnum instance = MyEnum.Monday | MyEnum.Thursday; // instance now has a value of
// *both* Monday and Thursday,
// represented by (in binary) 0100.
if (instance.HasFlag(MyEnum.Wednesday))
{
// it doesn't, so this block is skipped
}
else if (instance.HasFlag(MyEnum.Thursday))
{
// it does, so this block is executed
}
Poiché la classe Enum è sottoclasa da System.ValueType , viene trattata come un tipo di valore e passata per valore, non per riferimento. L'oggetto base viene creato sull'heap, ma quando si passa un valore enum in una chiamata di funzione, una copia del valore utilizzando il tipo di valore sottostante dell'Enum (in genere System.Int32) viene inserita nello stack. Il compilatore tiene traccia dell'associazione tra questo valore e l'oggetto di base creato nello stack. Vedi ValueType Class (System) (MSDN) per ulteriori informazioni.