¿Por qué C # estático de tipos?

https://stackoverflow.com/questions/859186

21-08-2019
|

Pregunta

Soy un programador web PHP que está tratando de aprender C #.

Me gustaría saber por qué C # me obliga a especificar el tipo de datos al crear una variable.

Class classInstance = new Class();

¿Por qué es necesario conocer el tipo de datos antes de una instancia de clase?

Solución

Como han dicho otros, es estático / de tipo fuerte C #. Pero tomo tu pregunta más que ser "¿Por qué que desee C # para ser estático / fuertemente tipificado como este? ¿Qué ventajas tiene esto sobre los lenguajes dinámicos?"

Con esto en mente, hay un montón de buenas razones:

Estabilidad Ciertos tipos de errores se capturan ahora automáticamente por el compilador, antes de que el código cada vez lo hace en cualquier lugar cerca de la producción.
Legibilidad / mantenibilidad ahora están proporcionando más información acerca de cómo se supone que el código para trabajar a futuros desarrolladores que lo leyeron. Se agrega la información de que una variable específica está destinado a contener un cierto tipo de valor, y que ayuda a los programadores razón acerca de lo que es el propósito de esa variable.

Esta es probablemente la razón, por ejemplo, las guías de estilo de Microsoft recomienda que los programadores de Visual Basic 6 ponen un prefijo de tipo con los nombres de variables, pero que los programadores de VB.Net NO.
Rendimiento Este es el motivo más débil, pero la ligadura de escribir / pato puede ser más lento. En el extremo, una variable se refiere a la memoria que está estructurado de alguna manera específica. Sin tipos fuertes, el programa tendrá que hacer la verificación de tipo adicional o conversión detrás de las escenas en tiempo de ejecución que utiliza la memoria que está estructurado de una manera físicamente como si estuviera estructurado de otra manera lógica.

Me dude en incluir este punto, porque en última instancia, a menudo hay que hacer esas conversiones en un lenguaje fuertemente tipado también. Es sólo que el lenguaje fuertemente tipado deja el tiempo exacto y el alcance de la conversión para el programador, y no realiza ningún trabajo extra a menos que hay que hacer. También permite que el programador para obligar a un tipo de datos más ventajosa. Pero estos realmente son atributos de la etiqueta programador , en lugar de la plataforma.

Eso sí misma una razón débil para omitir el punto, excepto que un buen lenguaje dinámico menudo hará mejores opciones que el programador. Esto significa un lenguaje dinámico puede ayudar a muchos programadores escribir programas más rápidos. Aún así, por programadores, idiomas inflexible de tipos tienen el potencial a ser más rápido.
Mejor Herramientas de desarrollo Si su IDE sabe qué tipo se espera que una variable sea, se le puede dar ayuda adicional acerca de qué tipo de cosas que la variable puede hacer. Esto es mucho más difícil para el IDE debe hacer si tiene que inferir el tipo para usted. Y si te dan más ayuda con las minucias de una API desde el IDE, entonces usted como desarrollador será capaz de conseguir su cabeza alrededor de un API más grande, más rica, y llegar más rápido.

O tal que estabas preguntando por qué se tiene que especificar el nombre de clase dos veces por la misma variable en la misma línea? La respuesta es doble:

A menudo no lo hace. En C # 3.0 y posteriormente se puede utilizar la palabra clave var en lugar del nombre de tipo en muchos casos. Las variables creadas de esta manera se sigue estático de tipos, pero el tipo es ahora infiere para usted por el compilador.
Gracias a la herencia y las interfaces veces el tipo en el lado izquierdo no coincide con el tipo en el lado derecho.

Otros consejos

Es simplemente cómo se diseñó el lenguaje. C # es un lenguaje de estilo C y sigue en el patrón de tener tipos de la izquierda.

En C # 3.0 y hasta puede especie de evitar esto, en muchos casos con la inferencia de tipo local.

var variable = new SomeClass();

Pero al mismo tiempo también se podría argumentar que todavía se está declarando un tipo en el LHS. Sólo que desea que el compilador para recogerlo para usted.

Editar

Por favor leer esto en el contexto de la pregunta original usuarios

¿por qué necesitamos [nombre de la clase] antes de un nombre de variable?

