¿Hay alguna razón por la que C # no admita los métodos en línea manuales? ¿Y qué pasa con los parámetros opcionales?

StackOverflow https://stackoverflow.com/questions/1621623

  •  06-07-2019
  •  | 
  •  

Pregunta

¿Hay alguna razón de diseño para eso (como la razón por la que abandonaron la herencia múltiple)?

¿O simplemente no fue lo suficientemente importante?

y la misma pregunta se aplica a los parámetros opcionales en los métodos ... esto ya estaba en la primera versión de vb.net ... así que seguramente no hay pereza que haga que MS no permita parámetros opcionales, probablemente la decisión de la arquitectura ... y Parece que cambiaron de opinión al respecto, porque C # 4 incluirá eso ...

¿Alguien sabe cuál fue la decisión y por qué se rindió?

EDIT:

Tal vez no me entendiste del todo. Últimamente estoy trabajando en un programa de cálculo (números de soporte de cualquier tamaño, hasta el último dígito), en el que algunos métodos se usan literalmente millones de veces por segundo.

Diga que tengo un método llamado Agregar (int num), y este método se usa mucho con 1 como parámetro ( Add (1); ), he descubierto que es más rápido para implementar un método especial especialmente para uno. Y no me refiero a la sobrecarga: escribir un nuevo método llamado AddOne y, literalmente, copiar el método Agregar en él, excepto que en lugar de usar num estoy escribiendo 1 . Esto puede parecerte horriblemente extraño, pero en realidad es más rápido.

(por más feo que sea)

Eso me hizo preguntarme por qué C # no es compatible con el manual en línea, lo que puede ser increíblemente útil aquí.

gracias. (y por qué me votaste abajo: S)

Edición 2:

Me pregunté si añadir o no esto. Estoy muy familiarizado con la rareza (y las desventajas) de elegir una plataforma como dot net para este proyecto, pero creo que las optimizaciones de la red de puntos son más importantes de lo que piensan ... especialmente las características como Cualquier CPU, etc.

¿Fue útil?

Solución

Para responder parte de su pregunta, consulte la publicación del blog de Eric Gunnerson: ¿Por qué C # no tiene una palabra clave 'en línea'?

Una cita de su publicación:

  

Para C #, la alineación ocurre en el JIT   nivel, y el JIT generalmente hace un   decisión decente.

EDITAR: no estoy seguro de la razón por la que se admiten los parámetros opcionales retrasados, sin embargo, al decir que " se rindieron " Parece que se esperaba que lo implementaran en función de nuestras expectativas de lo que ofrecen otros idiomas. Me imagino que no era una prioridad en su lista de prioridades y tenían fechas límite para que ciertas funciones salieran por las puertas de cada versión. Probablemente no haya aumentado su importancia hasta ahora, especialmente porque la sobrecarga de métodos era una alternativa disponible. Mientras tanto, tenemos los genéricos (2.0) y las características que hacen que LINQ sea posible, etc. (3.0). Estoy contento con la progresión del lenguaje; Las características mencionadas anteriormente son más importantes para mí que obtener soporte para parámetros opcionales desde el principio.

Otros consejos

En línea manual sería casi inútil. El compilador JIT integra los métodos durante la compilación de código nativo cuando es apropiado, y creo que en casi todos los casos el compilador JIT es mejor adivinar cuándo es apropiado que el programador.

En cuanto a los parámetros opcionales, no sé por qué no estaban allí en versiones anteriores. Dicho esto, no me gusta que estén allí en C # 4, porque los considero algo dañinos porque el parámetro se integra en el ensamblaje consumidor y usted tiene que recompilarlo si cambia los valores estándar en una DLL y desea el consumo montaje para utilizar los nuevos.

EDITAR:

Alguna información adicional acerca de la inclusión. Aunque no puede forzar al compilador JIT a incluir una llamada de método, puede forzarlo a NO en línea a una llamada de método. Para esto, usas System.Runtime.CompilerServices.MethodImplAttribute, de esta forma: 

internal static class MyClass
{
    [System.Runtime.CompilerServices.MethodImplAttribute(MethodImplOptions.NoInlining)]
    private static void MyMethod()
    {
        //Powerful, magical code
    }

    //Other code
}

Mi conjetura: la razón por la que las versiones anteriores de C # no tenían parámetros opcionales se debe a las malas experiencias con ellos en C ++. En la superficie, se ven bastante directos, pero hay algunos casos molestos en las esquinas. Creo que uno de los libros de Herb Sutter describe esto con más detalle; en general, tiene que ver con anular los métodos virtual . Maximilian ha mencionado uno de los casos de esquina de .NET en su respuesta.

También se puede arreglárselas fácilmente escribiendo múltiples sobrecargas; puede que no sea muy agradable para el autor de la clase, pero los clientes apenas notarán la diferencia entre las sobrecargas y los parámetros opcionales.

Después de todos estos años sin ellos, ¿por qué C # 4.0 los agregó? 1) paridad mejorada con VB.NET, y 2) interoperabilidad más fácil con COM.

  

Últimamente estoy trabajando en un programa de cálculo (números de soporte de cualquier tamaño, hasta el último dígito), en el que algunos métodos se usan literalmente millones de veces por segundo.

Luego escogiste un idioma incorrecto. Asumo que realmente perfilaste tu código (¿verdad?) Y sabes que no hay nada, aparte de las micro-optimizaciones, que pueda ayudarte. Además, estás utilizando una biblioteca Bigint nativa de alto rendimiento y no estás escribiendo la tuya, ¿no?

Si eso es cierto, no uses .NET. Si crees que puedes ganar velocidad en la especialización parcial, ve a Haskell, C, Fortran o cualquier otro idioma que lo haga de forma automática, o puede exponerte a ti para que lo haga a mano.

Si Add (1) realmente te importa, las asignaciones de pila también serán importantes.

Sin embargo, realmente debes ver lo que el generador de perfiles puede decirte ...

C # los ha agregado en 4.0: http: / /msdn.microsoft.com/en-us/library/dd264739(VS.100).aspx

En cuanto a por qué no se hicieron desde el principio, lo más probable es que sintieran que las sobrecargas de métodos daban más flexibilidad. Con la sobrecarga, puede especificar varios 'valores predeterminados' en función de los otros parámetros que está tomando. Tampoco es mucho más sintaxis.

Incluso en lenguajes como C ++, alinear algo no garantiza que suceda; Es una pista para el compilador. El compilador puede tomar la sugerencia o hacer su propia cosa .

C # es otro paso que se elimina del código de ensamblaje generado (a través de IL + el JIT), por lo que es aún más difícil garantizar que algo esté en línea. Además, tiene problemas como las implementaciones x86 + x64 del JIT que difieren en su comportamiento.

Java tampoco incluye una palabra clave en línea . El mejor Java JIT puede incluir incluso métodos virtuales, ni el uso de palabras clave como private o final hace ninguna diferencia (solía hacerlo, pero ahora es historia antigua).

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top