Wskazówki: używanie Visual F# do tworzenia, debugowania i wdrażania aplikacji

Artykuł
06/10/2015

Instruktaż ten wprowadza do używania F# w Visual Studio razem z .NET Framework 4.5.

W tym instruktażu przedstawiono jak rozpocząć korzystanie z Visual Studio, aby pisać aplikacje F#, poprzez przykład analizy historycznych danych stopy skarbu USA.Na początku przedstawiona zostanie szybka analiza danych za pomocą okna F# Interactive, następnie zaprezentowany zostanie sposób pisania i testowania kodu do analizy danych, a następnie uzupełniony on zostanie o stronę użytkownika napisaną w C#, aby poznać integrację kodu F# z innymi językami .NET.

Wymagania wstępne

Następujące składniki są wymagane do przeprowadzenia tego instruktażu:

Visual Studio

[!UWAGA]

Na komputerze w poniższych instrukcjach mogą być wyświetlane inne nazwy i lokalizacje niektórych elementów interfejsu użytkownika programu Visual Studio. Te elementy są określane przez numer wersji Visual Studio oraz twoje ustawienia. Aby uzyskać więcej informacji, zobacz Dostosowywanie ustawień środowiska deweloperskiego w Visual Studio.

Aby utworzyć skrypt F#

Najpierw należy utworzyć skrypt F#.W menu Plik menu, wskaż Nowy, a następnie kliknij przycisk Plik.W oknie dialogowym Nowy plik wybierz Skrypt w kategorii Ogólne pod listą szablonów Zainstalowane, a następnie wybierz Plik skryptu F#.Kliknij Otwórz, aby stworzyć plik, a następnie zapisz plik jako RateAnalysis.fsx.
Użyj API .Net i F#, aby uzyskać dostęp do danych z witryny internetowej Rezerwy Federalnej Stanów Zjednoczonych.Wpisz następujący kod.
```
open System.Net
open System.IO

let url = sprintf "http://www.federalreserve.gov/datadownload/Output.aspx?rel=H15&series=bcb44e57fb57efbe90002369321bfb3f&lastObs=&from=&to=&filetype=csv&label=include&layout=seriescolumn" 
let req = WebRequest.Create(url, Timeout = 10000000)
let resp = req.GetResponse()
let stream = resp.GetResponseStream()
let reader = new StreamReader(stream)
let csv = reader.ReadToEnd()
```
Zauważ co następujące:
- Ciągi znaków i słowa kluczowe są pokolorowane.
- Listy uzupełniania pojawiają się po wpisaniu każdej kropki (.).
- Za pomocą użycia skrótu klawiaturowego CTRL+SPACJA lub CTRL+J w środku identyfikatora, Visual Studio może uzupełnić nazwy metod i innych identyfikatorów.Gdy używasz klawiszy CTRL+J pojawi się lista uzupełniania.
- Ustawienie wskaźnika myszy nad dowolnym identyfikatorem w kodzie spowoduje pokazania etykiety, która zawiera informacje dotyczące tego identyfikatora.
- Jeśli wciśnięty zostanie klawisz F1, gdy kursor znajduje się w WebRequest, pojawi się oczekiwana dokumentacja.
- Jeśli wciśnięty zostanie klawisz F1, gdy kursor znajduje się w let, pojawi się oczekiwana dokumentacja.
- Odwołania do typów i przestrzeni nazw z mscorlib.dll, System.dll i System.Windows.Forms.dll są domyślne.
- Wartość Timeout, która jest tutaj ustawiana to właściwość, a nie argument konstruktora.F# umożliwia ustawienie wartości właściwości w ten sposób.
- Po skopiowaniu adresu URL w przykładzie do przeglądarki, uzyska się listę wartości rozdzielonych przecinkami, które zawierają daty i stopy procentowe, opublikowane przez Rezerwę Federalną Stanów Zjednoczonych.
Wykonany teraz zostanie kod za pomocą F# Interactive.Zaznacz cały kod (za pomocą myszy lub naciskając klawisze CTRL+A) i kliknij prawym przyciskiem myszy, a następnie Wykonaj w trybie interaktywnym.(Alternatywnie, naciśnij klawisze ALT+ENTER).
- Jeśli jeszcze nie było widoczne, pokaże się okno F# Interactive.
- Kod zostanie pomyślnie wykonany.
- Następujące pojawia się w oknie trybu F# Interactive.
```
val url : string =
  "http://www.federalreserve.gov/datadownload/Output.aspx?rel=H1"+[107 chars]
val req : System.Net.WebRequest
val resp : System.Net.WebResponse
val stream : System.IO.Stream
val reader : System.IO.StreamReader

val csv : string =
  ""Series Description","Market yield on U.S. Treasury securities"+[224219 chars]

>
```
Dalej sprawdź dane za pomocą F# Interactive.W wierszy poleceń F# Interactive wpisz csv;; i naciśnij klawisz ENTER.Wpisz csv.Length;; i naciśnij klawisz ENTER.Zauważ co następujące:
- Dane są aktualne.
- F# Interactive wyświetla wartość ciągu csv i jego długość, jak pokazano tutaj.
```
07/10/2009, 3.32
07/13/2009, 3.38
07/14/2009, 3.50
07/15/2009, 3.63
"
> csv.Length;;
val it : int = 224513
```
- Na następującej ilustracji pokazano okno trybu F# Interactive.
  
  Okno F# Interactive
Przedstawiony zostanie sposób, jak napisać kod F# do analizy danych w formacie CSV (wartości rozdzielone przecinkiem).Plik CSV jest tak nazwany, ponieważ zawiera wartości rozdzielone przecinkami.W edytorze kodu należy dodać następujący kod.A także należy dodać open System.Globalization na początku pliku.Podczas dodawania każdego wiersza, należy zaznaczyć dodany kod w tej sekcji aż do tej linii i wcisnąć klawisze ALT+ENTER, aby wyświetlić wyniki częściowe.Zauważ co następujące:
- Technologia IntelliSense daje pomocne informacje po wpisaniu kropki, nawet w środku złożonego wyrażenia zagnieżdżonego.
- Gdy kod jest niekompletny (lub niepoprawny), czerwone faliste podkreślenia wskazuje, że w kodzie występują błędy składni lub semantyczne.
- Można tworzyć potoki przy użyciu operatora potoku (|>).Operator potoku przyjmuje wartość zwracaną przez jedno wyrażenie i używa jej jako argumentu dla funkcji w następnym wierszu.Potoki i F# Interactive umożliwiają łatwe częściowe wykonanie kodu przetwarzającego dane.
```
let interest = 
    csv.Split([|'\n'|])
    |> Seq.skip 8
    |> Seq.map (fun line -> line.Trim())
    |> Seq.filter (fun line -> not (line.EndsWith("ND")))
    |> Seq.filter (fun line -> not (line.Length = 0))
    |> Seq.map (fun line -> line.Split([|','|]))
    |> Seq.map ( fun values ->
        System.DateTime.Parse(values.[0], CultureInfo.CreateSpecificCulture("en-US")),
        float values.[1])
```

Teraz należy nadać tej funkcjonalności nazwę.Usuń identyfikator serii bcb44e57fb57efbe90002369321bfb3f z definicji urli zastąp go z %s, aby zrobić ciąg literału ciągiem formatu.Dodaj seriesID po ciągu formatu.Zaznacz cały kod, z wyjątkiem otwartych dyrektyw i naciśnij klawisz TAB.Powyżej wciętego bloku kodu należy dodać następujące wiersze kodu.

let loadRates maturity =
    // The following tuples associate various maturity durations, in years, 
    // with codes defined for treasury bills by the Federal Reserve. 
    let maturitiesMap = Map.ofList [(1, "e30653a4b627e9d1f2490a0277d9f1ac")
                                    (2, "c66ea77a2e8f0919c5133c7633065908")
                                    (5, "fbb02942bfdbff31a479e98bcbe26388")
                                    (10, "bcb44e57fb57efbe90002369321bfb3f")
                                    (20, "a1ebeb6e84ca6389772dd054dc980191")]
    let seriesID = Map.find maturity maturitiesMap

Na końcu wciętego bloku, należy dodać interest.Zauważ co następujące:

Wcięcie jest znaczące w F#.Poziom wcięcia wskazuje poziom zagnieżdżenia.
TAB jest prawie jak Refaktoryzacja wyodrębniania metody (C#).

Teraz kod jest podobny do następującego.

open System.Net
open System.IO

let loadRates maturity =
    // The following tuples associate various maturity durations, in years, 
    // with codes defined for treasury bills by the Federal Reserve. 
    let maturitiesMap = Map.ofList [(1, "e30653a4b627e9d1f2490a0277d9f1ac")
                                    (2, "c66ea77a2e8f0919c5133c7633065908")
                                    (5, "fbb02942bfdbff31a479e98bcbe26388")
                                    (10, "bcb44e57fb57efbe90002369321bfb3f")
                                    (20, "a1ebeb6e84ca6389772dd054dc980191")]
    let seriesID = Map.find maturity maturitiesMap
    let url = sprintf "http://www.federalreserve.gov/datadownload/Output.aspx?rel=H15&series=%s&lastObs=&from=&to=&filetype=csv&label=include&layout=seriescolumn" seriesID
    let req = WebRequest.Create(url, Timeout = 10000000)
    let resp = req.GetResponse()
    let stream = resp.GetResponseStream()
    let reader = new StreamReader(stream)
    let csv = reader.ReadToEnd()


    let interest = 
        csv.Split([|'\n'|])
        |> Seq.skip 8
        |> Seq.map (fun line -> line.Trim())
        |> Seq.filter (fun line -> not (line.EndsWith("ND")))
        |> Seq.filter (fun line -> not (line.Length = 0))
        |> Seq.map (fun line -> line.Split([|','|]))
        |> Seq.map ( fun values ->
            System.DateTime.Parse(values.[0], CultureInfo.CreateSpecificCulture("en-US")),
            float values.[1])
    interest

Użyjesz teraz tej funkcji na nowych danych wejściowych.Zaznacz cały kod i naciśnij klawisze ALT+ENTER, aby wykonać go za pomocą F# Interactive.W wierszu F# Interactive, wywołaj nową funkcję loadRates na innych współczynnikach dojrzałości: 1, 2, i 5, w latach.Zauważ co następujące:
- Poprzednie definicje nie zostaną utracone F# Interactive, ale nowe definicje są dostępne.
- Złożone dane strukturalne są przedstawiane przez specjalną funkcję drukowania.

Opracowanie składnika za pomocą F#

Stwórz projekt biblioteki, aby wystawić funkcjonalność, którą stworzyłeś.W menu Plik, wskaż Nowy i kliknij przycisk Projekt.W oknie dialogowym Nowy projekt wybierz Visual F# w liście Zainstalowane, a następnie Biblioteka F#, aby stworzyć nowy projekt biblioteki.Nadaj nazwę projektu RateAnalysis.Skopiuj kod, który został wcześniej utworzony z RateAnalysis.fsx i wklej go do Library1.fs.Dodaj deklarację modułu na początku pliku: module RateLoader.W Eksploratorze rozwiązania zmień nazwę Library1.fs na RateLoader.fs i zapisz plik.Zauważ co następujące:
- Domyślny szablon biblioteki F# zawiera plik kodu, który ma rozszerzenie .fs i skrypt, który ma rozszerzenie .fsx.Aby interakcyjnie przetestować kod biblioteki, można użyć pliku skryptu.

Stworzysz teraz klasę F#, która wystawia pożądaną funkcjonalność.W Eksploratorze rozwiązania, kliknij prawym przyciskiem myszy projekt, wskaż Dodaj, a następnie kliknij przycisk Nowy element.W oknie dialogowym Dodaj nowy element wybierz Plik źródłowy F#.Nazwij plik Analyzer.fs.Kliknij prawym przyciskiem myszy Script.fsx w Eksploratorze rozwiązania i kliknij przycisk Przenieś w dół.(Alternatywnie, naciśnij klawisze ALT+Strzałka w dół). Wklej następujący kod do Analyzer.fs:

module RateAnalysis.Analyzer

open RateLoader

/// Provides analysis of historical interest rate data. 
type Analyzer(ratesAndDates) = 
    let rates = 
        ratesAndDates
        |> Seq.map snd

    /// Construct Analyzer objects for each maturity category. 
    static member GetAnalyzers(maturities) = 
        maturities
        |> Seq.map loadRates
        |> Seq.map (fun ratesAndDates -> new Analyzer(ratesAndDates))

    member sa.Min =
        let date, minRate = (Seq.minBy (fun (_, rate) -> rate) ratesAndDates)
        (minRate, date.ToString("d"))

    member sa.Max = 
        let date, maxRate = (Seq.maxBy (fun (_, rate) -> rate) ratesAndDates)
        (maxRate, date.ToString("d"))

    member sa.Current =
        rates |> List.ofSeq |> List.rev |> List.head

Zauważ co następujące:

F# obsługuje programowanie obiektowe.Aby uzyskać więcej informacji, zobacz Klasy (F#), Dziedziczenie (F#)i inne powiązane tematy w F# Language Reference.

Aby skompilować projekt, naciśnij klawisze CTRL+SHIFT+B lub F6.Zauważ co następujące:

Projekt kompiluje się pomyślnie.
W oknie Lista błędów nie wyświetlane są żadne błędy.
Katalog wyjściowy zawiera pliki .dll, .pdb, i .xml.

Okno wyjściowe wyświetla następujące informacje:

------ Build started: Project: RateAnalysis, Configuration: Debug Any CPU ------
    C:\Program Files (x86)\Microsoft F#\v4.0\fsc.exe -o:obj\Debug\RateAnalysis.exe -g --debug:full --noframework --define:DEBUG --define:TRACE --optimize- --tailcalls- -r:"C:\Program Files (x86)\Microsoft F#\v4.0\FSharp.Core.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\mscorlib.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Core.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.dll" --target:exe --warn:3 --warnaserror:76 --vserrors --utf8output --fullpaths --flaterrors Program.fs RateLoader.fs ValueAnalyzer.fs 
    RateAnalysis -> C:\Users\ghogen\Documents\Visual Studio 10\Projects\RateAnalysis\RateAnalysis\bin\Debug\RateAnalysis.exe
========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========

Aby dodać aplikację klienta C#, otwórz menu skrótów dla węzła rozwiązania, wybierz Dodaj, a następnie Nowy projekt.W oknie dialogowym Dodaj nowy projekt wybierz Visual C# w liście Zainstalowane szablony, a następnie wybierz Aplikacja konsoli.Być może będziesz musiał rozwinąć węzeł Inne języki.Nazwij projekt CSharpDriver, a następnie wybierz przycisk OK.Otwórz menu skrótów węzła Odwołania tego projektu, a następnie wybierz Dodaj odwołanie.Wybierz węzeł Rozwiązanie, a następnie węzeł Projekty.Zaznacz pole wyboru obok projektu RateAnalysis, a następnie wybierz przycisk OK.Otwórz menu skrótów dla węzła projektu CSharpDriver, a następnie kliknij Ustaw jako projekt startowy.Wpisz następujący kod w treści metody Main aplikacji C#.
```
var maturities = new[] { 1, 2, 5, 10 };
var analyzers = RateAnalysis.Analyzer.Analyzer.GetAnalyzers(maturities);

foreach (var item in analyzers)
{
    Console.WriteLine("Min = {0}, \t Max = {1}, \t Current = {2}", item.Min, item.Max, item.Current);
}
Console.WriteLine("Press Enter to exit.");
Console.ReadLine();
```
Zauważ co następujące:
- Można dodać odwołania projekt-do-projektu do i z C# i F#.
- Można użyć przestrzeni nazw i typów zdefiniowanych w F# z C# jak innych typów.
- Komentarze dokumentacji F# są dostępne w C# IntelliSense.
- C# może uzyskać dostęp do wartości wartości zwrotnych krotek z F# API.Krotki są wartościami Tuple w .NET Framework 4.5.
Aby debugować aplikację, naciśnij klawisz F11, aby skompilować aplikację, uruchom aplikację w debugerze i wejdź w pierwszy wiersz wykonywanego kodu.Naciśnij klawisz F11 jeszcze kilka razy, dopóki nie wejdziesz w treść kodu F# członka GetAnalyzers.Zauważ co następujące:
- Z kodu C# można łatwo wejść do kodu F#.
- Każde wyrażenie w F# jest krokiem w debugerze.
- W oknie zmiennych lokalnych pokazują się wartości maturities.
- Dalsze naciskanie klawisza F11 spowoduje przejście przez kolejne kroki ewaluacji aplikacji.
- Wszystkie polecenia debugera takie jak Uruchom do kursora, Ustaw następną instrukcję, Wstaw punkt przerwania, Dodaj czujkę i Przejdź do dezasemblacji działają zgodnie z oczekiwaniami.

Aby wdrożyć aplikację

Jeśli nadal debugujesz, zatrzymaj debugowanie wciskając klawisze SHIFT+F5 lub przez otwarcie menu Debuguj, a następnie wybierając Zatrzymaj debugowanie.
Otwórz menu skrótów dla projektu CSharpDriver, a następnie wybierz Właściwości.
W projektancie projektu wybierz kartę Publikuj, która pokazuje opcje dla wdrażania aplikacji.
Wybierz przycisk Kreatora publikowania.

Uruchomi się Kreatora publikowania, a pierwszy ekran zapyta gdzie chcesz opublikować pliki.
W polu tekstowym, należy określić lokalizację pliku na dysku lokalnym, gdzie chcesz opublikować pliki instalacyjne aplikacji lub wybrać przycisk Przeglądaj, aby przejść do tej lokalizacji.
Wybierz przycisk Zakończ, aby zaakceptować wszystkie ustawienia domyślne, aby utworzyć standardowy instalator, który może być rozprowadzany na komputerach klienckich lub wybierz przycisk Dalej, aby wyświetlić inne opcje publikowania.

Plik wykonywalny instalatora i pliki pomocnicze są publikowane w określonej lokalizacji.

Następne kroki

Rozpocznij pisanie kodu F# czytając Wskazówki: pierwszy program w języku F# lub dowiedz się więcej o funkcjach w F# czytając Funkcje jako wartości pierwszej klasy (F#).Możesz odkrywać język F# czytając Materiały referencyjne dotyczące języka F#.

Zobacz też

Inne zasoby

Przykłady i wskazówki dotyczące Visual F#

Udostępnij za pośrednictwem