Por que C # tipagem estática?

https://stackoverflow.com/questions/859186

21-08-2019
|

Pergunta

Eu sou um web programador PHP que está tentando aprender C #.

Eu gostaria de saber porque C # me obriga a especificar o tipo de dados ao criar uma variável.

Class classInstance = new Class();

Por que precisamos de saber o tipo de dados antes de uma instância de classe?

Solução

Como já foi dito, C # é estático / fortemente tipado. Mas eu tomo a sua pergunta mais para ser "Por que você deseja C # para ser static / fortemente tipado como este? Quais as vantagens que isso tem línguas mais dinâmicas?"

Com isso em mente, há muitas boas razões:

Estabilidade Certos tipos de erros agora são capturados automaticamente pelo compilador, antes do código nunca faz isso em qualquer lugar perto de produção.
Readability / Maintainability Você está agora fornecendo mais informações sobre como o código é suposto trabalho para futuros desenvolvedores que lêem. Você pode adicionar informações que uma variável específica é destinado a manter um certo tipo de valor, e que ajuda os programadores a raciocinar sobre o que a finalidade dessa variável é.

Este é provavelmente por isso que, por exemplo, diretrizes de estilo da Microsoft recomenda que os programadores VB6 colocar um tipo prefixo com nomes de variáveis, mas não que os programadores VB.Net fazer.
Desempenho Esta é a razão mais fraco, mas a ligação tardia / tipagem pato pode ser mais lenta. No final, uma variável refere-se a memória que está estruturado de algum modo específico. Sem tipos fortes, o programa terá que fazer a verificação tipo extra ou conversão nos bastidores em tempo de execução como você usar a memória que está estruturado de uma forma fisicamente como se fosse estruturada de outra maneira lógica.

Eu hesite em incluir este ponto, porque em última análise, muitas vezes você tem que fazer essas conversões em uma linguagem fortemente digitado também. É que a linguagem fortemente digitado deixa o tempo exato ea extensão da conversão para o programador, e não faz nenhum trabalho extra a menos que precisa ser feito. Também permite que o programador para forçar um tipo de dados de forma mais vantajosa. Mas estes realmente são atributos do programador , ao invés da plataforma.

Isso seria por si só um motivo fraco para omitir o ponto, exceto que uma linguagem boa dinâmica, muitas vezes, fazer escolhas melhores do que o programador. Isto significa uma linguagem dinâmica pode ajudar muitos programadores escrever programas mais rápidos. Ainda assim, para boa programadores, línguas fortemente tipados ter o potencial para ser mais rápido.
Melhor Dev Tools Se seu IDE sabe o que digitar uma variável deverá ser, ele pode lhe dar ajuda adicional sobre que tipos de coisas que variável pode fazer. Isto é muito mais difícil para o IDE que fazer se ele tem para inferir o tipo para você. E se você obter mais ajuda com a minúcia de uma API do IDE, então você como um desenvolvedor será capaz de obter a sua cabeça em torno de uma API maior, mais rico, e chegar lá mais rápido.

Ou talvez você estava me perguntando por que você tem que especificar o nome da classe duas vezes para a mesma variável na mesma linha? A resposta é duas vezes:

Muitas vezes você não. No C # 3.0 e mais tarde você pode usar o var palavra-chave em vez do nome do tipo em muitos casos. Variáveis ??criadas dessa forma ainda estão tipagem estática, mas o tipo é agora inferida para você pelo compilador.
Graças a herança e as interfaces, por vezes, o tipo no lado da mão esquerda não corresponde ao tipo no lado direito.

Outras dicas

É simplesmente a forma como a linguagem foi projetada. C # é uma linguagem de estilo C e segue no padrão de ter tipos do lado esquerdo.

Em C # 3.0 e se você pode tipo de contornar esta situação, em muitos casos com a inferência de tipo local.

var variable = new SomeClass();

Mas, ao mesmo tempo, você também poderia argumentar que você ainda está declarando um tipo na LHS. Só que você quiser que o compilador para buscá-lo para você.

Editar

Por favor, leia isso no contexto da usuários pergunta original

