F#-Lernprogramm: Erstellen einer F#-App mit vollem Stapel

Veröffentlicht: 2022-03-11

In den letzten Jahren hat sich die funktionale Programmierung den Ruf eines besonders rigorosen und produktiven Paradigmas erworben. Funktionale Programmiersprachen gewinnen nicht nur innerhalb der Programmierergemeinschaften an Aufmerksamkeit, sondern viele große Unternehmen beginnen auch damit, funktionale Programmiersprachen zu verwenden, um kommerzielle Probleme zu lösen.

Beispielsweise hat Walmart begonnen, Clojure, einen JVM-basierten funktionalen Lisp-Dialekt, für seine Checkout-Infrastruktur zu verwenden; Jet.com, eine große E-Commerce-Plattform (jetzt im Besitz von Walmart), verwendet F#, um die meisten seiner Microservices zu erstellen; und Jane Street, ein proprietäres Handelsunternehmen, verwenden hauptsächlich OCaml, um ihre Algorithmen zu erstellen.

Heute werden wir uns mit der F#-Programmierung befassen. F# ist eine der funktionalen Programmiersprachen, die aufgrund ihrer Flexibilität, starken .NET-Integration und der hohen Qualität der verfügbaren Tools zunehmend angenommen wird. Für die Zwecke dieses F#-Lernprogramms erstellen wir einen einfachen Webserver und eine zugehörige mobile App, die nur F# sowohl für das Front-End als auch für das Back-End verwendet.

Warum sollten Sie sich für F# entscheiden und wofür wird F# verwendet?

Für das heutige Projekt verwenden wir ausschließlich F#. Es gibt mehrere Gründe, F# als Sprache unserer Wahl zu bevorzugen:

  • .NET-Integration: F# hat eine sehr enge Integration mit dem Rest der .NET-Welt und bietet daher direkten Zugriff auf ein großes Ökosystem gut unterstützter und gründlich dokumentierter Bibliotheken zur Lösung einer Vielzahl von Programmieraufgaben.
  • Prägnanz: F# ist aufgrund seines leistungsstarken Typrückschlusssystems und seiner knappen Syntax äußerst prägnant. Programmieraufgaben lassen sich mit F# oft viel eleganter lösen als mit C# oder Java. F#-Code kann im Vergleich dazu sehr rationalisiert erscheinen.
  • Entwicklertools: F# genießt eine starke Integration in Visual Studio, das eine der besten IDEs für das .NET-Ökosystem ist. Für diejenigen, die auf Nicht-Windows-Plattformen arbeiten, gibt es eine Fülle von Plugins im Visual Studio-Code. Diese Tools machen die Programmierung in F# äußerst produktiv.

Ich könnte weiter über die Vorteile der Verwendung von F# sprechen, aber lassen Sie uns ohne weiteres eintauchen!

Die Idee hinter unserem F#-Tutorial

In den Vereinigten Staaten gibt es ein bekanntes Sprichwort: „Irgendwo ist es fünf Uhr“ .

In einigen Teilen der Welt ist 17:00 Uhr der früheste Zeitpunkt, an dem es gesellschaftlich akzeptiert ist, ein Getränk oder eine traditionelle Tasse Tee zu sich zu nehmen.

Heute werden wir eine Anwendung erstellen, die auf diesem Konzept basiert. Wir werden eine Anwendung bauen, die zu jeder Zeit die verschiedenen Zeitzonen durchsucht, herausfindet, wo es fünf Uhr ist, und diese Informationen dem Benutzer zur Verfügung stellt.

Das Backend

Einrichten des Webservers

Wir beginnen mit der Erstellung des Back-End-Dienstes, der die Zeitzonen-Suchfunktion ausführt. Wir werden Suave.IO verwenden, um eine JSON-API zu erstellen.

Illustration des F#-Lernprogramms: Einrichtung des Webservers

Suave.IO ist ein intuitives Web-Framework mit einem leichtgewichtigen Webserver, mit dem sich einfache Web-Apps sehr schnell programmieren lassen.

