C# - F # Supporto di interoperabilità in Visual Studio 2015 su .NET Core

Question

Nota: qui parlo di core dotnet e non di framework completo! Per il framework completo ci sono un sacco di documenti su questo, ma questo è core dotnet.

devo una libreria # F creato da

dotnet new --lang F# 

E un # un'applicazione ASP.NET core RC2 C (creato da File-> Nuovo progetto in VS).

Ora uso la mia libreria F # da C# (immagino uno scenario molto comune ...). Il progetto F # è referenziato in project.json come qualsiasi altra libreria .net (elencandola sotto dipendenze)

Ora tutto questo compila e funziona bene, il che è fantastico!

L'unico problema è che VS non sembra supportarlo. Non c'è intellisense e le linee, dove uso le funzioni F # da C# sono contrassegnate come errori. Anche il debug da C# a F # non funziona. L'ho provato su un Mac con VS Code, lo stesso ...

Quando premo compilare, i compilatori lo capiscono e tutto va bene.

Questa schermata riassume (questo è dove io chiamo una funzione F # da C#):

Quindi, in pratica ho finito con la soluzione VS con un mucchio di errori in esso, che compila ancora.

Here è un semplice riproduttore.

Domande:

1. caso IntelliSense e il lavoro di debug in VS a tutti?
2. Se sì, cosa ho sbagliato?
3. In caso negativo, è previsto che questo scenario venga coperto nel futuro ?

Ecco il codice dal riproduttore:

F # biblioteca - project.json (creato da cli - dotnet new --lang F#)

"version": "1.0.0-*", 
    "buildOptions": { 
    "compilerName": "fsc", 
    "compile": { 
     "includeFiles": [ 
     "FSharpLibrary.fs" 
     ] 
    } 
    }, 
    "dependencies": { 
    "Microsoft.FSharp.Core.netcore": "1.0.0-alpha-160316", 
    "NETStandard.Library": "1.5.0-rc2-24027" 
    }, 
    "tools": { 
    "dotnet-compile-fsc": { 
     "version": "1.0.0-*", 
     "imports": [ 
     "dnxcore50", 
     "portable-net45+win81", 
     "netstandard1.3" 
     ] 
    } 
    }, 
    "frameworks": { 
    "netstandard1.5": { 
     "imports": [ 
     "portable-net45+win8", 
     "dnxcore50" 
     ] 
    } 
    } 

F # biblioteca, il codice:

namespace FSharpLibrary 

module Sample = 

    let public FSharpFunction number = 
      printfn "Hello From F#, %d" number 

Applicazione C# (qui uso un'app per console, ma le stesse cose di asp.net core)

using System; 
namespace ConsoleAppCSharp 
{ 
    public class Program 
    { 
     public static void Main(string[] args) 
     { 
      FSharpLibrary.Sample.FSharpFunction(42); //<- This is red. and marked as error.  
      Console.ReadKey(); 
     } 
    } 
} 

C# applicazione console project.json

{ 
    "version": "1.0.0-*", 
    "buildOptions": { 
    "emitEntryPoint": true 
    }, 

    "dependencies": { 
    "LibraryFSharp": "1.0.0-*", 
    "Microsoft.NETCore.App": { 
     "type": "platform", 
     "version": "1.0.0-rc2-3002702" 
    } 
    }, 

    "frameworks": { 
    "netcoreapp1.0": { 
     "imports": "dnxcore50" 
    } 
    } 
} 

Grazie

Answer 1

Quindi attualmente quello che ho descritto sopra è tutto il supporto che avete in Visual Studio 2015, con l'anteprima utensili. Si spera che Visual Studio 15 sia migliore, ma l'anteprima corrente (Anteprima 5) does not have .NET Core support at all.

Ciò che vale la pena provare è Visual Studio Code. In F # ottieni intellisense per tipo che sono definiti in C#. Quindi per l'interoperabilità F # -C# attualmente VS Code ha un supporto molto migliore rispetto all'intero VS.