Como: Migrar para o CLR
Este tópico aborda problemas que possam surgir durante a compilação de código nativo com /clr (consulte a o CLR (ComComummon Idioma Tempo de execução ComComumpilation) Para obter mais informações). /clr permite que os módulos do Visual C++ invocar e ser chamado do .NET assemblies e, ao mesmo tempo, manter a compatibilidade com os módulos não gerenciados. See Misto (nativo e gerenciado) assemblies e Nativo e interoperabilidade .NET Para obter mais informações sobre as vantagens de compilação com /clr.
Conhecidos problemas de compilação biblioteca projetos com/CLR
Visual C++ 2005 contém alguns problemas conhecidos quando compilando projetos de biblioteca com /clr:
Durante a compilação de um projeto de controle ActiveX MFC ActiveX com /clr no ambiente de desenvolvimento**,** o sistema de compilação tentará registrar o arquivo .dll com regasm e não regsvr32. Você deve registrar manualmente o controle com o regsvr32.
Quando você cria um projeto ATL e em seguida, habilite a /clr, os arquivos .c gerará um erro, porque os arquivos .c não podem ser compilados com /clr. No entanto, se você alterar as configurações de arquivo para compilar o arquivo /TP, você irá gerar erros de vinculador. É necessário compilar sistema autônomo arquivos .c sistema autônomo nativa (sem /clr).
Seu código pode consultar tipos em tempo de execução com CRuntimeClass::FromName. No entanto, se um tipo estiver em uma .dll MSIL (compilado com /clr), a telefonar para CRuntimeClass::FromName pode falhar caso ele ocorra antes de executar os construtores estático na .dll gerenciado (você não verá esse problema se a telefonar FromName acontecer depois código for executado em .dll gerenciado). Para contornar esse problema, você pode forçar a construção do construtor estático gerenciado, definindo uma função na DLL gerenciada, exportá-la e invocar o do aplicativo MFC nativo.Por exemplo:
// Extention DLL Header file: __declspec( dllexport ) void EnsureManagedInitialization () { // managed code that won't be optimized away System::GC::KeepAlive(System::Int32::MaxValue); }
Compilar com o Visual C++ 2005
Antes de usar /clr em qualquer módulo no seu projeto, primeiro compilar e vincular seu projeto nativo com Visual C++ 2005.
As seguintes etapas seguidas na ordem, fornecem o caminho mais fácil para um /clr compilação. É importante compilar e executar o projeto após cada uma dessas etapas.
Versões anterior ao Visual C++ 2003
Se você estiver atualizando para Visual C++ 2005 de uma versão anterior ao Visual C++ 2003, você poderá ver erros de compilador relacionados para a conformidade avançado de padrão C++ no Visual C++ 2003. Consulte Quebrar alterações no compilador Visual C++ para obter mais informações.
Atualizando a partir do Visual C++ 2003
Projetos anteriores criados com Visual C++ 2003 pela primeira vez também devem ser compilados sem /clr sistema autônomo Visual C++ 2005 aumentou a conformidade ANSI/ISO e algumas alterações significativas. Consulte Quebrar alterações no compilador Visual C++ para obter mais informações.A alterar que exigem atenção mais provavelmente é Aprimoramentos de segurança na CRT. Código que usa a CRT é muito provável gerar avisos de substituição.Esses avisos podem ser suprimida, mas migrando para o novo Versões com segurança avançada de funções CRT é o preferido, sistema autônomo fornecem melhor segurança e pode revelar problemas de segurança em seu código.
Atualizando do gerenciado Extensions para C++
Projetos criados com Visual C++ .NET ou Visual C++ 2003 usado gerenciado Extensions para C++ exigirá, pelo menos uma alterar sistema autônomo configurações de projeto, conforme essas extensões são agora desaprovadas.sistema autônomo resultado, o código escrito com Extentions gerenciadas para C++ não compila em /clr. Use /clr:oldSyntax em vez disso.
Converter código C para C++
Embora Visual C++ 2005 irá compilar arquivos C, é necessário convertê-los em C++ para um /clr compilação. O nome de arquivo real não precisa ser alterado, você pode usar /Tp (consulte a /Tc, /Tp, /TC, /TP (especificar o tipo de arquivo de origem).) Observe que, embora os arquivos de código-fonte C++ sejam exigidos para /clr, não é necessário re-factor seu código para usar paradigmas orientada a objeto.
Código c é muito provável que exigir alterações quando compilado sistema autônomo um arquivo do C++.As regras de segurança de tipo C++ são rígidas, portanto, conversões de tipo devem ser feitas com conversões explícitas.Por exemplo, malloc retorna um ponteiro nulo, mas pode ser atribuído a um ponteiro para qualquer tipo em C com uma projeção de:
int* a = malloc(sizeof(int)); // C code
int* b = (int*)malloc(sizeof(int)); // C++ equivalent
Ponteiros de função também são estritamente fortemente tipado no C++, o seguinte código C exige a modificação.No C++ é melhor criar um typedef que define o tipo de ponteiro de função e use esse tipo para converter ponteiros de função:
NewFunc1 = GetProcAddress( hLib, "Func1" ); // C code
typedef int(*MYPROC)(int); // C++ equivalent
NewFunc2 = (MYPROC)GetProcAddress( hLib, "Func2" );
C++ também requer que funções seja tanto com protótipo ou totalmente definido antes que eles possam ser referenciados ou chamados.
Identificadores usados no código C que são palavras-chave em C++ (por exemplo, virtual, new, delete, bool, true, falseetc..) deve ser renomeado. Geralmente, isso pode ser concluído com operações de Pesquisar e substituição simples.
Finalmente, ao passo que chamadas COM estilo C exigem o uso explícito da tabela de v e this ponteiro, C++ não:
COMObj1->lpVtbl->Method(COMObj, args); // C code
COMObj2->Method(args); // C++ equivalent
Reconfigurar as configurações do projeto
Após o projeto é compilado e executado em Visual C++ 2005 Você deve criar novas configurações de projeto para /clr em vez de modificar as configurações padrão. /clr é incompatível com algumas opções de compilador e criação de configurações separadas permite construir seu projeto sistema autônomo nativo ou gerenciado. Quando /clr é selecionado na caixa de diálogo de páginas de propriedade, as configurações de projeto não é compatível com /clr estão desativados (e opções desativadas não serão restauradas automaticamente se /clr é subseqüentemente desmarcada).
Criar novas configurações de projeto
Você pode usar Copiar configurações de opção de a Caixa de Diálogo New Project Configuration Para criar uma configuração de projeto com base em suas configurações de projeto existente. Fazer isso vez para a configuração de depurar e uma vez para configuração de versão.Alterações subseqüentes, em seguida, podem ser aplicadas à /clr -configurações específicas, deixando as configurações de projeto original intacto.
Projetos que usam regras de compilação personalizada podem exigir atenção extra.
Essa etapa tem implicações diferentes para projetos que usam makefiles.No caso que um alvo de construção separado pode ser configurado ou versão específica para /clr compilação pode ser criada a partir de uma cópia do original.
Alterar configurações de projeto
/clr pode ser selecionado no ambiente de desenvolvimento, seguindo as instruções no o CLR (ComComummon Idioma Tempo de execução ComComumpilation). sistema autônomo mencionado anteriormente, esta etapa automaticamente desativará configurações conflitantes do projeto.
.gif "Observação") Observação: |
|---|
Ao atualizar um projeto de serviço Web ou biblioteca gerenciado do Visual C++ 2003 para o Visual C++ 2005, o /Zl compilador opção será adicionado à Linha de comando propriedade página.Isso fará com que LNK2001.Remover /Zl do Linha de comando página de propriedades para resolver.Consulte /Zl (omitir o nome da biblioteca padrão) e Como: Abrir o Projeto Propriedade Páginas para mais informações.Ou, então, adicionar msvcrt.lib e msvcmrt.lib do vinculador Dependências adicionaispropriedade . |
Para projetos criados com makefiles, compilador incompatível de opções devem ser desabilitado manualmente uma vez /clr é adicionado. See // CLR restrições Para obter informações sobre as opções de compilador que não são compatível com /clr.
Cabeçalhos pré-compilados
Cabeçalhos pré-compilados são suportados em /clr. No entanto, se você compilar apenas alguns de seus arquivos CPP com /clr (o restante sistema autônomo nativo de compilação) algumas alterações serão necessárias sistema autônomo pré-compilado gerados com cabeçalhos /clr não são compatível com aqueles gerados sem /clr. Essa incompatibilidade é devido ao fato que /clr gera e requer metadados. Módulos compilados /clr Portanto, não pode usar cabeçalhos pré-compilados não incluam metadados, e não /clr módulos não é possível usar arquivos de cabeçalho pré-compilado que contêm metadados.
A maneira mais fácil de compilar um projeto em que alguns módulos são compilados /clr é desabilitar totalmente a cabeçalhos pré-compilados. (No projeto propriedade Pages diálogo, abra o nó C/C ++ e selecionar Precompiled Headers.Em seguida, alterar a propriedade criar/Use Precompiled Headers como "Not Using Precompiled Headers".)
No entanto, especialmente para projetos grandes, cabeçalhos pré-compilados fornecem velocidade de compilação muito melhor, para que desativar esse recurso não seja desejável.Nesse caso é melhor configurar o /clr e não /clr arquivos para usar cabeçalhos pré-compilados separados. Isso pode ser concluído em uma etapa por multi-selecting módulos para ser compilado /clr usando o gerenciador de soluções, clicando com o botão direito do mouse no agrupar e selecionando Propriedades. Em seguida, altere o arquivo de cabeçalho pré-compilados e criar/usar PCH através do arquivo propriedades para usar um nome de arquivo de cabeçalho diferente e o arquivo PCH respectivamente.
Corrigindo erros
Compilando com /clr pode resultar em erros de tempo de execução do compilador, vinculador ou. Esta seção aborda os problemas mais comuns.
Metadados de mesclagem
Versões diferentes dos tipos de dados podem fazer com que o vinculador falhe, pois não coincide com os metadados gerados para os dois tipos.(Isso geralmente é causado quando os membros de um tipo condicionalmente são definidos, mas não as condições são os mesmos para todos os arquivos CPP que usam o tipo.) Nesse caso o vinculador falha, relatórios, somente o nome do símbolo e o nome do segundo arquivo OBJ onde o tipo foi definido.Muitas vezes é útil girar a ordem em que arquivos OBJ são enviados para o vinculador para descobrir a localização da versão do tipo de dados.
deadlock do carregador bloquear
No Visual C++ .NET e Visual C++ 2003, a inicialização em /clr foi suscetível a paralisação não-determinística. Esse problema é conhecido sistema autônomo "deadlock de deadlock de carregador".In Visual C++ 2005 , esse deadlock é mais fácil evitar, ele é detectado e reportado em tempo de execução e não é mais não-determinística. Encontrar o problema de bloquear de carregador ainda é possível, mas agora é muito mais fácil evitar e corrigir.See Inicialização de assemblies mistos de apoio detalhado, orientação e soluções.
Exporta dados
Exportação de dados DLL é propenso a erros e não recomendável.Isso ocorre porque a seção de dados de uma DLL não é garantida a ser inicializado até que alguma parte gerenciado da DLL tenha sido executada.Metadados de referência com The # Using Directive.
Visibilidade de tipo
Tipos nativo agora são privados por padrão.No Visual C++ .NET 2002 e Visual C++ 2003, os tipos nativo eram públicos por padrão.Isso pode resultar em um tipo nativo não sendo visíveis fora da DLL.Resolver esse erro, adicionando public para esses tipos. Consulte Tipo e visibilidade de associados para obter mais informações.
Flutuante ponto e problemas de alinhamento
__controlfp não é compatível com o Common linguagem tempo de execução (consulte a _control87, _controlfp, __control87_2 Para obter mais informações). O CLR também respeitarão não alinhar (C++).
Inicialização de COM
O Common linguagem tempo de execução inicializa COM automaticamente quando um módulo é inicializado (quando COM é inicializado automaticamente ela tem concluído isso sistema autônomo MTA).sistema autônomo resultado, inicializar explicitamente COM gera códigos de retorno indicando que COM já foi inicializada.Tentando inicializar explicitamente COM um modelo de threading quando o CLR já foi inicializado COM para outro modelo de threading pode fazer com que seu aplicativo falhar.
COM inicialização e código de erro associado ou deverá permitir para o caso em que já foi inicializado COM ou chamadas para CoInitialize e CoUninitialize pode geralmente simplesmente ser removido. O Common linguagem tempo de execução começa COM sistema autônomo MTA por padrão; use /CLRTHREADATTRIBUTE (atributo de conjunto CLR segmento) Para modificar isso.
Problemas de desempenho
Você pode ver uma redução no desempenho quando métodos nativo do C++ gerados para MSIL são chamados indiretamente (chamadas de função virtual ou usar ponteiros de função).Para saber mais sobre isso, consulte Duplo conversão (C++).
Ao mover de nativo para MSIL, você observará um aumento no dimensionar do conjunto de trabalho.Isso ocorre porque o common linguagem tempo de execução fornece muitos recursos para garantir que os programas funcionem corretamente.Se seu /clr aplicativo não está sendo executado corretamente, você pode habilitar C4793 (desativado por padrão), consulte Compilador C4793 de aviso (nível 1 e 3) Para obter mais informações.
Programa falha no desligado
Em alguns casos, o CLR pode desligado antes de termina seu código gerenciado em execução.Usando std::set_terminate e SIGTERM Isso pode causar. Consulte Constantes de sinal e set_terminate (< exceção >) para mais informações.
Usando novos recursos do Visual C++
Depois que o aplicativo compila, links e é executado, você pode começar a usar recursos do .NET em qualquer módulo compilado com /clr. Para obter mais informações, consulte Novo Features Idioma in Visual C++.
Se você tiver usado o gerenciado Extensions para C++, você pode converter o código para usar a nova sintaxe.Para obter um resumo das diferenças sintáticas, consulte o Lista de verificação de atualização de gerenciado Extensions para C++ sintaxe. Para obter detalhes sobre a conversão de gerenciado Extensions para C++, consulte C + c++ / CLI migração Primer.
Para obter informações sobre programação em Visual C++ .NET consulte: