Appunti di studio C# - Analisi approfondita dei costruttori e dei distruttori

Costruttore, costruttore distruttore

Costruttore:

1. Se non viene fornito alcun costruttore, il sistema fornirà automaticamente un costruttore predefinito, inizializzando tutti i membri con valori di default (i tipi di riferimento sono null, i tipi di valore sono 0, il tipo bool è false);

2. Se viene fornito un costruttore con parametri, il sistema non fornirà un costruttore predefinito;

3. Il costruttore può essere sovraccaricato: è possibile fornire più versioni del costruttore, distinte in base al numero e al tipo dei parametri;

4. Costruttore privato: non è possibile istanziare l'oggetto tramite questo costruttore, è possibile istanziare tramite chiamata a funzione statica; quando viene utilizzato come contenitore per alcuni membri statici o proprietà, è possibile definire un costruttore privato per prevenire l'istanziazione;

I costruttori generali sono costruttori di istanza, eseguono il costruttore ogni volta che si crea un'istanza;

Costruttore statico:

1. Può essere definito solo uno, può essere eseguito una volta sola, viene chiamato dalla libreria runtime di .NET solo prima di chiamare qualsiasi membro della classe,

2. Non può avere alcun parametro, nessun modificatore di accesso, può accedere solo ai membri statici della classe, non può accedere ai membri delle istanze della classe;

3. Se la classe ha campi statici o proprietà che devono essere inizializzati dall'esterno prima di utilizzare la classe, utilizzare il costruttore statico;

4. Costruttore statico e costruttore di istanza senza parametri possono essere definiti contemporaneamente, non ci sarà conflitto su quando eseguire quale costruttore;

All'interno del costruttore è possibile chiamare altri costruttori stessi: this(), o i costruttori della classe base: base(), come se si potesse chiamare altri costruttori con la sintassi di ereditarietà;

Campo readonly: simile a una costante, il suo valore non può essere modificato. Il campo readonly deve essere dichiarato con readonly, può essere non inizializzato, può essere inizializzato nel costruttore e il suo valore non può essere modificato successivamente;

Instanziazione di tipo anonimo: var a = new { f1 = "1ad", f2 = "34", f3 = 5, f4 = 6 };

Costruttore: utilizzato per distruggere l'istanza della classe

• Non è possibile definire un costruttore distruttore all'interno di una struttura. Solo le classi possono utilizzare il costruttore distruttore.

• Un'istanza può avere solo un costruttore distruttore.

• Non è possibile ereditare o sovraccaricare il costruttore a distruzione.

• Non è possibile chiamare il costruttore a distruzione. Essi vengono chiamati automaticamente. Controllati dal garbage collector, se il garbage collector ritiene che un oggetto è pronto per essere distrutto, allora chiama il costruttore a distruzione (se esiste) e recupera la memoria utilizzata per questo oggetto. Il costruttore a distruzione viene anche chiamato quando il programma esce

• Il costruttore a distruzione non ha修饰符 né parametri

È possibile forzare la raccolta dei rifiuti chiamando Collect, ma è meglio evitare di farlo nella maggior parte dei casi, poiché può causare problemi di prestazioni

C# non richiede una gestione della memoria eccessiva. Questo è perché il garbage collector del .NET Framework gestisce implicitamente l'allocazione e la liberazione della memoria degli oggetti. Tuttavia, quando un'applicazione avvolge risorse non gestite come finestre, file e connessioni di rete, dovrebbe utilizzare il costruttore a distruzione per liberare queste risorse. Quando un oggetto è pronto per essere distrutto, il garbage collector esegue il metodo Finalize dell'oggetto.

Se la tua applicazione utilizza risorse esterne costose, ti consigliamo di fornire un modo per liberare esplicitamente le risorse prima che il cestino dei rifiuti liberhi l'oggetto. Questo può essere fatto implementando il metodo Dispose dell'interfaccia IDisposable, che esegue la pulizia necessaria per l'oggetto. Questo può migliorare notevolmente le prestazioni dell'applicazione. Anche con questo controllo esplicito delle risorse, il costruttore a distruzione è una misura di protezione, che può essere utilizzata per pulire le risorse se il chiamare il metodo Dispose fallisce

class Car
{
  -Car() 
  {
    // … …
  }
}

Il costruttore a distruzione chiama implicitamente ricorsivamente il metodo Finalize() su tutte le istanze della catena di ereditarietà

public class Bus
 {
   protected static readonly DateTime globalStartTime;
   protected int RouteNumber { get; set; }
   static Bus() //静态构造函数
   {
 globalStartTime = DateTime.Now;
 Console.WriteLine("Static ctor sets global start time to {0}", globalStartTime.ToLongTimeString());
   }
   public Bus(int routeNum)
   {
 RouteNumber = routeNum;
 Console.WriteLine("{0} is created.", RouteNumber);
   }
   public void Drive()
   {
 TimeSpan elapsedTime = DateTime.Now - globalStartTime;
 Console.WriteLine("{0} sta iniziando il suo percorso {1:N2} minuti dopo l'ora di inizio globale {2}.",
             this.RouteNumber,
             elapsedTime.TotalMilliseconds,
             globalStartTime.ToShortTimeString());
   }
 }
 class TestBus
 {
   static void Main()
   {
 Bus bus = new Bus(71);
 bus.Drive();
 System.Threading.Thread.Sleep(25);
 Bus bus2 = new Bus(72);
 bus2.Drive();
 System.Console.WriteLine("Premere qualsiasi tasto per uscire.");
 System.Console.ReadKey();
   }
 }
 /* Output:
   Il costruttore statico imposta l'ora di inizio globale a 10:04:08 AM
   71 è stato creato.
   71 sta iniziando il suo percorso 21.00 minuti dopo l'ora di inizio globale 10:04 AM.
   72 è stato creato.
   72 sta iniziando il suo percorso 46.00 minuti dopo l'ora di inizio globale 10:04 AM.   
*/

Questo è tutto il contenuto del tutorial di C# che ho raccolto per voi: analisi approfondita dei costruttori e dei distruttori, spero sia utile a tutti. Sostienete il tutorial urlando~