visual studio punto puede modo interrupción interrupcion ejecutar codigo actualmente activará .net visual-studio 64bit 32bit-64bit

.net - puede - el punto de interrupción no se activará actualmente visual studio 2015



Usar de forma condicional la referencia de 32/64 bits cuando se construye en Visual Studio (5)

Tengo un proyecto que se construye en 32/64 bits y tiene dependencias correspondientes de 32/64 bits. Quiero poder cambiar las configuraciones y utilizar la referencia correcta, pero no sé cómo decirle a Visual Studio que use la dependencia apropiada para la arquitectura.

Tal vez estoy haciendo esto de la manera incorrecta, pero quiero poder cambiar entre x86 y x64 en el menú desplegable de configuración y hacer que la DLL a la que se hace referencia sea la correcta.

AFAIK, si su proyecto requiere referencias que son específicas de 32 bits o de 64 bits (es decir, ensamblados de interoperabilidad COM), y no tiene interés en editar manualmente el archivo .csproj, entonces tendrá que crear archivos de 32 bits por separado y Proyectos de 64 bits.

Debo señalar que la siguiente solución no ha sido probada, pero debería funcionar. Si está dispuesto a editar manualmente el archivo .csproj, entonces debería poder lograr el resultado deseado con un único proyecto. El archivo .csproj es solo un script de MSBuild, así que para una referencia completa, mira here . Una vez que haya abierto el archivo .csproj en un editor, ubique los elementos <Reference> . Debería poder dividir estos elementos en 3 grupos de elementos distintos: referencias que no son específicas de la plataforma, referencias específicas de x86 y referencias específicas de x64.

Aquí hay un ejemplo que asume que su proyecto está configurado con plataformas de destino llamadas "x86" y "x64"

<!-- this group contains references that are not platform specific --> <ItemGroup> <Reference Include="System" /> <Reference Include="System.Core" /> <!-- any other references that aren''t platform specific --> </ItemGroup> <!-- x86 specific references --> <ItemGroup Condition=" ''$(Platform)'' == ''x86'' "> <Reference Include="MyComAssembly.Interop"> <HintPath>../../lib/x86/MyComAssembly.Interop.dll</HintPath> </Reference> <!-- any additional x86 specific references --> </ItemGroup> <!-- x64 specific referneces --> <ItemGroup Condition=" ''$(Platform)'' == ''x64'' "> <Reference Include="MyComAssembly.Interop"> <HintPath>../../lib/x64/MyComAssembly.Interop.dll</HintPath> </Reference> <!-- any additional x64 specific references --> </ItemGroup>

Ahora, cuando configura su proyecto / configuración de compilación de la solución para apuntar a la plataforma x86 o x64, debe incluir las referencias adecuadas en cada caso. Por supuesto, tendrá que jugar con los elementos <Reference> . Incluso podría configurar proyectos ficticios donde agregue las referencias x86 y x64, y luego simplemente copie los elementos <Reference> necesarios de esos archivos ficticios de proyecto a su archivo de proyecto "real".


Editar 1
Aquí hay un enlace a los elementos comunes del proyecto MSBuild, que dejé accidentalmente en la publicación original: http://msdn.microsoft.com/en-us/library/bb629388.aspx

Enfrenté el mismo problema y pasé bastante tiempo buscando una solución decente. La mayoría de las personas ofrece la edición manual de los archivos de solución de Visual Studio, lo que es bastante tedioso, propenso a errores y confuso cuando se exploran estos archivos editados en la GUI de Visual Studio posteriormente. Cuando ya me rendí, la solución surgió por sí misma. Es muy similar a lo que recomienda Micke en su respuesta anterior.

En el administrador de cuentas creé dos objetivos de compilación separados para las plataformas x86 y x64, como de costumbre. Luego, agregué una referencia al ensamblaje x86 a mi proyecto. En este punto, creí que el proyecto está configurado para la construcción x86 solamente y nunca se compilará para la configuración x64, a menos que haga una edición manual de la misma tal como lo sugirió Hugo arriba.

Después de un tiempo, finalmente me olvidé de la limitación y accidentalmente comencé la compilación x64. Por supuesto, la compilación falló. Pero importante fue el mensaje de error que recibí. El mensaje de error indicó que el ensamblado nombrado exactamente como mi ensamblado x86 referenciado falta en la carpeta destinada como objetivo de compilación x64 para mi solución.

Habiendo notado esto, he copiado manualmente el ensamblaje x64 apropiado en este directorio. ¡Gloria! Mi construcción x64 tuvo éxito milagrosamente con el ensamblaje adecuado encontrado y vinculado implícitamente. Fue cuestión de minutos modificar mi solución para establecer un directorio de destino de compilación para el ensamblaje x64 en esta carpeta. Después de estos pasos, la solución se genera automáticamente para x86 y x64 sin ninguna edición manual de los archivos de MSBuild.

Para resumir:

  1. Crear objetivos x86 y x64 en un solo proyecto
  2. Agregue todas las referencias de proyecto adecuadas a los ensamblajes x86
  3. Establezca un directorio de destino de compilación común para todos los ensamblados x64
  4. En caso de que tenga ensamblados x64 listos, simplemente cópielos una vez en su directorio de destino de compilación x64.

Después de completar estos pasos, su solución se compilará correctamente para las configuraciones x86 y x64.

Esto funcionó para mí en el proyecto Visual Studio 2010 .NET 4.0 C #. Evidentemente, este es un tipo de comportamiento interno no documentado de Visual Studio, que podría estar sujeto a cambios en las versiones de 2012, 2013 y 2015. Si alguien intenta probar otras versiones, por favor comparta su experiencia.

Esto es lo que hice en un proyecto anterior, que requerirá la edición manual de los archivos .csproj. También necesita directorios separados para los diferentes binarios, idealmente hermanos entre sí, y con el mismo nombre que la plataforma a la que se dirige.

Después de agregar las referencias de una sola plataforma al proyecto, abra .csproj en un editor de texto. Antes del primer elemento <ItemGroup> dentro del elemento <Project> , agregue el siguiente código, que ayudará a determinar en qué plataforma está ejecutando (y compilando).

<!-- Properties group for Determining 64bit Architecture --> <PropertyGroup> <CurrentPlatform>x86</CurrentPlatform> <CurrentPlatform Condition="''$(PROCESSOR_ARCHITECTURE)''==''AMD64'' or ''$(PROCESSOR_ARCHITEW6432)''==''AMD64''">AMD64</CurrentPlatform> </PropertyGroup>

Luego, para las referencias específicas de su plataforma, realiza cambios como los siguientes:

<ItemGroup> <Reference Include="Leadtools, Version=16.5.0.0, Culture=neutral, PublicKeyToken=9cf889f53ea9b907, processorArchitecture=x86"> <SpecificVersion>False</SpecificVersion> <HintPath>../../Lib/Leadtools/$(CurrentPlatform)/Leadtools.dll</HintPath> </Reference> <Reference Include="Leadtools.Codecs, Version=16.5.0.0, Culture=neutral, PublicKeyToken=9cf889f53ea9b907, processorArchitecture=x86"> <SpecificVersion>False</SpecificVersion> <HintPath>../../Lib/Leadtools/$(CurrentPlatform)/Leadtools.Codecs.dll</HintPath> </Reference> <Reference Include="Leadtools.ImageProcessing.Core, Version=16.5.0.0, Culture=neutral, PublicKeyToken=9cf889f53ea9b907, processorArchitecture=x86"> <SpecificVersion>False</SpecificVersion> <HintPath>../../Lib/Leadtools/$(CurrentPlatform)/Leadtools.ImageProcessing.Core.dll</HintPath> </Reference> <Reference Include="System" /> <Reference Include="System.Core" /> <Reference Include="System.Data.Entity" /> <!-- Other project references --> </ItemGroup>

Tenga en cuenta el uso de la propiedad $(CurrentPlatform) , que definimos anteriormente. En cambio, podría usar condicionales para qué ensamblajes incluir qué plataforma. También podría necesitar:

  • Reemplace $(PROCESSOR_ARCHITEW6432) y $(PROCESSOR_ARCHITECTURE) con $(Platform) para considerar SOLAMENTE la plataforma de destino de los proyectos
  • Modifique la lógica de determinación de plataforma para que sea apropiada para la máquina actual, de modo que no esté creando / haciendo referencia a un binario de 64 bits para ejecutar en una plataforma de 32 bits.

Lo escribí originalmente para una Wiki interna en el trabajo, sin embargo, lo he modificado y publicado todo el proceso en mi blog , si está interesado en las instrucciones detalladas paso a paso.

Estoy haciendo referencia a las DLL x86, ubicadas en, por ejemplo, / component / v3_NET4, en mi proyecto. Las DLL específicas para x86 / x64 se encuentran en subcarpetas denominadas "x86" y "x64" respectivamente.

Luego estoy usando una secuencia de comandos previa a la compilación que copia las DLL apropiadas (x86 / x64) en la carpeta referenciada, en base a $ (PlatformName).

xcopy /s /e /y "$(SolutionDir)../component/v3_NET4/$(PlatformName)/*" "$(SolutionDir)../component/v3_NET4"

Funciona para mi.

Puede usar una condición para un ItemGroup para las referencias dll en el archivo de proyecto.
Esto hará que visual studio vuelva a verificar la condición y las referencias siempre que cambie la configuración activa.
Solo agrega una condición para cada configuración.

Ejemplo:

<ItemGroup Condition=" ''$(Configuration)|$(Platform)'' == ''Release|x86'' "> <Reference Include="DLLName"> <HintPath>../DLLName.dll</HintPath> </Reference> <ProjectReference Include="../MyOtherProject.vcxproj"> <Project>{AAAAAA-000000-BBBB-CCCC-TTTTTTTTTT}</Project> <Name>MyOtherProject</Name> </ProjectReference> </ItemGroup>