Wechseln Sie zunächst zu Visual Studio, und starten Sie ein neues F#-Konsolenanwendungsprojekt. Wenn Ihnen diese Option nicht zur Verfügung steht, müssen Sie möglicherweise die F#-Funktionalität mit Visual Studio Installer installieren. Nennen Sie das Projekt „FivePM“. Sobald Ihre Anwendung erstellt ist, sollten Sie in etwa Folgendes sehen:

 [<EntryPoint>] let main argv = printfn "%A" argv 0 // return an integer exit code

Dies ist ein sehr einfacher Startcode, der das Argument ausgibt und mit dem Statuscode 0 beendet wird. Sie können die Druckanweisung gerne ändern und mit verschiedenen Funktionen des Codes experimentieren. Der „%A“-Formatierer ist ein spezieller Formatierer, der die Zeichenfolgendarstellung des übergebenen Typs druckt, also fühlen Sie sich frei, ganze Zahlen, Floats oder sogar komplexe Typen zu drucken. Sobald Sie sich mit der grundlegenden Syntax vertraut gemacht haben, ist es an der Zeit, Suave zu installieren.

Der einfachste Weg, Suave zu installieren, ist über den NuGet-Paketmanager. Gehen Sie zu Projekt -> NuGet-Pakete verwalten und klicken Sie auf die Registerkarte Durchsuchen. Suchen Sie nach Suave und klicken Sie auf Installieren. Sobald Sie die zu installierenden Pakete akzeptiert haben, sollten Sie fertig sein! Gehen Sie jetzt zurück zu Ihrem program.fs-Bildschirm und wir können mit dem Erstellen des Servers beginnen.

Um mit der Verwendung von Suave zu beginnen, müssen wir zuerst das Paket importieren. Geben Sie oben in Ihrem Programm die folgenden Anweisungen ein:

 open Suave open Suave.Operators open Suave.Filters open Suave.Successful

Dadurch werden die grundlegenden Pakete importiert, die zum Erstellen eines einfachen Webservers erforderlich sind. Ersetzen Sie nun den Hauptcode durch den folgenden, der eine einfache App definiert und auf Port 8080 bereitstellt:

 [<EntryPoint>] let main argv = // Define the port where you want to serve. We'll hardcode this for now. let port = 8080 // create an app config with the port let cfg = { defaultConfig with bindings = [ HttpBinding.createSimple HTTP "0.0.0.0" port]} // We'll define a single GET route at the / endpoint that returns "Hello World" let app = choose [ GET >=> choose [ path "/" >=> request (fun _ -> OK "Hello World!")] ] // Now we start the server startWebServer cfg app 0

Der Code sollte sehr einfach aussehen, selbst wenn Sie nicht mit der F#-Syntax oder Suaves Art der Definition von Routenhandlern vertraut sind, sollte der Code einigermaßen lesbar sein. Im Wesentlichen kehrt die Web-App mit einem 200-Status und „Hello World!“ Zurück. Zeichenfolge, wenn sie mit einer GET-Anforderung auf der „/“-Route getroffen wird. Fahren Sie fort und führen Sie die Anwendung aus (F5 in Visual Studio) und navigieren Sie zu localhost:8080, und Sie sollten „Hello World!“ sehen. in Ihrem Browserfenster.

Refaktorisieren des Servercodes

Jetzt haben wir einen Webserver! Leider macht es nicht viel - also geben wir ihm etwas Funktionalität! Lassen Sie uns zunächst die Webserver-Funktionalität an einen anderen Ort verschieben, damit wir einige Funktionen erstellen können, ohne uns um den Webserver kümmern zu müssen (wir werden ihn später mit dem Webserver verbinden). Definieren Sie eine separate Funktion folgendermaßen:

 // We'll use argv later :) let runWebServer argv = // Define the port where you want to serve. We'll hardcode this for now. let port = 8080 // create an app config with the port let cfg = { defaultConfig with bindings = [ HttpBinding.createSimple HTTP "0.0.0.0" port]} // We'll define a single GET route at the / endpoint that returns "Hello World" let app = choose [ GET >=> choose [ path "/" >=> request (fun _ -> OK "Hello World!")] ] // Now we start the server startWebServer cfg app

Ändern Sie nun die Hauptfunktion wie folgt und stellen Sie sicher, dass wir es richtig gemacht haben.

 [<EntryPoint>] let main argv = runWebServer argv 0

Drücken Sie F5 und unser „Hello World!“ Server sollte wie zuvor funktionieren.

Zeitzonen abrufen

Lassen Sie uns nun die Funktionalität entwickeln, die die Zeitzone bestimmt, in der es fünf Uhr ist. Wir wollen Code schreiben, um alle Zeitzonen zu durchlaufen und die Zeitzone zu bestimmen, die 17:00 Uhr am nächsten liegt.

Abbildung der Zeitzonen wird abgerufen

Darüber hinaus möchten wir nicht wirklich eine Zeitzone zurückgeben, die sehr nahe an 17:00 Uhr liegt, aber kurz davor liegt (z. B. 16:58 Uhr), da für diese Demonstration die Prämisse lautet, dass sie nicht vor 5 Uhr liegen kann :00 Uhr, aber nah.

Beginnen wir damit, eine Liste der Zeitzonen zu erhalten. In F# ist dies sehr einfach, da es sich so gut in C# integrieren lässt. Fügen Sie oben „open System“ hinzu und ändern Sie Ihre F#-Anwendung wie folgt:

 [<EntryPoint>] let main argv = // This gets all the time zones into a List-like object let tzs = TimeZoneInfo.GetSystemTimeZones() // Now we iterate through the list and print out the names of the timezones for tz in tzs do printfn "%s" tz.DisplayName 0

Führen Sie die Anwendung aus und Sie sollten in Ihrer Konsole eine Liste aller Zeitzonen, ihrer Offsets und ihres Anzeigenamens sehen.

Erstellen und Verwenden eines benutzerdefinierten Typs

Jetzt, da wir die Liste der Zeitzonen haben, können wir sie in einen benutzerdefinierten Datentyp konvertieren, der für uns nützlicher ist, etwas, das Informationen wie den UTC-Offset, die Ortszeit und die Entfernung von 17:00 Uhr in Ortszeit enthält usw. Zu diesem Zweck definieren wir einen benutzerdefinierten Typ direkt über Ihrer Hauptfunktion:

 type TZInfo = {tzName: string; minDiff: float; localTime: string; utcOffset: float}

Jetzt können wir die Zeitzoneninformationen, die wir aus dem letzten Schritt erhalten haben, in eine Liste dieser TZInfo-Objekte umwandeln. Ändern Sie Ihre Hauptfunktion folgendermaßen:

 [<EntryPoint>] let main argv = // This gets all the time zones into a List-like object let tzs = TimeZoneInfo.GetSystemTimeZones() // List comprehension + type inference allows us to easily perform conversions let tzList = [ for tz in tzs do // convert the current time to the local time zone let localTz = TimeZoneInfo.ConvertTime(DateTime.Now, tz) // Get the datetime object if it was 5:00pm let fivePM = DateTime(localTz.Year, localTz.Month, localTz.Day, 17, 0, 0) // Get the difference between now local time and 5:00pm local time. let minDifference = (localTz - fivePM).TotalMinutes yield { tzName=tz.StandardName; minDiff=minDifference; localTime=localTz.ToString("hh:mm tt"); utcOffset=tz.BaseUtcOffset.TotalHours; } ] printfn "%A" tzList.Head 0

Und Sie sollten das tzInfo-Objekt für Dateline Standard Time auf Ihrem Bildschirm sehen.

Sortieren und Filtern und Piping, oh mein Gott!

Da wir nun eine Liste dieser tzInfo-Objekte haben, können wir diese Objekte filtern und sortieren, um die Zeitzone zu finden, in der es 1) nach 17:00 Uhr und 2) am nächsten zu 17:00 Uhr der Zeitzonen in 1) liegt. Ändern Sie Ihre Hauptfunktion wie folgt:

 [<EntryPoint>] let main argv = // This gets all the time zones into a List-like object let tzs = TimeZoneInfo.GetSystemTimeZones() // List comprehension + type inference allows us to easily perform conversions let tzList = [ for tz in tzs do // convert the current time to the local time zone let localTz = TimeZoneInfo.ConvertTime(DateTime.Now, tz) // Get the datetime object if it was 5:00pm let fivePM = DateTime(localTz.Year, localTz.Month, localTz.Day, 17, 0, 0) // Get the difference between now local time and 5:00pm local time. let minDifference = (localTz - fivePM).TotalMinutes yield { tzName=tz.StandardName; minDiff=minDifference; localTime=localTz.ToString("hh:mm tt"); utcOffset=tz.BaseUtcOffset.TotalHours; } ] // We use the pipe operator to chain functiona calls together let closest = tzList // filter so that we only get tz after 5pm |> List.filter (fun (i:TZInfo) -> i.minDiff >= 0.0) // sort by minDiff |> List.sortBy (fun (i:TZInfo) -> i.minDiff) // Get the first item |> List.head printfn "%A" closest

Und jetzt sollten wir die gesuchte Zeitzone haben.

Refactoring des Timezone Getter auf seine eigene Funktion

Lassen Sie uns nun den Code in eine eigene Funktion umgestalten, damit wir ihn später verwenden können. Definiere eine Funktion so:

 // the function takes uint as input, and we represent that as "()" let getClosest () = // This gets all the time zones into a List-like object let tzs = TimeZoneInfo.GetSystemTimeZones() // List comprehension + type inference allows us to easily perform conversions let tzList = [ for tz in tzs do // convert the current time to the local time zone let localTz = TimeZoneInfo.ConvertTime(DateTime.Now, tz) // Get the datetime object if it was 5:00pm let fivePM = DateTime(localTz.Year, localTz.Month, localTz.Day, 17, 0, 0) // Get the difference between now local time and 5:00pm local time. let minDifference = (localTz - fivePM).TotalMinutes yield { tzName=tz.StandardName; minDiff=minDifference; localTime=localTz.ToString("hh:mm tt"); utcOffset=tz.BaseUtcOffset.TotalHours; } ] // We use the pipe operator to chain function calls together tzList // filter so that we only get tz after 5pm |> List.filter (fun (i:TZInfo) -> i.minDiff >= 0.0) // sort by minDiff |> List.sortBy (fun (i:TZInfo) -> i.minDiff) // Get the first item |> List.head And our main function can just be: [<EntryPoint>] let main argv = printfn "%A" <| getClosest() 0

Führen Sie den Code aus und Sie sollten die gleiche Ausgabe wie zuvor sehen.

JSON-Codierung der Rückgabedaten

Jetzt, da wir die Zeitzonendaten abrufen können, können wir die Informationen in JSON umwandeln und über unsere Anwendung bereitstellen. Dank des JSON.NET-Pakets von NewtonSoft ist das ganz einfach. Kehren Sie zu Ihrem NuGet-Paket-Manager zurück, suchen Sie Newtonsoft.Json und installieren Sie das Paket. Kehren Sie nun zu Program.fs zurück und nehmen Sie eine kleine Änderung an unserer Hauptfunktion vor:

 [<EntryPoint>] let main argv = printfn "%s" <| JsonConvert.SerializeObject(getClosest()) 0

Führen Sie den Code jetzt aus und anstelle des TZInfo-Objekts sollten Sie den JSON-Code sehen, der auf Ihrer Konsole ausgegeben wird.

Verbinden der Zeitzoneninformationen mit der JSON-API

Es ist sehr einfach, dies mit unserer JSON-API zu verbinden. Nehmen Sie einfach die folgenden Änderungen an Ihrer runWebServer-Funktion vor:

 // We'll use argv later :) let runWebServer argv = // Define the port where you want to serve. We'll hardcode this for now. let port = 8080 // create an app config with the port let cfg = { defaultConfig with bindings = [ HttpBinding.createSimple HTTP "0.0.0.0" port]} // We'll define a single GET route at the / endpoint that returns "Hello World" let app = choose [ GET >=> choose [ // We are getting the closest time zone, converting it to JSON, then setting the MimeType path "/" >=> request (fun _ -> OK <| JsonConvert.SerializeObject(getClosest())) >=> setMimeType "application/json; charset=utf-8" ] ] // Now we start the server startWebServer cfg app

Führen Sie die Anwendung aus und navigieren Sie zu localhost:8080. Sie sollten den JSON in Ihrem Browserfenster sehen.

Bereitstellen des Servers

Jetzt, da wir den JSON-API-Server haben, können wir ihn bereitstellen, damit er im Internet zugänglich ist. Eine der einfachsten Möglichkeiten, diese Anwendung bereitzustellen, ist der App Service von Microsoft Azure, der als verwalteter IIS-Dienst verstanden werden kann. Wechseln Sie zum Bereitstellen in Azure App Service zu https://portal.azure.com und gehen Sie zu App Service. Erstellen Sie eine neue App und navigieren Sie in Ihrem Portal zum Bereitstellungscenter. Das Portal kann beim ersten Mal etwas überfordernd sein. Wenn Sie also Probleme haben, konsultieren Sie unbedingt eines der vielen verfügbaren Tutorials zur Verwendung von App Service.

Sie sollten eine Vielzahl von Bereitstellungsoptionen sehen. Sie können alles verwenden, was Sie möchten, aber der Einfachheit halber können wir die FTP-Option verwenden.

Der App-Dienst sucht nach einer web.config-Datei im Stammverzeichnis Ihrer Anwendung, um zu erfahren, wie Ihre Anwendung ausgeführt wird. Da unser Webserver eine wesentliche Konsolenanwendung ist, können wir die Anwendung veröffentlichen und mithilfe von HttpPlatformHandler in den IIS-Server integrieren. Fügen Sie in Visual Studio eine XML-Datei zu Ihrem Projekt hinzu und nennen Sie sie web.config. Füllen Sie es mit dem folgenden XML:

 <?xml version="1.0" encoding="UTF-8"?> <configuration> <system.webServer> <handlers> <remove name="httpplatformhandler" /> <add name="httpplatformhandler" path="*" verb="*" modules="httpPlatformHandler" resourceType="Unspecified"/> </handlers> <httpPlatform stdoutLogEnabled="true" stdoutLogFile="suave.log" startupTimeLimit="20" processPath=".\publish\FivePM.exe" arguments="%HTTP_PLATFORM_PORT%"/> </system.webServer> </configuration>

Stellen Sie eine Verbindung zum FTP-Server her, indem Sie die Anmeldeinformationen verwenden, die Sie vom Bereitstellungszentrum erhalten haben (Sie müssen auf die FTP-Option klicken). Verschieben Sie die Datei „web.config“ in den Ordner „wwwroot“ Ihrer App-Service-FTP-Site.

Jetzt wollen wir unsere Anwendung erstellen und veröffentlichen, aber vorher müssen wir eine kleine Änderung am Servercode vornehmen. Gehen Sie zu Ihrer runServer-Funktion und ändern Sie die ersten 3 Zeilen wie folgt:

 let runWebServer (argv:string[]) = // Define the port where you want to serve. We'll hardcode this for now. let port = if argv.Length = 0 then 8080 else (int argv.[0])

Dadurch kann die Anwendung das übergebene Argument betrachten und das erste Argument als Portnummer verwenden, anstatt den Port fest auf 8080 zu codieren. In der Webkonfiguration übergeben wir %HTTP_PLATFORM_PORT% als erstes Argument, also wir sollte eingestellt werden.

Erstellen Sie die Anwendung im Release-Modus, veröffentlichen Sie die Anwendung und kopieren Sie den veröffentlichten Ordner in die wwwroot. Starten Sie die Anwendung neu und Sie sollten das JSON-API-Ergebnis auf der Website *.azurewebsites.net .

Jetzt wird unsere Anwendung bereitgestellt!

Das Frontend

Abbildung des F#-Frontends

Nachdem wir den Server bereitgestellt haben, können wir ein Frontend erstellen. Für das Frontend erstellen wir eine Android-Anwendung mit Xamarin und F#. Dieser Stack genießt wie unsere Back-End-Umgebung eine tiefe Integration mit Visual Studio. Natürlich unterstützt das F#-Ökosystem eine ganze Reihe von Front-End-Entwicklungsoptionen (WebSharper, Fable/Elmish, Xamarin.iOS, DotLiquid usw.), aber der Kürze halber werden wir für diesen Beitrag nur mit Xamarin.Android entwickeln und gehen sie für zukünftige Posts.

Einrichten

Um die Android-App einzurichten, starten Sie ein neues Projekt und wählen Sie die Option Xamarin Android aus. Stellen Sie sicher, dass Sie Android-Entwicklungstools installiert haben. Sobald das Projekt eingerichtet ist, sollten Sie so etwas in Ihrer Hauptcodedatei sehen.

 [<Activity (Label = "FivePMFinder", MainLauncher = true, Icon = "@mipmap/icon")>] type MainActivity () = inherit Activity () let mutable count:int = 1 override this.OnCreate (bundle) = base.OnCreate (bundle) // Set our view from the "main" layout resource this.SetContentView (Resources.Layout.Main) // Get our button from the layout resource, and attach an event to it let button = this.FindViewById<Button>(Resources.Id.myButton) button.Click.Add (fun args -> button.Text <- sprintf "%d clicks!" count count <- count + 1 )

Dies ist der Startcode für F# Android Xamarin. Der Code verfolgt derzeit nur, wie oft auf eine Schaltfläche geklickt wurde, und zeigt den aktuellen Zählwert an. Sie können sehen, wie es funktioniert, indem Sie F5 drücken, um den Emulator zu starten, und die Anwendung im Debug-Modus starten.

Hinzufügen von UI-Komponenten

Lassen Sie uns einige UI-Komponenten hinzufügen und sie nützlicher machen. Öffnen Sie resource/layouts und navigieren Sie zu Main.axml.

Sie sollten eine visuelle Darstellung des Layouts der Hauptaktivität sehen. Sie können die verschiedenen UI-Elemente bearbeiten, indem Sie auf die Elemente klicken. Sie können Elemente hinzufügen, indem Sie zur Toolbox gehen und das Element auswählen, das Sie hinzufügen möchten. Benennen Sie die Schaltfläche um und fügen Sie unterhalb der Schaltfläche eine TextView hinzu. Die XML-Darstellung Ihrer AXML sollte ungefähr so ​​aussehen:

 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:andro android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <Button android: android:layout_width="match_parent" android:layout_height="wrap_content" android:text="@string/fivePM" /> <TextView android:text="" android:textAppearance="?android:attr/textAppearanceMedium" android:layout_width="match_parent" android:layout_height="wrap_content" android: /> </LinearLayout>

Die AXML verweist auf die Strings-Ressourcendatei, öffnen Sie also Ihre resources/values/strings.xml und nehmen Sie die folgenden Änderungen vor:

 <?xml version="1.0" encoding="utf-8"?> <resources> <string name="fivePM">It\'s 5PM Somewhere!</string> <string name="app_name">5PM Finder</string> </resources>

Jetzt haben wir das Frontend AXML gebaut. Verbinden wir es jetzt mit einem Code. Navigieren Sie zu MainActivity.fs und nehmen Sie die folgenden Änderungen an Ihrer onCreate-Funktion vor:

 base.OnCreate (bundle) // Set our view from the "main" layout resource this.SetContentView (Resources.Layout.Main) // Get our button from the layout resource, and attach an event to it let button = this.FindViewById<Button>(Resources.Id.myButton) let txtView = this.FindViewById<TextView>(Resources.Id.textView1); button.Click.Add (fun args -> let webClient = new WebClient() txtView.Text <- webClient.DownloadString("https://fivepm.azurewebsites.net/") )

Ersetzen Sie fivepm.azurewebsites.net durch die URL Ihrer eigenen JSON-API-Bereitstellung. Führen Sie die Anwendung aus und klicken Sie auf die Schaltfläche im Emulator. In Kürze sollten Sie die JSON-API-Rückgabe mit Ihrem API-Ergebnis sehen.

Analysieren von JSON

Wir sind fast da! Im Moment zeigt unsere App das rohe JSON an und es ist ziemlich unlesbar. Der nächste Schritt ist dann das Parsen des JSON und das Ausgeben einer besser lesbaren Zeichenfolge. Um JSON zu analysieren, können wir die Newtonsoft.JSON-Bibliothek vom Server verwenden.

Navigieren Sie zu Ihrem NuGet-Paket-Manager und suchen Sie nach Newtonsoft.JSON. Installieren Sie und gehen Sie zurück zur Datei MainActivity.fs. Importieren Sie es, indem Sie „open Newtonsoft.Json“ hinzufügen.

Fügen Sie nun dem Projekt den Typ TZInfo hinzu. Wir könnten die TZInfo vom Server wiederverwenden, aber da wir eigentlich nur zwei der Felder brauchen, können wir hier einen benutzerdefinierten Typ definieren:

 type TZInfo = { tzName:string localTime: string }

Fügen Sie die Typdefinition über der Hauptfunktion hinzu und ändern Sie nun die Hauptfunktion folgendermaßen:

 button.Click.Add (fun args -> let webClient = new WebClient() let tzi = JsonConvert.DeserializeObject<TZInfo>(webClient.DownloadString("https://fivepm.azurewebsites.net/")) txtView.Text <- sprintf "It's (about) 5PM in the\n\n%s Timezone! \n\nSpecifically, it is %s there" tzi.tzName tzi.localTime )

Jetzt wird das JSON-API-Ergebnis in das TZInfo-Objekt deserialisiert und zum Erstellen einer Zeichenfolge verwendet. Führen Sie die App aus und klicken Sie auf die Schaltfläche. Sie sollten die formatierte Zeichenfolge auf dem Bildschirm sehen.

Obwohl diese Anwendung sehr einfach und vielleicht nicht verfeinert ist, haben wir eine mobile Anwendung erstellt, die eine F# JSON-API nutzt, die Daten transformiert und sie dem Benutzer anzeigt. Und wir haben das alles in F# gemacht. Fühlen Sie sich frei, mit den verschiedenen Steuerelementen herumzuspielen und zu sehen, ob Sie das Design verbessern können.

Und da haben wir es! Eine einfache mobile F#-Anwendung und eine F#-JSON-API, die dem Benutzer mitteilt, wo es fünf Uhr ist.

Einpacken

Heute haben wir die Erstellung einer einfachen Web-API und einer einfachen Android-Anwendung nur mit F# durchgegangen, um sowohl die Ausdruckskraft der Sprache F# als auch die Stärke des F#-Ökosystems zu demonstrieren. Wir haben jedoch kaum an der Oberfläche der F#-Entwicklung gekratzt, daher werde ich ein paar weitere Posts schreiben, um auf dem aufzubauen, was wir heute besprochen haben. Außerdem hoffe ich, dass dieser Beitrag Sie dazu inspiriert hat, eigene F#-Anwendungen zu erstellen!

Den Code, den wir für dieses Tutorial verwendet haben, finden Sie auf GitHub.