Existe alguma razão C # não suporta métodos de inline manuais? E sobre parâmetros opcionais?

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

  •  06-07-2019
  •  | 
  •  

Pergunta

Há alguma razão projeto para que (como a razão eles desistiram de multi herança)?

ou ele simplesmente não foi suficiente importante?

e mesma questão se aplica para os parâmetros opcionais em métodos ... este já estava na primeira versão de vb.net ... então certamente há preguiça que causam MS não permitir parâmetros opcionais, provavelmente decisão arquitetura .. e parece que eles tiveram mudança de coração sobre isso, porque C # 4 vai incluir isso ..

Alguém sabe o que foi a decisão e por que eles dão-lo?

EDIT:

Talvez você não me entende completamente. Estou trabalhando recentemente em um programa de cálculo (números de suporte de qualquer tamanho, para o último dígito), em que alguns métodos são usados ??literalmente milhões de vezes por segundo.

dizer que tenho um método chamado Add (int num), e este método é calma utilizado um lote com 1 como parâmetro (Add(1);), eu descobri que é mais rápido para implementar um método especial especialmente para um. E eu não sobrecarga média - Escrevendo um novo método chamado AddOne, e literalmente copiar o método Add para ele, exceto que em vez de usar num Estou escrevendo 1. Este poder parece terrivelmente estranho para você, mas é realmente mais rápido.

(tanto quanto feia é)

Isso fez-me pergunto por que C # não suporta linha manual que pode ser incrivelmente útil aqui.

graças. (E por que você me votar contra: S)

Editar 2:

Eu me perguntei se ou não adicionar este. Eu estou muito bem familiarizado com a estranheza (e desvantagens) de escolher uma plataforma, como dot net para tal projeto, mas acho que pontilham otimizações líquidas são mais importantes do que você pensa ... especialmente recursos como Qualquer CPU etc.

Foi útil?

Solução

Para responder a parte da sua pergunta, veja post de Eric Gunnerson: Por que C # não tem um 'inline' palavra-chave?

A citação de seu posto:

Para C #, inlining acontece no JIT nível, e o JIT geralmente faz um decisão decente.

EDIT: Eu não tenho certeza da razão para adiada suporta parâmetros opcionais, no entanto dizendo que "desistiu" sobre ele soa como se eles eram esperados para implementá-lo com base em nossas expectativas do que outras línguas oferecido. Imagino que não estava no topo de sua lista de prioridades e tiveram prazos para obter certas características para fora da porta para cada versão. Provavelmente não se levantou em importância até agora, especialmente porque a sobrecarga de método era uma alternativa disponível. Enquanto isso que temos genéricos (2,0), e as características que fazem LINQ possível etc. (3,0). Estou feliz com a progressão da linguagem; as características acima mencionadas são mais importantes para mim do que a obtenção de apoio para os parâmetros opcionais no início.

Outras dicas

inlining manual seria quase inútil. Os inlines compilador JIT métodos durante compilação de código nativo quando apropriado, e eu acho que em quase todos os casos, o compilador JIT é melhor em adivinhar quando é apropriado que o programador.

Quanto aos parâmetros opcionais, eu não sei por que eles não estavam lá nas versões anteriores. Dito isto, eu não gosto deles para estar lá em C # 4, porque eu considerá-los um pouco prejudicial, porque o parâmetro ficar cozido no consumo de montagem e você tem que recompilar-lo se você alterar os valores padrão em uma DLL e quer que o consumidor montagem de usar os novos.

EDIT:

Algumas informações adicionais sobre inlining. Embora você não pode forçar o compilador JIT para inline uma chamada de método, você pode forçá-lo a não in-line uma chamada de método. Para isso, você usar o System.Runtime.CompilerServices.MethodImplAttribute, assim: 

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

    //Other code
}

Meu palpite: a razão versões anteriores do C # não tem parâmetros opcionais é por causa de más experiências com eles em C ++. Na superfície, eles parecem simples e direta o suficiente, mas existem alguns casos de canto incômodo. Eu acho que um dos livros de Herb Sutter descreve isso com mais detalhes; em geral, que tem a ver com substituindo métodos virtual. Maximilian mencionou um dos casos de canto .NET em sua resposta.

Você também pode muito bem conviver com fora-los por escrito manualmente várias sobrecargas; que pode não ser muito bom para o autor da classe, mas os clientes dificilmente vai notar a diferença entre sobrecargas e parâmetros opcionais.

Assim, depois de todos estes anos w / o-los, por que C # 4.0 adicioná-los? 1) paridade melhorada com VB.NET, e 2) de interoperabilidade mais fácil com COM.

Eu estou trabalhando recentemente em um programa de cálculo (números de suporte de qualquer tamanho, para o último dígito), em que alguns métodos são usados ??literalmente milhões de vezes por segundo.

Em seguida, você escolheu um idioma errado. Eu suponho que você realmente perfilado seu código (certo?) E sei que não há nada além de micro-otimizações que podem ajudar você. Além disso, você está usando uma biblioteca bigint nativa de alto desempenho e não escrever o seu próprio, certo?

Se isso é verdade, não use .NET. Se você acha que pode ganhar velocidade na especialização parcial, ir para Haskell, C, Fortran ou qualquer outra linguagem que tanto faz isso automaticamente, ou pode expor inlining a você fazê-lo com a mão.

Se Add(1) realmente importa para você, alocações de heap importa também.

No entanto, você deve realmente olhar para o que o profiler pode dizer ...

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

por que eles não foram feitos desde o início, a sua provavelmente porque sentiram método sobrecargas deu mais flexibilidade. Com a sobrecarga você pode especificar vários 'defaults' com base nos outros parâmetros que você está tomando. Seu também não muito mais sintaxe.

Mesmo em linguagens como C ++, inlining algo não garante que isso vai acontecer; é uma dica para o compilador. O compilador pode tomar a dica, ou fazer o seu próprio coisa .

C # é mais um passo removido do código gerado montagem (via IL + o JIT), por isso se torna ainda mais difícil a garantia de que algo vai inline. Além disso, você tem problemas como os x86 + x64 implementações do JIT diferentes no comportamento.

Java não inclui um em linha palavra-chave também. Os melhores EIC Java pode embutidos até mesmo métodos virtuais, nem o uso de palavras-chave como privada ou final fazer qualquer diferença (que costumava, mas isso já é história antiga).

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top