Considerações sobre desempenho para interoperabilidade (C++)
Este tópico fornece diretrizes para reduzir o efeito de gerenciados/não gerenciados transições de interoperabilidade no desempenho em tempo de execução.
Visual C++ oferece suporte os mesmos mecanismos de interoperabilidade que outras.NET idiomas como, por exemplo, Visual Basic e C# (P/Invoke), mas ele também fornece suporte de interoperabilidade que é específico para Visual C++ (interoperabilidade de C++).Para aplicativos essenciais de desempenho, é importante entender as implicações de desempenho de cada técnica de interoperabilidade.
Independentemente da interoperabilidade técnica usada, seqüências de transição especiais, chamadas thunks, são necessárias sempre que uma função gerenciada chama uma função e vice-versa não gerenciada.Esses thunks são inseridos automaticamente pelo compilador Visual C++, mas é importante ter em mente que cumulativamente, essas transições podem ser caras em termos de desempenho.
Reduzindo transições
Uma maneira de evitar ou reduzir o custo de interoperabilidade thunks é Refatorar as interfaces envolvidas minimizar gerenciados/não gerenciados transições.Melhorias drásticas no desempenho pode ser feita pelo direcionamento interfaces informais, que são aqueles envolvidos chamadas freqüentes limite gerenciado /.Uma função gerenciada que chama uma função não gerenciada em um loop estreito, por exemplo, é um bom candidato para refatoração.Se o próprio loop é movido para o lado não gerenciado ou se uma alternativa gerenciada para a chamada não gerenciada é criada (talvez ser dados de enfileiramento de mensagens no lado gerenciado e empacotamento para a API não gerenciada vez após o loop), o número de transições pode ser reduzido significativamente.
P/Invoke vs.Interoperabilidade de C++
Para.NET linguagens, como, por exemplo, Visual Basic e C#, o método prescrito para interoperar com componentes nativos é P/Invoke.Porque P/Invoke é suportado pelo.NET Framework, Visual C++ o suporta bem, mas o Visual C++ também fornece seu próprio suporte de interoperabilidade, que é chamado de interoperabilidade de C++.Interoperabilidade de C++ é preferencial sobre P/Invoke porque P/Invoke não é tipo seguro.Como resultado, principalmente são relatados erros em tempo de execução, mas interoperabilidade de C++ também tem vantagens de desempenho sobre P/Invoke.
Ambas as técnicas requerem várias coisas aconteça sempre que uma função gerenciada chama uma função não gerenciada:
Os argumentos da chamada de função são empacotados do CLR para tipos nativos.
Um thunk não gerenciado a gerenciado é executado.
A função não gerenciada é chamada (usando as nativas versões dos argumentos).
Um thunk não gerenciado para gerenciado é executado.
O tipo de retorno e qualquer "out" ou "no, out" argumentos são empacotados de nativo para tipos CLR.
Thunks gerenciado/são necessárias para interoperabilidade funcionar, mas o empacotamento de dados que é necessário depende dos tipos de dados envolvidos, a assinatura de função e como os dados serão usados.
O empacotamento de dados executada pelo interoperabilidade de C++ é a forma mais simples possível: os parâmetros são simplesmente copiados limite gerenciado/não gerenciado de maneira bit a bit; Nenhuma transformação é realizada em todos os.P/Invoke, isso só é verdadeiro se todos os parâmetros são simples, tipos blittable.Caso contrário, P/Invoke executa etapas muito eficientes para converter cada parâmetro gerenciado em um tipo nativo apropriado e vice-versa, se os argumentos são marcados como "saída" ou "no, out".
Em outras palavras, interoperabilidade de C++ usa o método mais rápido possível de empacotamento de dados, enquanto o P/Invoke usa o método mais robusto.Isso significa que a interoperabilidade de C++ (de uma forma típica para C++) fornece desempenho ideal por padrão, e o programador é responsável pelo endereçamento casos em que esse comportamento não é seguro ou apropriado.
Interoperabilidade de C++, portanto, requer que o empacotamento de dados deve ser fornecido explicitamente, mas a vantagem é que o programador é livre para decidir o que é apropriado, dada a natureza dos dados e como ele será usado.Além disso, embora o comportamento de empacotamento de dados P/Invoke pode ser modificado no personalizado para um grau, interoperabilidade de C++ permite que dados empacotamento para serem personalizados em uma base por chamada.Não é possível com P/Invoke.
Para obter mais informações sobre interoperabilidade de C++, consulte Usando interoperabilidade C++ (PInvoke implícita).