quería comentar en varias otras respuestas en este hilo. Una gran cantidad de personas que están dando "C # es estáticamente tipo" como respuesta. Mientras que la afirmación es cierta (C # se escribe de forma estática), es casi nada que ver con la cuestión. tipos estáticos no requiere un nombre de tipo estar a la izquierda del nombre de la variable. Claro que puede evitar que no es una opción diseñador del lenguaje una característica necesaria de lenguajes con tipos estáticos.

Estos es fácilmente comprobable al considerar otras lenguas tipos estáticos tales como F #. Tipos de F # aparecen a la derecha de un nombre de variable y muy a menudo puede omitirse por completo. También hay varios ejemplos contrarios. PowerShell, por ejemplo, es extremadamente dinámico y pone toda su tipo, si se incluye, a la izquierda.

Una de las razones principales es que se pueden especificar distintos tipos, siempre y cuando el tipo en el lado izquierdo de la asignación es un tipo matriz del tipo de la izquierda (o una interfaz que se implementa en ese tipo).

Por ejemplo dado los siguientes tipos:

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

C # le permite hacer esto:

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

Sí, en la mayoría de los casos el compilador podría inferir el tipo de la variable de la asignación (al igual que con el var palabra clave) pero no es así para el razón por la que he mostrado anteriormente.

Editar Como una cuestión de orden - mientras que C # es fuertemente introducido la distinción importante (por lo que esta discusión se refiere) es que es, de hecho, también una de tipo estático idioma. En otras palabras, el compilador de C # hace la comprobación estática de tipos en tiempo de compilación.

C # es un estático de tipos-, inflexible de tipos lenguaje como C o C ++. En todos los idiomas variables deben ser declaradas a ser de un tipo específico.

En última instancia, porque Anders Hejlsberg lo dijo ...

Es necesario [nombre de la clase] delante, porque hay muchas situaciones en las que la primera [nombre de la clase] es diferente de la segunda, como:

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

etc. También puede utilizar la palabra 'var' si no desea especificar el tipo de forma explícita.

¿Por qué necesitamos saber el tipo de datos antes de una instancia de clase?

no! Leer de derecha a izquierda. Se crea la variable y luego se almacena en una variable de tipo seguro para que sepa qué tipo de esa variable es para su uso posterior.

Considere el siguiente fragmento, sería una pesadilla para depurar si usted no recibió los errores hasta el tiempo de ejecución.

 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);
 }

Cuando you'r pensar que se puede reemplazar el nueva clase () con un número o una cadena y la sintaxis hará mucho más sentido. El siguiente ejemplo podría ser un poco prolijo, pero podría ayudar a entender por qué se ha diseñado de la manera que es.

   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 otros han señalado, es un lenguaje fuertemente, de tipo estático.

Al declarar por adelantado lo que el tipo que está con la intención de crear es, recibirá advertencias en tiempo de compilación cuando intenta asignar un valor ilegal. Al declarar por adelantado qué tipo de parámetros que acepta en los métodos, recibe esas mismas advertencias en tiempo de compilación cuando se pasa por accidente sin sentido en un método que no se lo esperaba. Se elimina la sobrecarga de cierta paranoia en su nombre.

Por último, y bastante bien, C # (y muchos otros idiomas) no tiene la misma ridícula, "convertir cualquier cosa a cualquier cosa, incluso cuando no tiene sentido" mentalidad que hace PHP, que francamente puede tropezar hasta más veces de lo que ayuda.

Debido a que C # es un lenguaje fuertemente tipado

C # es un lenguaje fuertemente tipado, como C ++ o Java. Por lo tanto, necesita saber el tipo de la variable. se puede falsificar un poco en C # 3.0 a través de la palabra clave var. Eso permite que el compilador inferir el tipo.

Esa es la diferencia entre un lenguaje fuertemente tipado y tipos débiles. C # (y C, C ++, Java, la mayoría de los más potentes lenguajes) están fuertemente tipado por lo que debe declarar el tipo de variable.

Cuando definimos variables para contener los datos que tenemos que especificar el tipo de datos que esas variables sostendrán. El compilador comprueba entonces que lo que estamos haciendo con los datos tiene sentido para él, es decir, sigue las reglas. No podemos, por ejemplo, tienda de texto en un número -. El compilador no permitirá

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

La variable a es de tipo int, y asignándole el valor "Fred", que es una cadena de texto en reglas rompe el compilador no es capaz de hacer cualquier tipo de conversión de esta cadena.

En C # 3.0, puede utilizar la palabra clave 'var' - esto utiliza la inferencia de tipos estática a trabajar en lo que el tipo de la variable es en tiempo de compilación

var foo = new ClassName();

variable 'foo' será de tipo 'NombredeClase' a partir de entonces.

Una de las cosas que no se ha mencionado es que C # es un CLS (Common Language Specification) lenguaje compatible. Se trata de un conjunto de reglas que un lenguaje .NET tiene que cumplir con el fin de ser interopable con otros lenguajes .NET.

Así que en realidad C # es simplemente mantener a estas reglas. Para citar este artículo de MSDN :

El CLS ayuda a mejorar y asegurar   idioma interoperabilidad mediante la definición   un conjunto de características que los desarrolladores pueden   confiar en que esté disponible en una amplia   variedad de idiomas. Los CLS también   establece los requisitos para CLS   conformidad; estos ayudan a determinar   si su código administrado se ajusta a   el CLS y en qué medida un determinado   herramienta es compatible con el desarrollo de   código administrado que utiliza CLS características.

Si el componente utiliza solamente CLS   características de la API que expone a   otro código (incluyendo derivados   clases), el componente está garantizada   para que sea accesible desde cualquier programación   lenguaje que soporte el CLS.   Los componentes que se adhieren a las CLS   reglas y utilizar las funciones del   incluido en los CLS se dice que son   componentes compatibles con CLS

Parte de la CLS es el CTS al Tipo Común Sistema .

Si eso no es suficiente para usted siglas entonces hay una tonelada más en .NET como CLI, ILASM / MSIL, CLR, BCL, FCL,

tipos estáticos también permite que el compilador para tomar mejores optimizaciones, y saltar ciertos pasos. Tome una sobrecarga por ejemplo, donde tiene varios métodos o los operadores con el mismo nombre que sólo difieren por sus argumentos. Con un lenguaje dinámico, el tiempo de ejecución tendría que calificar cada versión con el fin de determinar cuál es la mejor opción. Con un lenguaje estático como esta, el código final simplemente apunta directamente a la sobrecarga apropiada.

tipos estáticos también ayuda en el mantenimiento del código y refactorización. Mi ejemplo favorito es la función Cambiar nombre de muchos entornos de desarrollo de alta gama. Gracias a tipos estáticos, el IDE puede encontrar con certeza cada ocurrencia del identificador en el código, y dejar identificadores no relacionadas con el mismo nombre intacta.

No me di cuenta si se mencionó con todo o no, pero C # 4.0 presenta la comprobación dinámica a través de la dynamic palabra clave. Aunque estoy seguro de que quiere evitar que cuando no es necesario.

¿Por qué C # me obliga a especificar el tipo de datos al crear una variable.

¿Por qué es necesario conocer el tipo de datos antes de una instancia de clase?

Creo que una cosa que la mayoría de las respuestas no han referenciado es el hecho de que C # fue originalmente significado y diseñado como "administrado", el lenguaje "seguro", entre otras cosas, y muchos de esos objetivos son llegado a través de estática / compilar verificabilidad tiempo. Conociendo la variable de tipo de datos hace explícitamente este problema mucho más fácil de resolver. Lo que significa que uno puede hacer varias evaluaciones automatizadas (compilador de C #, no JIT) acerca de los posibles errores / comportamiento indeseable sin permitir jamás ejecución.

Eso verificabilidad como efecto secundario también le da una mejor legibilidad, herramientas dev, estabilidad, etc., porque si un algoritmo automatizado puede entender mejor lo que el código va a hacer cuando realmente funciona, por lo que puede usted:)

tipos estáticos significa que el compilador puede realizar algún tipo de controles en tiempo de compilación, no en tiempo de ejecución. Cada variable es de particular o de tipo fuerte en tipo estático. C # es fuertemente definitivamente inflexible.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow