C # è un linguaggio di programmazione moderno, generico e orientato agli oggetti sviluppato da Microsoft. C # è progettato per Common Language Infrastructure (CLI), che consiste nel codice eseguibile e nell'ambiente di runtime che consente l'uso di vari linguaggi di alto livello su diverse piattaforme e architetture di computer.
Un array Jagged è un array di array.
Puoi inizializzare un array frastagliato come -
int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};Dove, score è un array di due array di numeri interi - score [0] è un array di 3 numeri interi e score [1] è un array di 4 interi.
Ci sono tre modi in cui i parametri possono essere passati a un metodo:
Value parameters- Questo metodo copia il valore effettivo di un argomento nel parametro formale della funzione. In questo caso, le modifiche apportate al parametro all'interno della funzione non hanno effetto sull'argomento.
Reference parameters- Questo metodo copia il riferimento alla posizione di memoria di un argomento nel parametro formale. Ciò significa che le modifiche apportate al parametro influiscono sull'argomento.
Output parameters - Questo metodo aiuta a restituire più di un valore.
Sì! Utilizzo dei parametri di output. Un'istruzione return può essere utilizzata per restituire un solo valore da una funzione. Tuttavia, utilizzando i parametri di output, è possibile restituire due valori da una funzione.
I parametri di output sono simili ai parametri di riferimento, tranne per il fatto che trasferiscono i dati fuori dal metodo anziché in esso. Il parametro di riferimento copia il riferimento alla posizione di memoria di un argomento nel parametro formale. Ciò significa che le modifiche apportate al parametro influiscono sull'argomento.
Uno spazio dei nomi è progettato per fornire un modo per mantenere un insieme di nomi separato da un altro. I nomi delle classi dichiarati in uno spazio dei nomi non sono in conflitto con gli stessi nomi delle classi dichiarati in un altro.
La parola chiave using viene utilizzata per includere uno spazio dei nomi nel programma. Un programma ha generalmente più istruzioni using.
Alle variabili del tipo di valore può essere assegnato direttamente un valore. Sono derivati dalla classe System.ValueType.
I tipi di valore contengono direttamente dati. Alcuni esempi sono int, char e float, che memorizza rispettivamente numeri, alfabeti e numeri in virgola mobile. Quando si dichiara un tipo int, il sistema alloca memoria per memorizzare il valore.
I tipi di riferimento non contengono i dati effettivi memorizzati in una variabile, ma contengono un riferimento alle variabili.
In altre parole, si riferiscono a una posizione di memoria. Utilizzando più variabili, i tipi di riferimento possono fare riferimento a una posizione di memoria. Se i dati nella posizione di memoria vengono modificati da una delle variabili, l'altra variabile riflette automaticamente questo cambiamento di valore. Esempi di tipi di riferimento incorporati sono: oggetto, dinamico e stringa.
Il tipo di oggetto è la classe di base definitiva per tutti i tipi di dati in C # Common Type System (CTS). Object è un alias per la classe System.Object. Ai tipi di oggetto possono essere assegnati valori di qualsiasi altro tipo, tipo di valore, tipo di riferimento, tipo predefinito o definito dall'utente. Tuttavia, prima di assegnare valori, è necessaria la conversione del tipo.
Quando un tipo di valore viene convertito in un tipo di oggetto, viene chiamato boxing.
Quando un tipo di oggetto viene convertito in un tipo di valore, viene chiamato unboxing.
È possibile memorizzare qualsiasi tipo di valore nella variabile del tipo di dati dinamico. Il controllo del tipo per questi tipi di variabili viene eseguito in fase di esecuzione.
La sintassi per la dichiarazione di un tipo dinamico è -
dynamic <variable_name> = value;Per esempio,
dynamic d = 20;I tipi dinamici sono simili ai tipi di oggetto tranne per il fatto che il controllo del tipo per le variabili del tipo di oggetto avviene in fase di compilazione, mentre quello per le variabili di tipo dinamico avviene in fase di esecuzione.
Le variabili del tipo di puntatore memorizzano l'indirizzo di memoria di un altro tipo. I puntatori in C # hanno le stesse funzionalità dei puntatori in C o C ++.
La sintassi per la dichiarazione di un tipo di puntatore è -
type* identifier;Per esempio
char* cptr;
int* iptr;L'operatore is determina se un oggetto è di un certo tipo.
If (Ford is Car) // controlla se Ford è un oggetto della classe Car.
come operatore esegue il cast senza sollevare un'eccezione se il cast fallisce.
Object obj = new StringReader("Hello");
StringReader r = obj as StringReader;L'incapsulamento è definito "come il processo di racchiudere uno o più elementi all'interno di un pacchetto fisico o logico". L'incapsulamento, nella metodologia di programmazione orientata agli oggetti, impedisce l'accesso ai dettagli di implementazione.
L'incapsulamento viene implementato utilizzando gli specificatori di accesso.
Un identificatore di accesso definisce l'ambito e la visibilità di un membro della classe.
Lo specificatore di accesso pubblico consente a una classe di esporre le sue variabili membro e le funzioni membro ad altre funzioni e oggetti. È possibile accedere a qualsiasi membro pubblico dall'esterno della classe.
Lo specificatore di accesso privato consente a una classe di nascondere le sue variabili membro e le funzioni membro da altre funzioni e oggetti. Solo le funzioni della stessa classe possono accedere ai suoi membri privati. Anche un'istanza di una classe non può accedere ai suoi membri privati.
Lo specificatore di accesso protetto consente a una classe figlia di accedere alle variabili membro e alle funzioni membro della sua classe base. In questo modo aiuta a implementare l'ereditarietà.
Lo specificatore di accesso interno consente a una classe di esporre le proprie variabili membro e funzioni membro ad altre funzioni e oggetti nell'assembly corrente. In altre parole, è possibile accedere a qualsiasi membro con specificatore di accesso interno da qualsiasi classe o metodo definito all'interno dell'applicazione in cui è definito il membro.
Lo specificatore di accesso interno protetto consente a una classe di nascondere le proprie variabili membro e funzioni membro da altri oggetti e funzioni di classe, ad eccezione di una classe figlia all'interno della stessa applicazione. Viene utilizzato anche durante l'implementazione dell'ereditarietà.
C # fornisce tipi di dati speciali, i tipi nullable, a cui è possibile assegnare un intervallo di valori normale e valori null.
Ad esempio, è possibile memorizzare qualsiasi valore compreso tra -2,147,483,648 e 2,147,483,647 o null in una variabile Nullable <Int32>. Allo stesso modo, puoi assegnare true, false o null in una variabile <bool> Nullable.
L'operatore di coalescenza null viene utilizzato con i tipi di valore nullable e i tipi di riferimento. Viene utilizzato per convertire un operando nel tipo di un altro operando di tipo valore nullable (o meno), in cui è possibile una conversione implicita.
Se il valore del primo operando è nullo, l'operatore restituisce il valore del secondo operando, altrimenti restituisce il valore del primo operando.
Utilizzando la parola chiave params, è possibile specificare un parametro del metodo che accetta un numero variabile di argomenti o addirittura nessun argomento.
No! parametri aggiuntivi non sono consentiti dopo la parola chiave params in una dichiarazione di metodo. È consentita una sola parola chiave params in una dichiarazione di metodo.
La classe Array è la classe base per tutti gli array in C #. È definito nello spazio dei nomi di sistema. La classe Array fornisce varie proprietà e metodi per lavorare con gli array.
Utilizzo della funzione Array.sort (array). Ordina gli elementi in un intero Array unidimensionale utilizzando l'implementazione IComparable di ciascun elemento dell'array.
Per prima cosa ordina l'array usando Array.sort (array), quindi inverti lo stesso usando il metodo Array.reverse (array).
In C #, una struttura è un tipo di dati di tipo valore. Ti aiuta a fare in modo che una singola variabile conservi i dati correlati di vari tipi di dati. La parola chiave struct viene utilizzata per creare una struttura.
Le strutture vengono utilizzate per rappresentare un record. Per definire una struttura, è necessario utilizzare l'istruzione struct. L'istruzione struct definisce un nuovo tipo di dati, con più di un membro per il programma.
Le classi e le strutture presentano le seguenti differenze di base:
le classi sono tipi di riferimento e le strutture sono tipi di valore.
le strutture non supportano l'ereditarietà.
le strutture non possono avere un costruttore predefinito.
Un'enumerazione è un insieme di costanti intere denominate. Un tipo enumerato viene dichiarato utilizzando la parola chiave enum.
Le enumerazioni C # sono tipo di dati valore. In altre parole, l'enumerazione contiene i propri valori e non può ereditare o non può trasmettere l'ereditarietà.
L'identificatore di accesso predefinito per un tipo di classe è interno.
L'accesso predefinito per i membri è privato.
Uno dei concetti più importanti nella programmazione orientata agli oggetti è l'ereditarietà. L'ereditarietà ci consente di definire una classe in termini di un'altra classe, il che semplifica la creazione e la manutenzione di un'applicazione. Ciò offre anche l'opportunità di riutilizzare la funzionalità del codice e accelera i tempi di implementazione.
Quando si crea una classe, invece di scrivere membri dati e funzioni membro completamente nuovi, il programmatore può designare che la nuova classe erediti i membri di una classe esistente. Questa classe esistente viene chiamata classe base e la nuova classe viene definita classe derivata.
L'idea di eredità implementa la relazione IS-A. Ad esempio, il mammifero è un animale, il cane è un mammifero quindi anche il cane è un animale e così via.
No! C # non supporta l'ereditarietà multipla.
Una classe può essere derivata da più di una classe o interfaccia, il che significa che può ereditare dati e funzioni da più classi o interfacce di base. La sintassi utilizzata in C # per la creazione di classi derivate è la seguente:
<acess-specifier> class <base_class>
{
...
}
class <derived_class> : <base_class>
{
...
}La parola polimorfismo significa avere molte forme. Nel paradigma della programmazione orientata agli oggetti, il polimorfismo è spesso espresso come "un'interfaccia, più funzioni".
Il polimorfismo può essere statico o dinamico. Nel polimorfismo statico, la risposta a una funzione è determinata al momento della compilazione. Nel polimorfismo dinamico, viene deciso in fase di esecuzione.
C # fornisce due tecniche per implementare il polimorfismo statico. Sono -
Sovraccarico delle funzioni
Sovraccarico dell'operatore
Il meccanismo di collegamento di una funzione con un oggetto durante la fase di compilazione è chiamato associazione anticipata. È anche chiamato binding statico.
È possibile avere più definizioni per lo stesso nome di funzione nello stesso ambito. La definizione della funzione deve differire l'una dall'altra per i tipi e / o il numero di argomenti nell'elenco degli argomenti. Non è possibile eseguire l'overload di dichiarazioni di funzione che differiscono solo per il tipo restituito.
Il polimorfismo dinamico è implementato da classi astratte e funzioni virtuali.
Quando una classe viene dichiarata sealed, non può essere ereditata.
No! Non può essere creato poiché le classi astratte non possono essere dichiarate sigillate.
Quando si dispone di una funzione definita in una classe che si desidera implementare in una o più classi ereditate, si utilizzano funzioni virtuali. Le funzioni virtuali potrebbero essere implementate in modo diverso in diverse classi ereditate e la chiamata a queste funzioni verrà decisa in fase di esecuzione.
È possibile ridefinire o sovraccaricare la maggior parte degli operatori incorporati disponibili in C #. Pertanto un programmatore può utilizzare anche operatori con tipi definiti dall'utente.
Gli operatori sovraccaricati sono funzioni con nomi speciali, l'operatore parola chiave seguito dal simbolo dell'operatore da definire. Simile a qualsiasi altra funzione, un operatore sovraccarico ha un tipo restituito e un elenco di parametri.
n interfaccia è definita come un contratto sintattico che tutte le classi che ereditano l'interfaccia dovrebbero seguire. L'interfaccia definisce la parte "cosa" del contratto sintattico e le classi derivate definiscono la parte "come" del contratto sintattico.
Le interfacce definiscono proprietà, metodi ed eventi, che sono i membri dell'interfaccia. Le interfacce contengono solo la dichiarazione dei membri. È responsabilità della classe derivante definire i membri. Spesso aiuta a fornire una struttura standard che le classi derivate seguirebbero.
Le direttive del preprocessore danno istruzioni al compilatore di preelaborare le informazioni prima che inizi la compilazione effettiva.
Tutte le direttive del preprocessore iniziano con # e solo i caratteri spazi bianchi possono apparire prima di una direttiva del preprocessore su una riga. Le direttive del preprocessore non sono istruzioni, quindi non terminano con un punto e virgola (;).
È possibile utilizzare la direttiva #if per creare una direttiva condizionale. Le direttive condizionali sono utili per testare uno o più simboli per verificare se restituiscono true. Se restituiscono true, il compilatore valuta tutto il codice compreso tra #if e la direttiva successiva.
Le eccezioni C # sono rappresentate da classi. Le classi di eccezione in C # derivano principalmente direttamente o indirettamente dalla classe System.Exception. Alcune delle classi di eccezione derivate dalla classe System.Exception sono le classi System.ApplicationException e System.SystemException.
La classe System.ApplicationException supporta le eccezioni generate dai programmi applicativi. Quindi le eccezioni definite dai programmatori dovrebbero derivare da questa classe.
La classe System.SystemException è la classe di base per tutte le eccezioni di sistema predefinite.