StaDyn (lenguaje de programación)

Al igual que en los lenguajes dinámicos, las variables pueden contener diferentes tipos dentro del mismo ámbito:

using System ; class Program { public static void Main () { Console . Write ( "Número: " ); var age = Console . In . ReadLine (); Console . WriteLine ( "Dígitos: " + age . Length );edad = Convertir.ToInt32 ( edad ) ; edad ++ ;​Console.WriteLine ( "Feliz cumpleaños, ahora tienes " + age + " años." ) ; int length = age.Length ; // * Error del compilador } }

La agevariable se infiere primero como cadena, por lo que es seguro obtener su Lengthpropiedad. Luego, contiene un entero, por lo que age++es una expresión válida. El compilador detecta un error en la última línea, ya que Lengthya no es proporcionado por age.

El código generado no utiliza una sola Objectvariable para representar la edad, sino dos variables diferentes cuyos tipos son cadena y entero. Esto se logra mediante una modificación del algoritmo para calcular el formulario SSA . ^{[ 5 ]} Esto hace que el código generado sea más eficiente, ya que no se requieren conversiones de tipo en tiempo de ejecución.

vary dynamiclas variables pueden contener tipos sensibles al flujo:

using System ; class Program { public static void Main ( String [] args ) { var exception ; if ( args.Length > 0 ) exception = new ApplicationException ( " Una excepción de la aplicación." ) ; else exception = new SystemException ( " Una excepción del sistema." ) ; Console.WriteLine ( exception.Message ) ; } }

Es seguro obtener la Messagepropiedad exceptionporque tanto ApplicationExceptioncomo SystemExceptionproporcionan dicha propiedad. De lo contrario, se mostrará un error de compilación. De esta forma, StaDyn proporciona un sistema de tipado estático seguro.

En el siguiente programa:

using System ; class Program { public static void Main ( String [] args ) { var exception ; switch ( args.Length ) { case 0 : exception = new ApplicationException ( " Una excepción de aplicación." ) ; break ; case 1 : exception = new SystemException ( "Una excepción del sistema." ) ; break ; default : exception = "Esto no es una excepción." ; break ; } Console.WriteLine ( exception.Message ) ; // * Error de compilación con var, pero no con dynamic Console.WriteLine ( exception.Unknown ); // * Error de compilación } }

La Messagepropiedad no es proporcionada por String, por lo que se muestra un error de compilación para exception.Message. Sin embargo, si declaramos exceptioncomo dynamic, el programa anterior es aceptado por el compilador. dynamices más indulgente que var, siguiendo la tendencia de los lenguajes dinámicos. Sin embargo, aún se realiza la comprobación de tipos estática. Esto se muestra en la última línea de código, donde el compilador muestra un error para exception.Unknownincluso si exceptionse declara como dynamic. Esto se debe a que ninguno de los tres tipos posibles ( ApplicationException, SystemExceptiony String) admite el Unknownmensaje. ^{[ 6 ]}

Aunque dynamiclos vartipos se pueden usar explícitamente para obtener una comprobación de tipos más segura o más permisiva, el dinamismo de varlas referencias individuales también se puede modificar con opciones de línea de comandos, archivos de configuración XML y un complemento para Visual Studio. ^{[ 7 ]}

vary dynamiclos tipos se pueden usar como campos de objeto:

clase Wrapper { atributo de variable privada ;public Wrapper ( var attribute ) { this . attribute = attribute ; }public var get () { return atributo ; }public void set ( var attribute ) { this . attribute = attribute ; } }clase Test { public static void Main () { string aString ; int aInt ; Wrapper wrapper = new Wrapper ( "Hello" ); aString = wrapper . get (); aInt = wrapper . get (); // * Error del compiladorenvoltorio.set ( 3 ) ; aString = envoltorio.get ( ); // * Error del compilador aInt = envoltorio.get ( ) ; } }

La Wrapperclase puede encapsular cualquier tipo. Cada vez que llamamos al setmétodo, el tipo attributese infiere como el tipo del argumento. Cada objeto tiene un tipo potencialmente diferente attribute, por lo que su tipo se almacena para cada instancia individual en lugar de para toda la clase. De esta manera, las dos líneas indicadas en el código anterior informan errores de compilación. Se implementa un algoritmo de análisis de alias basado en tipos para admitir este comportamiento. ^{[ 8 ]}

Analicemos el siguiente método:

public static var superior ( parámetro var ) { parámetro de retorno . Arriba (); }

parameterEl compilador infiere el tipo y el valor de retorno de la función. Para ello, se añade una restricción al tipo del uppermétodo: el argumento debe proporcionar un ToUppermétodo sin parámetros. En cada invocación, se comprobará esta restricción. Además, el tipo de retorno upperse inferirá como el tipo de retorno del ToUppermétodo correspondiente implementado por el argumento. ^{[ 9 ]}

El programador puede usar varo dynamicpara declarar parameter, cambiando la forma en que se realiza la comprobación de tipos al invocar el método. Supongamos que el argumento pasado a uppercontiene un tipo sensible al flujo (por ejemplo, la variable ApplicationException, SystemExceptiono Stringexceptionen el código anterior). Con var, todos los tipos posibles del argumento deben proporcionar ToUpper; con dynamic, al menos un tipo debe proporcionar ToUpper.