Por que precisamos de [nome da classe] antes de um nome de variável?

Eu queria comentar sobre várias outras respostas neste tópico. Um monte de pessoas estão dando "C # é estaticamente tipo" como resposta. Enquanto a afirmação é verdadeira (C # é digitado estaticamente), é quase completamente alheios à pergunta. tipagem estática não necessita de um nome de tipo sendo para a esquerda do nome da variável. Claro que pode ajudar, mas que é uma escolha designer da linguagem não é uma característica necessária de linguagens estáticas digitado.

Estes é facilmente demonstrável por considerar outras linguagens de tipagem estática, como F #. Tipos de F # aparecem à direita de um nome de variável e muitas vezes pode ser completamente omitido. Existem também vários exemplos de contador. PowerShell, por exemplo, é extremamente dinâmico e coloca todo seu tipo, se incluído, à esquerda.

Uma das principais razões é que você pode especificar diferentes tipos, desde que o tipo no lado esquerdo da atribuição é um tipo pai do tipo do lado esquerdo (ou uma interface que é implementado nesse tipo).

Por exemplo, dadas as seguintes tipos:

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

C # permite que você faça o seguinte:

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

Sim, na maioria dos casos o compilador poderia inferir o tipo da variável da cessão (como com o var palavra-chave), mas não pela razão que têm mostrado acima.

Editar: Como um ponto de ordem - enquanto C # é fortemente tipado a distinção importante (tanto quanto essa discussão está em causa) é que ele é de fato também estaticamente digitado idioma. Em outras palavras, o compilador C # faz a verificação de tipo estático em tempo de compilação.

C # é um estaticamente digitado , fortemente tipado linguagem como C ou C ++. Em línguas todas as variáveis ??devem ser declarados de um tipo específico.

Em última análise, porque Anders Hejlsberg disse isso ...

Você precisa [nome da classe] na frente porque há muitas situações em que o primeiro [nome da classe] é diferente da segunda, como:

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

etc. Você também pode usar a palavra 'var' se você não quer especificar o tipo explicitamente.

Por que precisamos de saber o tipo de dados antes uma instância de classe?

Você não! lido da direita para a esquerda. Você cria a variável e, em seguida, armazená-lo em uma variável de tipo seguro para que você saiba que tipo essa variável é para uso posterior.

Considere o seguinte trecho, que seria um pesadelo para depuração se você não receber os erros até a execução.

 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 você'r pensamento você pode substituir o new Class () com um número ou uma string e a sintaxe fará muito mais sentido. O exemplo a seguir pode ser um pouco detalhado, mas ajuda poder entender por que ele é projetado do jeito que está.

   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 #, como outros já fora apontado, é uma linguagem fortemente, estaticamente digitado.

Ao afirmar de antemão o que o tipo que você está pretendendo criar é, você receberá avisos de tempo de compilação quando tentar atribuir um valor ilegal. Ao afirmar de antemão que tipo de parâmetros que você aceitar métodos, você recebe os mesmos avisos de tempo de compilação quando você passar acidentalmente absurdo para um método que não está esperando por ele. Ele remove a sobrecarga de alguns paranóia em seu nome.

Finalmente, e bastante bem, C # (e muitas outras línguas) não tem o mesmo ridículo, "Converter qualquer coisa para qualquer coisa, mesmo quando não faz sentido" mentalidade de que o PHP faz, que, francamente pode tropeçar você -se mais vezes do que ajuda.

Porque C # é uma linguagem fortemente digitado

c # é uma linguagem fortemente tipada, como C ++ ou Java. Por isso ele precisa saber o tipo da variável. você pode falsificar um pouco em C # 3.0 via a palavra-chave var. Isso permite que o compilador inferir o tipo.

Essa é a diferença entre uma linguagem fortemente digitado e fracamente tipado. C # (e C, C ++, Java, a maioria das linguagens mais poderosas) estão fortemente digitado por isso você deve declarar o tipo de variável.

Quando definimos variáveis ??para armazenar dados que temos para especificar o tipo de dados que essas variáveis ??irá realizar. O compilador, em seguida, verifica se o que estamos fazendo com os dados faz sentido a ela, ou seja, segue as regras. Podemos não para texto exemplo loja em um número -. O compilador não vai permitir que ele

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

A variável de um é do tipo int, e atribuindo-lhe o valor "Fred", que é um texto cordão se o em regras o compilador é incapaz de fazer qualquer tipo de conversão desta cadeia.

Em C # 3.0, você pode usar o 'var' palavra-chave - este usos tipo estático inferência para descobrir o que o tipo da variável é em tempo de compilação

var foo = new ClassName();

variável 'foo' será do tipo 'ClassName' a partir de então.

Uma coisa que não tenha sido mencionado é que C # é uma CLS (Common Language Specification) de linguagem compatível. Este é um conjunto de regras que uma linguagem .NET tem que aderir a fim de ser interopable com outras linguagens .NET.

Então, realmente C # é apenas manter a estas regras. Para citar este MSDN artigo :

Os CLS ajuda a melhorar e garantir a linguagem interoperabilidade através da definição um conjunto de características que os desenvolvedores podem confiar para estar disponível em uma ampla variedade de idiomas. Os CLS também estabelece requisitos para CLS conformidade; Estes ajudam a determinar se seus conforma código gerenciado os CLS e em que medida um determinado ferramenta suporta o desenvolvimento de código gerenciado que usa CLS apresenta.

Se seus usos de componentes apenas CLS apresenta na API que expõe a outro código (incluindo derivados classes), o componente é garantida para ser acessível a partir de qualquer programação linguagem que suporta os CLS. Componentes que aderem ao CLS regras e usar apenas os recursos incluída no CLS são disse a ser Compatíveis com CLS componentes

Parte dos CLS é o CTS Common Type System .

Se isso não é suficiente siglas para você, então há uma tonelada mais em .NET tais como CLI, ILASM / MSIL, CLR, BCL, FCL,

estática digitação também permite que o compilador para criar melhores otimizações, e pular certas etapas. Tome sobrecarga por exemplo, onde você tem vários métodos ou operadores com o mesmo nome diferindo apenas por seus argumentos. Com uma linguagem dinâmica, o tempo de execução seria necessário grau cada versão, a fim de determinar qual é a melhor correspondência. Com uma linguagem estática assim, o código final simplesmente aponta diretamente para a sobrecarga apropriada.

estática digitação também ajuda na manutenção do código e refatoração. Meu exemplo favorito é o recurso Renomear de muitos IDEs mais sofisticados. Graças à tipagem estática, o IDE pode encontrar com certeza todas as ocorrências do identificador em seu código, e deixar identificadores não relacionados com o mesmo nome intacta.

Eu não percebi se foram mencionados ainda ou não, mas C # 4.0 introduz dinâmica verificando VIA a palavra-chave dynamic. Embora eu tenho certeza que você iria querer evitá-lo quando não é necessário.

Por C # me obriga a especificar o tipo de dados ao criar uma variável.

Por que precisamos de saber o tipo de dados antes de uma instância de classe?

Eu acho que uma coisa que a maioria das respostas não ter referenciado é o fato de que C # foi originalmente significou e projetado como "administrado", a linguagem "seguro", entre outras coisas, e muitos desses objetivos são chegou à via static / verificabilidade tempo de compilação. Sabendo o tipo de dados variável explicitamente torna este problema muito mais fácil de resolver. O que significa que pode-se fazer várias avaliações automatizados (C # compilador, não JIT) sobre possíveis erros / comportamento indesejável sem nunca permitindo a execução.

Isso verificabilidade como um efeito colateral também lhe dá uma melhor legibilidade, ferramentas de desenvolvimento, estabilidade etc., porque se um algoritmo automatizado pode entender melhor o que o código vai fazer quando ele realmente funciona, você também pode:)

tipagem estática significa que Compiler pode executar algum tipo de verificações em tempo de compilação não em tempo de execução. Cada variável é de particular ou tipo forte no tipo estático. C # é fortemente definitivamente fortemente tipado.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow