Considerações sobre desempenho para interoperabilidade (C++)
Este tópico fornece diretrizes para reduzir o efeito de gerenciado/não gerenciado transições de interoperabilidade no desempenho em time de execução.
O Visual C++ oferece suporte sistema autônomo mesmos mecanismos de interoperabilidade sistema autônomo idiomas Outros .NET sistema autônomo Visual Basic e translation from VPE for Csharp (P/Invoke), mas também fornece suporte de interoperabilidade que é específico para o Visual C++ (interoperabilidade C++).Para aplicativos críticos 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 um função não gerenciada e vice-versa.Esses thunks são inseridos automaticamente pelo compilador Visual C++, mas é importante ter em mente que cumulativamente, dessas transições podem ser caros em termos de desempenho.
Reduzindo transições
Uma maneira de evitar ou reduzir o custo de interoperabilidade thunks é refatorar as interfaces envolvidas minimizar as transições gerenciado/não gerenciado.Melhorias drásticas no desempenho podem ser feitas ao direcionar interfaces informais, que são aqueles envolvidos chamadas freqüentes por limite gerenciado /.A gerenciado função que chama uma desinstalação gerenciado função em um loop apertado, por exemplo, é um mercadoria candidato para refatoração.Se o próprio loop é movido para o lado não gerenciado ou se uma alternativa gerenciada para a telefonar não gerenciada é criada (talvez ser Enfileirando dados no lado gerenciado e, em seguida, o marshaling para a API não gerenciada ao mesmo tempo após o loop), o número de transições de pode ser reduzido significativamente.
P/Invoke vs.Interoperabilidade de C++
Para idiomas do .NET, sistema autônomo, por exemplo, Visual Basic e translation from VPE for Csharp, o método prescrito para interoperar com componentes nativo é P/Invoke.Porque P/Invoke é suportada pelo .NET estrutura, Visual C++ for compatível, bem, mas Visual C++ também fornece seu próprio suporte de interoperabilidade, que é chamado de interoperabilidade de C++.Interoperabilidade de C++ é preferível P/Invoke porque P/Invoke não seguros.sistema autônomo resultado, principalmente são relatados erros em time de execução, mas interoperabilidade C++ também tem vantagens de desempenho sobre P/Invoke.
Ambas as técnicas requerem várias coisas a serem sempre que uma função gerenciada chama uma função não gerenciada:
Os argumentos da telefonar de função são empacotados do CLR para tipos nativo.
Uma conversão de não gerenciado para gerenciado é executado.
A função não gerenciada é chamada (usando as versões nativas dos argumentos).
Uma conversão de não gerenciado para gerenciado é executado.
O tipo de retorno e qualquer "saída" ou "in, out" argumentos são empacotados de nativo para tipos CLR.
Thunks gerenciado/não gerenciado são necessários para a interoperabilidade funcione em todas as, mas o marshaling de dados que é necessário depende dos tipos de dados envolvidos, a assinatura de função e como os dados serão usados.
O marshaling de dados realizado por interoperabilidade C++ é a forma mais simples possível: os parâmetros são simplesmente copiados entre o limite gerenciado/não gerenciados de maneira bit a bit; Nenhuma transformação é realizada em todos os.Para o P/Invoke, isso só será true se todos os parâmetros são simples, tipos blittable.Caso contrário, P/Invoke realiza etapas muito eficientes para converter cada parâmetro gerenciado para um tipo nativo apropriado e vice-versa se sistema autônomo argumentos estiverem marcados sistema autônomo "out" ou "in, out".
Em outras palavras, interoperabilidade de C++ usa o método possível mais rápido de marshaling de dados, enquanto o P/Invoke usa o método mais robusto.Isso significa que a interoperabilidade C++ (de maneira típica para C++) fornece um 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 marshaling de dados deve ser fornecido explicitamente, mas a vantagem é que o programador é disponível decidir o que for apropriado, dada a natureza dos dados e como ele deve ser usada.Além disso, embora o comportamento do marshaling de P/Invoke dados pode ser modificado no personalizado para um grau, interoperabilidade de C++ permite que dados de marshaling para serem personalizados em uma base por telefonar.Isso não é possível com P/Invoke.
Para obter mais informações sobre interoperabilidade de C++, consulte Usando a interoperabilidade de C++ (PInvoke implícita).