sirve - Código de Visual Studio para.Net Framework

visual studio code new c# project

Question

Estoy teniendo dificultades para determinar si y cómo puedo usar Visual Studio Code para desarrollar y depurar la línea de comandos / consola / bibliotecas de los programas de C # .Net que no se pueden ejecutar en .Net Core , es decir, requieren .Net Framework . Necesito acceder a Oracle que no tiene un proveedor .Net Core, pero sí tiene un proveedor de .Net Framework administrado. Utilizo VS 2015/2017 para esta tarea, pero me gustaría cambiar a Código VS si pudiera codificar, compilar y depurar .Net Framework target programas C #. He intentado buscar en Google y no pude encontrar nada.

Answer 1

Desafortunadamente, no presenta intellisense para C / C ++, solo resaltado de sintaxis: code.visualstudio.com/docs/languages ​​EDIT: tampoco integración de depurador para C / C ++. ¡La integración de git es realmente agradable! Parece más diseñado para aplicaciones web, el depurador funciona para node.js

Si bien esto no especifica C #, es lógico que se apliquen los mismos estándares (que es que no hay depurador ni funcionalidad de compilación).

Cita tomada del comentario en la primera respuesta de stackoverflow.com/questions/29953743/…

Answer 2

Acabo de crear una aplicación de consola simple y personalicé el archivo csproj. Después, podría adjuntar el depurador OmniSharp a una aplicación de marco .NET completa. El archivo csproj se ve así:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net47</TargetFramework>
    <PlatformTarget>x64</PlatformTarget>
    <DebugType>portable</DebugType>
  </PropertyGroup>

</Project>

Acabo de seguir la https://github.com/OmniSharp/omnisharp-vscode/wiki/Desktop-.NET-Framework : cambié TargetFramework para ejecutarse en .NET 4.7, PlatformTarget a 64 bit y DebugType a portable.

Además, actualicé launch.json:

{
   // Use IntelliSense to find out which attributes exist for C# debugging
   // Use hover for the description of the existing attributes
   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
   "version": "0.2.0",
   "configurations": [
        {
            "name": ".NET Core Launch (console)",
            "type": "clr",
            "request": "launch",
            "preLaunchTask": "build",
            // If you have changed target frameworks, make sure to update the program path.
            "program": "${workspaceFolder}/bin/Debug/net47/FullNetInVsCode.exe",
            "args": [],
            "cwd": "${workspaceFolder}",
            // For more information about the ''console'' field, see https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md#console-terminal-window
            "console": "internalConsole",
            "stopAtEntry": false,
            "internalConsoleOptions": "openOnSessionStart"
        },
        {
            "name": ".NET Core Attach",
            "type": "clr",
            "request": "attach",
            "processId": "${command:pickProcess}"
        }
    ,]
}

En este archivo, acabo de cambiar de type a clr en ambos objetos JSON, y el program dirigido al archivo exe.

Luego, pude establecer un punto de interrupción y simplemente presionar F5 para comenzar la depuración en el marco completo de .NET:

Answer 3

Ok, aunque llego tarde, estoy publicando esta respuesta, ya que podría ayudar a otras personas que enfrentan este problema, lo cual fue bastante agotador para mí.

Lo primero, las actualizaciones más recientes para Visual Studio Code son compatibles con la creación y depuración de proyectos para .NET Framework, pero es muy limitado:

La extensión de C # admite la depuración de .NET completa y limitada. Solo puede depurar aplicaciones de 64 bits con PDB portátiles. https://github.com/OmniSharp/omnisharp-vscode/wiki/Desktop-.NET-Framework

Como se dice en OmniSharp (responsable de la extensión C #) github, el proyecto debe ser una aplicación de 64 bits con PDB portátiles.

Pero, incluso después de leer muchos temas y discusiones sobre este tema, no me quedó claro cuáles eran los pasos necesarios. Así que expondré aquí una pequeña guía con los pasos que he seguido y que funcionaron para mí, y espero que también lo sean para usted.

1) Los archivos / carpetas necesarios son:

a) .vscode con launch.json y tasks.json

b) carpeta bin / Debug para su aplicación exe y los ensamblajes a los que le gustaría crear una referencia

d) los archivos .csproj y Program.cs

e) opcionalmente un archivo por lotes, cuyo propósito describiré más adelante

2) Instalar el MSBuild 15

3) En el archivo .csproj:

• cambie Project Sdk = "Microsoft.NET.Sdk" a Project ToolsVersion = "15.0" xmlns = "http://schemas.microsoft.com/developer/msbuild/2003"

• en el primer Grupo de propiedades debemos establecer el Tipo de salida en Exe (el valor predeterminado puede ser dll), eliminar la propiedad TargetFramework, reemplazando con TargetFrameworkVersion con el valor v4.6.1 (ejemplo para .NET Framwork 4.6.1, puede ser 4.7 por ejemplo) y, finalmente, ponga los tiempos de ejecución win-x64 y win7-x64 (y cualquier otro que el compilador pueda quejarse). Este primer grupo debería verse así:

 <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
    <RuntimeIdentifiers>win-x64;win7-x64</RuntimeIdentifiers>
 </PropertyGroup>

• establecer otro grupo de propiedades con los siguientes itens:

  <PropertyGroup Condition=" ''$(Configuration)|$(Platform)'' == ''Debug|AnyCPU'' ">
    <PlatformTarget>x64</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>portable</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin/Debug/</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>

Algunos comentarios: la condición utilizada indica que estas propiedades solo se aplican cuando la configuración pasada al compilador es Depurar y la Plataforma es "AnyCPU", es posible que desee insertar otras condiciones con valores diferentes, o incluso que no utilice una condición en absoluto; los valores más importantes aquí son: La propiedad PlatformTarget debe ser x64 y DebugType debe ser portátil ; la ruta de salida se establece en bin / Debug.

• Como no estamos usando Microsoft Sdk, debemos incluir Program.cs para que el compilador pueda encontrarlo:

  <ItemGroup>
    <Compile Include="Program.cs" />
  </ItemGroup>

• Crea las referencias necesarias a tu proyecto; ejemplo:

<ItemGroup>
    <Reference Include="mscorlib" />
    <Reference Include="System.Core" />
    <Reference Include="System.Windows" />
    <Reference Include="System.ServiceModel" />  
    <Reference Include="System.Net" />
    <Reference Include="System.Xml" />
    <Reference Include="System" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Net.Http" />
</ItemGroup>

• finalmente importe las siguientes herramientas (asegúrese de seguir el orden expuesto aquí, colocando esto al principio, por ejemplo, genera un error)

  <Import Project="$(MSBuildToolsPath)/Microsoft.CSharp.targets" />

Todo debería verse así:

<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
    <RuntimeIdentifiers>win-x64;win7-x64</RuntimeIdentifiers>
  </PropertyGroup>

  <PropertyGroup Condition=" ''$(Configuration)|$(Platform)'' == ''Debug|AnyCPU'' ">
    <PlatformTarget>x64</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>portable</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin/Debug/</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>

  <PropertyGroup Condition=" ''$(Configuration)|$(Platform)'' == ''Release|AnyCPU'' ">
    <PlatformTarget>x64</PlatformTarget>
    <DebugType>portable</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin/Release/</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>

  <ItemGroup>
    <Compile Include="Program.cs" />
  </ItemGroup>

  <ItemGroup>
    <Reference Include="mscorlib" />
    <Reference Include="System.Core" />
    <Reference Include="System.Windows" />
    <Reference Include="System.ServiceModel" />  
    <Reference Include="System.Net" />
    <Reference Include="System.Xml" />
    <Reference Include="System" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Net.Http" />
  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)/Microsoft.CSharp.targets" />
  
</Project>

4) en el launch.json:

• Cree una nueva configuración (por ejemplo, MyLauncher), cuyo tipo debe ser clr , y que apunte a su programa; preLaunchTask se configurará en una configurada manualmente, "mybuild", por ejemplo, que se especificará en tasks.json; Un ejemplo de configuración es:

   "version": "0.2.0",
   "configurations": [

        {
            "name": "MyLauncher",
            "type":"clr",
            "request": "launch",
            "preLaunchTask": "mybuild",
            "program": "${workspaceFolder}/bin/Debug/<project>.exe",
            "args":[],
            "console": "internalConsole",
            "stopAtEntry": false,
            "internalConsoleOptions": "openOnSessionStart"
        },
        
        { other configurations...
        }
        
    ,]
}

5) en las tareas.json:

• Crea una tarea "mybuild" con los comandos para construir tu proyecto
• Usaremos el MSBuild 15 aquí (no use la compilación dotnet, al menos no me ha funcionado)
• Puede apuntar directamente al archivo (ruta) / MSBuild.exe (o msbuild.exe, si está en el archivo% PATH%) con los argumentos para generar el proyecto. A continuación se muestra un ejemplo. Tenga en cuenta que he establecido la configuración en Debug y la plataforma en AnyCPU, coincidiendo con la condición que he establecido en el archivo .csproj. También tenga en cuenta que las barras invertidas en / "AnyCPU /" se deben al uso de la oferta. marcas.

{
    "version": "2.0.0",
    "tasks": [
    
        {
            "label": "mybuild",
            "command":"<path to msbuild>/MSBuild.exe",
            "type":"shell",
            "args":[
                "<project>.csproj",
                "/t:Build",
                "/p:Configuration=Debug",
                "/p:Platform=/"AnyCPU/""
            ]
        }

    ]
}

• pero hay otra forma, usando el archivo .bat; en mi caso, la ruta al MSBuild.exe tenía espacios y eso generaba un error cuando se ejecutaba la tarea, de modo que puse el siguiente código en un archivo .bat (guarde el bloc de notas como name.bat):

  "(path) / MSBuild.exe" (proyecto) .csproj / t: Build / p: Configuration = Debug / p: Platform = "AnyCPU"

Y luego configure la tarea "mybuild" en:

        {
            "label": "mybuild",
            "command":"build.bat",
            "type":"shell",
            "args":[]
        }

Donde build.bat es el archivo por lotes que he creado con el código anterior

6) Después de esto, es posible que tenga que guardar, cerrar y volver a abrir los archivos (esto muchas veces me soluciona los problemas)

7) Establezca su configuración en el depurador en MyLauncher:

print

8) Ejecute su código con el botón de reproducción verde; llamará a MyLaunch, que primero construirá su proyecto con MSBuild 15 y luego ejecutará el archivo exe

Así que eso fue todo.

Espero que te ayude.

Sería genial si pudiera dar algún comentario.

Saludos

I dont know how to use this site very well, so Ive let some references here, because it wasnt letting me:

https://github.com/OmniSharp/omnisharp-vscode/issues/813
https://github.com/OmniSharp/omnisharp-vscode/issues/1365
https://github.com/OmniSharp/omnisharp-vscode/wiki/Portable-PDBs

Answer 4

https://code.visualstudio.com/docs/languages/csharp

Citar:

Nota: VS Code no admite la depuración de aplicaciones que se ejecutan en Desktop .NET Framework .

Parece que el IDE "completo en grasa" de Visual Studio sigue siendo un requisito para .Net Framework. Lástima mayor.