Perché C# è tipizzato staticamente?

https://stackoverflow.com/questions/859186

21-08-2019
|

Domanda

Sono un programmatore web PHP che sta cercando di imparare C#.

Vorrei sapere perché C# mi richiede di specificare il tipo di dati durante la creazione di una variabile.

Class classInstance = new Class();

Perché abbiamo bisogno di conoscere il tipo di dati prima di un'istanza di classe?

Soluzione

Come altri hanno detto, C # è statico / strongly-typed. Ma io prendo la tua domanda più per essere "Perché dovresti voler C # per essere statico / fortemente tipizzato come questa? Che vantaggi ha questo su linguaggi dinamici?"

Con questo in mente, ci sono un sacco di buoni motivi:

Stabilità Alcuni tipi di errori sono ora catturati automaticamente dal compilatore, prima che il codice fa mai da nessuna parte vicino alla produzione.
La leggibilità / Maintainability Si sta ora fornendo ulteriori informazioni su come si suppone che il codice per lavorare agli sviluppatori futuri che lo leggono. Si aggiungono le informazioni che una variabile specifica ha lo scopo di tenere un certo tipo di valore, e che aiuta i programmatori ragione di ciò che la finalità di tale variabile è.

Questo è probabilmente il motivo per cui, ad esempio, linee guida dello stile di Microsoft raccomanda che i programmatori VB6 messo un prefisso tipo con i nomi delle variabili, ma che i programmatori VB.Net non lo fanno.
Performance Questa è la ragione più debole, ma late-binding / duck typing può essere più lento. Alla fine, una variabile si riferisce alla memoria che è strutturata in qualche modo specifico. Senza tipi forti, il programma dovrà fare il tipo di verifica in più o la conversione dietro le quinte in fase di esecuzione, come si usa la memoria che è strutturato in un modo fisicamente come se fosse strutturata in un altro modo logico.

Ho esitato a includere questo punto, perché in ultima analisi si ha spesso a che fare quelle conversioni in un linguaggio fortemente tipizzato pure. E 'solo che il linguaggio fortemente tipizzato lascia l'esatta tempistica e la portata della conversione al programmatore, e lo fa senza lavoro in più a meno che non deve essere fatto. Inoltre permette al programmatore di forzare un tipo di dati più vantaggioso. Ma questi sono davvero gli attributi del programmatore , piuttosto che la piattaforma.

Questo sarebbe essere di per sé una ragione debole per omettere il punto, tranne che un buon linguaggio dinamico spesso fare scelte migliori rispetto al programmatore. Ciò significa che un linguaggio dinamico può aiutare molti programmatori di scrivere programmi più veloci. Eppure, per buoni , programmatori lingue fortemente tipizzato hanno il potenziale per essere più veloce.
Meglio strumenti di sviluppo Se il vostro IDE sa che tipo di una variabile dovrebbe essere, si può dare un ulteriore aiuto su quali tipi di cose che variabile può fare. Questo è molto più difficile per l'IDE di farlo se deve dedurre il tipo per voi. E se si ottiene più aiuto con la minuzia di un API dall'IDE, allora come sviluppatore sarà in grado di ottenere la testa intorno ad un più grande, più ricca API, e arrivare più velocemente.

O forse si stava solo chiedendo perché è necessario specificare il nome della classe due volte per la stessa variabile sulla stessa linea? La risposta è duplice:

Spesso non lo fai. In C # 3.0 e versioni successive è possibile utilizzare la parola chiave var anziché il nome del tipo in molti casi. Le variabili create in questo modo sono ancora staticamente tipizzati, ma il tipo è ora dedotto per voi dal compilatore.
Grazie alla eredità e le interfacce a volte il tipo sul lato sinistro non corrisponde al tipo sul lato destro della strada.

Altri suggerimenti

E 'semplicemente come il linguaggio è stato progettato. C # è un linguaggio C-style e segue il modello di avere tipi a sinistra.

In C # 3.0 e fino è possibile tipo di aggirare il problema in molti casi con inferenza di tipo locale.

var variable = new SomeClass();

Ma allo stesso tempo si potrebbe anche sostenere che si sta ancora dichiarare un tipo sul lato sinistro. Solo che si desidera che il compilatore di scegliere per voi.

Modifica

Si prega di leggere questo nel contesto della domanda originale utenti

perché abbiamo bisogno di [nome della classe] prima di un nome di variabile?

Ho voluto commentare su diverse altre risposte in questa discussione. Un sacco di persone stanno dando "C # è di tipo statico" come risposta. Mentre l'affermazione è vera (C # è staticamente tipizzato), è quasi del tutto estraneo alla domanda. tipizzazione statica non richiede un nome di tipo sia alla sinistra del nome della variabile. Certo si può fare a meno che non è una scelta della lingua progettista una caratteristica necessaria dei linguaggi tipizzati statici.

Si è facilmente dimostrabile considerando altri linguaggi staticamente tipizzati, come F #. Tipi in F # appaiono sulla destra di un nome di variabile e molto spesso possono essere del tutto omessi. Ci sono anche diversi esempi del contatore. PowerShell per esempio, è estremamente dinamico e mette tutto il suo tipo, se inclusi, a sinistra.

Uno dei motivi principali è che è possibile specificare i tipi differenti a condizione che il tipo sul lato sinistro della cessione è un tipo genitore del tipo a sinistra (o un'interfaccia implementata su quel tipo).

Per esempio dato i seguenti tipi:

class Foo { }
class Bar : Foo { }
interface IBaz { }
class Baz : IBaz { }

C # permette di fare questo:

Foo f = new Bar();
IBaz b = new Baz();

Sì, nella maggior parte dei casi il compilatore potrebbe dedurre il tipo della variabile dalla cessione (come con il var parola chiave) ma non è così per la ragione per cui ho indicato sopra.

Modifica Come una mozione d'ordine - mentre C # è fortemente tipizzato l'importante distinzione (per quanto questa discussione è in questione) è che in realtà è anche un staticamente tipizzato la lingua. In altre parole il compilatore C # non di tipo statico il controllo in fase di compilazione.

C # è un staticamente tipizzato , fortemente tipizzato linguaggio come C o C ++. In queste lingue tutte le variabili devono essere dichiarate per essere di un tipo specifico.

In definitiva, perché Anders Hejlsberg ha detto così ...

È necessario [nome della classe] di fronte, perché ci sono molte situazioni in cui il primo [nome della classe] è diverso dal secondo, come:

 IMyCoolInterface obj = new MyInterfaceImplementer();
 MyBaseType obj2 = new MySubTypeOfBaseType();

ecc. È inoltre possibile utilizzare la parola 'var' se non si desidera specificare il tipo esplicitamente.

Perché abbiamo bisogno di conoscere il tipo di dati prima un'istanza di classe?

Non lo sai! Leggi da destra a sinistra. Si crea la variabile e quindi si memorizza in una variabile di tipo sicuro in modo da sapere che tipo quella variabile è per un uso successivo.

Si consideri il seguente frammento di codice, sarebbe un incubo per eseguire il debug se non hai ricevuto gli errori fino a runtime.

 void FunctionCalledVeryUnfrequently()
 {
   ClassA a = new ClassA();
   ClassB b = new ClassB();
   ClassA a2 = new ClassB(); //COMPILER ERROR(thank god)

   //100 lines of code

   DoStuffWithA(a);
   DoStuffWithA(b);      //COMPILER ERROR(thank god)
   DoStuffWithA(a2);
 }

Quando you'r pensare di poter sostituire il nuova Classe () con un numero o una stringa e la sintassi renderà molto più senso. Il seguente esempio potrebbe essere un po 'prolisso, ma potrebbe aiutare a capire il motivo per cui è stato progettato il modo in cui è.

   string s = "abc";
   string s2 = new string(new char[]{'a', 'b', 'c'});
   //Does exactly the same thing

   DoStuffWithAString("abc");
   DoStuffWithAString(new string(new char[]{'a', 'b', 'c'}));
   //Does exactly the same thing

C #, come altri hanno fatto notare, è un linguaggio fortemente, staticamente tipizzato.

Per dichiarando in anticipo ciò che il tipo che stai con l'intenzione di creare è, riceverai a tempo di compilazione avvisi quando si tenta di assegnare un valore non valido. Affermando in anticipo che tipo di parametri si accetta nei metodi, si ricevono gli stessi avvertimenti a tempo di compilazione quando si passa accidentalmente senza senso in un metodo che non si aspetta di esso. Rimuove il sovraccarico di qualche paranoia a vostro nome.

Infine, e piuttosto bene, C # (e molte altre lingue) non ha lo stesso ridicolo "convertire qualsiasi cosa a qualsiasi cosa, anche quando non ha senso" mentalità che PHP fa, che francamente può inciampare voi up più volte di quanto non lo aiuta.

A causa C # è un linguaggio fortemente tipizzato

c # è un linguaggio fortemente tipizzato, come C ++ o Java. Quindi ha bisogno di conoscere il tipo di variabile. si può fudge un po 'in C # 3.0 con la parola chiave var. Che consente al compilatore dedurre il tipo.

Questa è la differenza tra un linguaggio fortemente tipizzato e debolmente tipizzato. C # (e C, C ++, Java, la maggior parte delle lingue più potenti) sono fortemente tipizzato quindi è necessario dichiarare il tipo di variabile.

Quando definiamo le variabili per contenere i dati che abbiamo per specificare il tipo di dati che quelle variabili terrà. Il compilatore controlla quindi che quello che stiamo facendo con i dati ha un senso ad esso, vale a dire segue le regole. Non possiamo per il testo esempio, conservare in un numero -. Il compilatore non permettere che

int a = "fred"; // Not allowed. Cannot implicitly convert 'string' to 'int'

La variabile a è di tipo int, e assegna al valore "fred" che è una stringa di testo su regole rompe il compilatore è in grado di fare qualsiasi tipo di conversione di questa stringa.

In C # 3.0, è possibile utilizzare la parola 'var' - questo usa inferenza statica di capire cosa il tipo della variabile è in fase di compilazione

var foo = new ClassName();

variabile 'foo' sarà di tipo 'ClassName' da allora in poi.

Una cosa che non è stato detto è che C # è un CLS (Common Language Specification) linguaggio compatibile. Questo è un insieme di regole che un linguaggio .NET deve rispettare per essere interopable con altri linguaggi .NET.

Quindi, in realtà C # è solo mantenere a queste regole. Per citare questo articolo MSDN :

La CLS aiuta a migliorare e garantire   lingua interoperabilità definendo   un insieme di caratteristiche che gli sviluppatori possono   contare su di essere disponibili in una vasta   varietà di lingue. Le CLS anche   stabilisce i requisiti per CLS   conformità; queste aiutano a determinare   se il codice gestito è conforme alle   la CLS e in quale misura una determinata   strumento supporta lo sviluppo di   codice gestito che utilizza CLS caratteristiche.

Se il componente utilizza solo CLS   caratteristiche API che espone a   altro codice (compresi derivati   classi), il componente viene garantito   per essere accessibile da qualsiasi programmazione   linguaggio che supporti la CLS.   I componenti che aderiscono ai CLS   regole e utilizzare solo le caratteristiche   incluso nella CLS sono detto di essere   CLS-compliant componenti

Una parte della CLS è il CTS Tipo comune sistema .

Se questo non è abbastanza per voi acronimi poi c'è una tonnellata di più in .NET, come CLI, ILASM / MSIL, CLR, BCL, FCL,

tipizzazione statica permette anche al compilatore di effettuare ottimizzazioni migliori, e saltare alcuni passaggi. Prendete sovraccarico per esempio, dove si dispone di più metodi o operatori con lo stesso nome che differisce solo per i loro argomenti. Con un linguaggio dinamico, il runtime avrebbe bisogno di grado ogni versione al fine di determinare quale sia la migliore partita. Con un linguaggio statico come questo, il codice finale indica semplicemente direttamente al sovraccarico appropriata.

tipizzazione statica aiuta anche nella manutenzione del codice e refactoring. Il mio esempio preferito è la funzione Rinomina di molti IDE di fascia alta. Grazie alla tipizzazione statica, l'IDE può trovare con certezza ogni occorrenza di identificatore nel codice, e lasciare identificatori non correlati con lo stesso nome intatto.

Non ho notato se fosse ancora o no menzionata, ma C # 4.0 introduce il controllo dinamico attraverso il dynamic parola chiave. Anche se sono sicuro che ci si vuole evitare di usarlo quando non è necessario.

Perché C# mi richiede di specificare il tipo di dati durante la creazione di una variabile.

Perché abbiamo bisogno di conoscere il tipo di dati prima di un'istanza di classe?

Penso che una cosa a cui la maggior parte delle risposte non ha fatto riferimento è il fatto che C# lo fosse originariamente inteso e progettato come linguaggio "gestito", "sicuro" tra le altre cose e molti di questi obiettivi vengono raggiunti tramite verificabilità statica/in fase di compilazione.Conoscere esplicitamente il tipo di dati variabile rende questo problema MOLTO più semplice da risolvere.Ciò significa che è possibile effettuare diverse valutazioni automatizzate (compilatore C#, non JIT) su possibili errori/comportamenti indesiderati senza mai consentirne l'esecuzione.

Questa verificabilità come effetto collaterale offre anche una migliore leggibilità, strumenti di sviluppo, stabilità, ecc.perché se un algoritmo automatizzato può capire meglio cosa farà il codice quando verrà effettivamente eseguito, puoi farlo anche tu :)

staticamente tipizzato significa che compilatore in grado di eseguire una sorta di controlli in fase di compilazione, non in fase di esecuzione. Ogni variabile è di particolare o di tipo forte nel tipo statico. C # è fortemente sicuramente fortemente tipizzato.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow