ในช่วงไม่กี่ปีที่ผ่านมาการเขียนโปรแกรมเชิงฟังก์ชันได้รับชื่อเสียงในฐานะกระบวนทัศน์ที่เข้มงวดและมีประสิทธิผลเป็นพิเศษ ภาษาโปรแกรมที่ใช้งานได้ไม่เพียง แต่ได้รับความสนใจในชุมชนโปรแกรมเมอร์ แต่ บริษัท ขนาดใหญ่หลายแห่งก็เริ่มใช้ภาษาโปรแกรมที่ใช้งานได้เพื่อแก้ปัญหาทางการค้า

กวดวิชา angularjs พร้อมตัวอย่างสำหรับผู้เริ่มต้น

ตัวอย่างเช่น Walmart ได้เริ่มใช้ Clojure ซึ่งเป็นภาษา Lisp ที่ใช้งานได้ตาม JVM สำหรับโครงสร้างพื้นฐานการชำระเงิน Jet.com ซึ่งเป็นแพลตฟอร์มอีคอมเมิร์ซขนาดใหญ่ (ปัจจุบันเป็นของ Walmart) ใช้ F # เพื่อสร้างไมโครเซอร์วิสส่วนใหญ่ และ Jane Street ซึ่งเป็น บริษัท การค้าที่เป็นกรรมสิทธิ์ส่วนใหญ่ใช้ OCaml ในการสร้างอัลกอริทึมของตน

วันนี้เราจะมาสำรวจ การเขียนโปรแกรม F # . F # เป็นหนึ่งในภาษาโปรแกรมที่ใช้งานได้ซึ่งมีการใช้งานเพิ่มขึ้นเนื่องจากความยืดหยุ่นการรวม. NET ที่แข็งแกร่งและเครื่องมือที่มีคุณภาพสูง สำหรับวัตถุประสงค์ของบทช่วยสอน F # นี้เราจะสร้างเว็บเซิร์ฟเวอร์ที่เรียบง่ายและแอปบนอุปกรณ์เคลื่อนที่ที่เกี่ยวข้องโดยใช้ F # สำหรับทั้งส่วนหน้าและส่วนหลัง

ทำไมต้องเลือก F # และ F # ใช้สำหรับอะไร?

สำหรับโครงการในวันนี้เราจะไม่ใช้อะไรเลยนอกจาก F # มีเหตุผลหลายประการที่ทำให้ F # เป็นภาษาที่เราเลือก:

• การรวม. NET: F # มีการผสานรวมอย่างแน่นหนากับโลก. NET ที่เหลือดังนั้นจึงพร้อมที่จะเข้าถึงระบบนิเวศขนาดใหญ่ของไลบรารีที่ได้รับการสนับสนุนและมีเอกสารอย่างละเอียดเพื่อแก้ปัญหาการเขียนโปรแกรมที่หลากหลาย
• ความกระชับ: F # มีความกระชับอย่างยิ่งเนื่องจากระบบการอนุมานประเภทที่มีประสิทธิภาพและไวยากรณ์แบบรวบรัด งานการเขียนโปรแกรมมักจะสามารถแก้ไขได้อย่างสวยงามโดยใช้ F # มากกว่า C # หรือ Java รหัส F # สามารถดูคล่องตัวมากเมื่อเปรียบเทียบ
• เครื่องมือสำหรับผู้พัฒนา: F # มีการผสานรวมที่แข็งแกร่ง Visual Studio ซึ่งเป็นหนึ่งใน IDE ที่ดีที่สุดสำหรับระบบนิเวศ. NET สำหรับผู้ที่ทำงานบนแพลตฟอร์มที่ไม่ใช่ Windows มีปลั๊กอินมากมายในรหัส Visual Studio เครื่องมือเหล่านี้ทำให้การเขียนโปรแกรมใน F # มีประสิทธิผลอย่างมาก

ฉันสามารถพูดคุยเกี่ยวกับประโยชน์ของการใช้ F # ได้ แต่หากไม่ต้องกังวลใจอีกต่อไปเรามาดูกันดีกว่า!

แนวคิดเบื้องหลังการสอน F # ของเรา

ในสหรัฐอเมริกามีคำพูดยอดนิยมว่า “ เวลาห้าโมงเย็นที่ไหนสักแห่ง” .

ในบางส่วนของโลก 17:00 น. เป็นช่วงเวลาแรกสุดที่สังคมยอมรับได้ในการดื่มหรือจิบชาแบบดั้งเดิม

วันนี้เราจะสร้างแอปพลิเคชันตามแนวคิดนี้ เราจะสร้างแอปพลิเคชันที่ค้นหาตามเขตเวลาต่างๆในเวลาใดก็ได้ค้นหาว่าอยู่ที่ใดเวลาห้านาฬิกาและให้ข้อมูลนั้นแก่ผู้ใช้

ส่วนหลัง

การตั้งค่าเว็บเซิร์ฟเวอร์

เราจะเริ่มต้นด้วยการสร้างบริการส่วนหลังที่ทำหน้าที่ค้นหาเขตเวลา เราจะใช้ Suave.IO เพื่อสร้าง JSON API

เรียบ IO เป็นเว็บเฟรมเวิร์กที่ใช้งานง่ายพร้อมเว็บเซิร์ฟเวอร์ที่มีน้ำหนักเบาซึ่งช่วยให้สามารถเข้ารหัสเว็บแอปอย่างง่ายได้อย่างรวดเร็ว

ในการเริ่มต้นไปที่ Visual Studio และเริ่มโครงการ F # Console Application ใหม่ ถ้าคุณไม่มีตัวเลือกนี้คุณอาจต้องติดตั้งฟังก์ชัน F # ด้วย Visual Studio Installer ตั้งชื่อโครงการว่า“ FivePM” เมื่อแอปพลิเคชันของคุณถูกสร้างขึ้นคุณจะเห็นสิ่งนี้:

[] let main argv = printfn '%A' argv 0 // return an integer exit code

นี่เป็นโค้ดเริ่มต้นที่เรียบง่ายมากที่พิมพ์อาร์กิวเมนต์และออกด้วยรหัสสถานะ 0 คุณสามารถเปลี่ยนคำสั่งพิมพ์และทดลองกับฟังก์ชันต่างๆของโค้ดได้ ฟอร์แมตเตอร์“% A” เป็นฟอร์แมตเตอร์พิเศษที่พิมพ์การแสดงสตริงของประเภทใดก็ตามที่คุณส่งผ่านดังนั้นอย่าลังเลที่จะพิมพ์จำนวนเต็มจำนวนลอยหรือแม้แต่ประเภทที่ซับซ้อน เมื่อคุณคุ้นเคยกับไวยากรณ์พื้นฐานแล้วก็ถึงเวลาติดตั้ง Suave

วิธีที่ง่ายที่สุดในการติดตั้ง Suave คือผ่านตัวจัดการแพ็คเกจ NuGet ไปที่โครงการ -> จัดการแพ็คเกจ NuGet และคลิกที่แท็บเรียกดู ค้นหา Suave แล้วคลิกติดตั้ง เมื่อคุณยอมรับแพคเกจที่จะติดตั้งคุณควรจะพร้อม! กลับไปที่หน้าจอ program.fs ของคุณแล้วเราก็พร้อมที่จะเริ่มสร้างเซิร์ฟเวอร์

ในการเริ่มใช้งาน Suave เราจะต้องนำเข้าแพ็คเกจก่อน ที่ด้านบนสุดของโปรแกรมของคุณพิมพ์ข้อความต่อไปนี้:

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

สิ่งนี้จะนำเข้าแพ็คเกจพื้นฐานที่จำเป็นในการสร้างเว็บเซิร์ฟเวอร์พื้นฐาน ตอนนี้แทนที่รหัสในหลักด้วยสิ่งต่อไปนี้ซึ่งกำหนดแอปอย่างง่ายและให้บริการบนพอร์ต 8080:

[] 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

โค้ดควรดูตรงไปตรงมามากแม้ว่าคุณจะไม่คุ้นเคยกับไวยากรณ์ F # หรือวิธีการกำหนดตัวจัดการเส้นทางของ Suave แต่โค้ดก็ควรอ่านได้อย่างเป็นธรรม โดยพื้นฐานแล้วเว็บแอปจะกลับมาพร้อมกับสถานะ 200 สถานะและ 'Hello World!' เมื่อถูกตีด้วยคำขอ GET บนเส้นทาง“ /” ไปข้างหน้าและเรียกใช้แอปพลิเคชัน (F5 ใน Visual Studio) และไปที่ localhost: 8080 และคุณจะเห็น“ Hello World!” ในหน้าต่างเบราว์เซอร์ของคุณ

การสร้างรหัสเซิร์ฟเวอร์ใหม่

ตอนนี้เรามีเว็บเซิร์ฟเวอร์แล้ว! น่าเสียดายที่มันไม่ได้ทำมากนักดังนั้นเรามาดูฟังก์ชั่นการใช้งานกัน! ขั้นแรกให้ย้ายการทำงานของเว็บเซิร์ฟเวอร์ไปที่อื่นเพื่อให้เราสร้างฟังก์ชันบางอย่างได้โดยไม่ต้องกังวลกับเว็บเซิร์ฟเวอร์ (เราจะเชื่อมต่อกับเว็บเซิร์ฟเวอร์ในภายหลัง) กำหนดฟังก์ชันที่แยกจากกันดังนี้:

// 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

ตอนนี้เปลี่ยนหน้าที่หลักเป็นดังต่อไปนี้และตรวจสอบให้แน่ใจว่าเราทำถูกต้อง

วิกฤตการณ์ทางการเงินของกรีกสำหรับหุ่น

[] let main argv = runWebServer argv 0

กด F5 และ 'Hello World!' ของเรา เซิร์ฟเวอร์ควรทำงานเหมือนเดิม

รับเขตเวลา

ตอนนี้เรามาสร้างฟังก์ชันที่กำหนดเขตเวลาซึ่งเป็นเวลาห้านาฬิกา เราต้องการเขียนโค้ดเพื่อวนซ้ำตามโซนเวลาทั้งหมดและกำหนดเขตเวลาที่ใกล้เคียงที่สุดกับ 17.00 น.

นอกจากนี้เราไม่ต้องการส่งคืนเขตเวลาที่ใกล้ถึง 17.00 น. แต่ต้องก่อนเวลาเล็กน้อย (เช่น 16:58 น.) เนื่องจากวัตถุประสงค์ของการสาธิตนี้มีหลักฐานว่าไม่สามารถมาก่อนวันที่ 5 : 00 น. แต่ปิด

เริ่มต้นด้วยการรับรายการเขตเวลา ใน F # มันง่ายมากเพราะมันรวมเข้ากับ C # ได้ดีมาก เพิ่ม“ ระบบเปิด” ที่ด้านบนและเปลี่ยนแอปพลิเคชัน F # ของคุณเป็น:

[] 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

เรียกใช้แอปพลิเคชันและคุณจะเห็นรายการโซนเวลาทั้งหมดออฟเซ็ตและชื่อที่แสดงในคอนโซลของคุณ

การสร้างและใช้งานประเภทกำหนดเอง

ตอนนี้เรามีรายชื่อเขตเวลาแล้วเราสามารถแปลงเป็นประเภทข้อมูลที่กำหนดเองซึ่งมีประโยชน์กับเรามากขึ้นซึ่งมีข้อมูลเช่นค่าชดเชย UTC เวลาท้องถิ่นระยะเวลาตั้งแต่ 17.00 น. ตามเวลาท้องถิ่น ฯลฯ ด้วยเหตุนี้เรามากำหนดประเภทที่กำหนดเองเหนือฟังก์ชันหลักของคุณ:

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

ตอนนี้เราสามารถแปลงและข้อมูลเขตเวลาที่เราได้รับจากขั้นตอนสุดท้ายลงในรายการของวัตถุ TZInfo นี้ เปลี่ยนฟังก์ชันหลักของคุณด้วยเหตุนี้:

[] 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

และคุณควรเห็นวัตถุ tzInfo สำหรับเวลามาตรฐานของ Dateline พิมพ์บนหน้าจอของคุณ

การเรียงลำดับและการกรองและการวางท่อ Oh My!

ตอนนี้เรามีรายการของออบเจ็กต์ tzInfo แล้วเราสามารถกรองและจัดเรียงวัตถุเหล่านี้เพื่อค้นหาเขตเวลาที่มันคือ 1) หลัง 17.00 น. และ 2) ใกล้เคียงที่สุดถึง 17.00 น. ของเขตเวลาใน 1) เปลี่ยนฟังก์ชันหลักของคุณดังนี้:

[] 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

และตอนนี้เราควรมีเขตเวลาที่เรากำลังมองหา

การปรับโครงสร้าง Timezone Getter ให้เป็นฟังก์ชันของตัวเอง

ตอนนี้เรามา refactor โค้ดให้เป็นฟังก์ชันของตัวเองเพื่อให้เราสามารถใช้งานได้ในภายหลัง กำหนดฟังก์ชันดังนั้น:

// 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: [] let main argv = printfn '%A' <| getClosest() 0

รันโค้ดและคุณจะเห็นผลลัพธ์เหมือนเดิม

JSON เข้ารหัสข้อมูลส่งคืน

ตอนนี้เราสามารถรับข้อมูลเขตเวลาได้แล้วเราสามารถแปลงข้อมูลเป็น JSON และให้บริการผ่านแอปพลิเคชันของเรา มันค่อนข้างง่ายขอบคุณแพ็คเกจ JSON.NET จาก NewtonSoft กลับไปที่ตัวจัดการแพ็คเกจ NuGet ของคุณและค้นหา Newtonsoft.Json และติดตั้งแพ็คเกจ ตอนนี้กลับไปที่ Program.fs และทำการเปลี่ยนแปลงเล็กน้อยกับฟังก์ชันหลักของเรา:

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

เรียกใช้โค้ดทันทีและแทนที่จะเป็นวัตถุ TZInfo คุณควรเห็น JSON พิมพ์ลงในคอนโซลของคุณ

ความแตกต่างระหว่าง c คอร์ปอเรชั่น และ s คอร์ปอเรชั่น บน w9

การเชื่อมต่อข้อมูลโซนเวลากับ JSON API

ง่ายมากที่จะเชื่อมต่อกับ JSON API ของเรา เพียงทำการเปลี่ยนแปลงต่อไปนี้กับฟังก์ชัน runWebServer ของคุณ:

// 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 => setMimeType 'application/json; charset=utf-8' ] ] // Now we start the server startWebServer cfg app

เรียกใช้แอปพลิเคชันและไปที่ localhost: 8080 คุณควรเห็น JSON บนหน้าต่างเบราว์เซอร์ของคุณ

การปรับใช้เซิร์ฟเวอร์

ตอนนี้เรามีเซิร์ฟเวอร์ JSON API แล้วเราสามารถปรับใช้เพื่อให้เข้าถึงได้บนอินเทอร์เน็ต วิธีที่ง่ายที่สุดวิธีหนึ่งในการปรับใช้แอปพลิเคชันนี้คือผ่านบริการแอปของ Microsoft Azure ซึ่งสามารถเข้าใจได้ว่าเป็นบริการ IIS ที่มีการจัดการ ในการปรับใช้กับบริการ Azure App ตรงไปที่ https://portal.azure.com และไปที่ App Service สร้างแอปใหม่และไปที่ศูนย์การปรับใช้ในพอร์ทัลของคุณ พอร์ทัลอาจดูน่ากลัวเล็กน้อยหากเป็นครั้งแรกของคุณดังนั้นหากคุณมีปัญหาอย่าลืมปรึกษาหนึ่งในบทแนะนำมากมายสำหรับการใช้บริการแอพ

คุณควรเห็นตัวเลือกต่างๆสำหรับการปรับใช้ คุณสามารถใช้สิ่งที่คุณต้องการ แต่เพื่อความเรียบง่ายเราสามารถใช้ตัวเลือก FTP

บริการแอปจะค้นหาไฟล์ web.config ที่รากของแอปพลิเคชันของคุณเพื่อทราบวิธีเรียกใช้แอปพลิเคชันของคุณ เนื่องจากเว็บเซิร์ฟเวอร์ของเราเป็นแอปพลิเคชันคอนโซลที่จำเป็นเราจึงสามารถเผยแพร่แอปพลิเคชันและรวมเข้ากับเซิร์ฟเวอร์ IIS โดยใช้ HttpPlatformHandler ใน Visual Studio ให้เพิ่มไฟล์ XML ลงในโปรเจ็กต์ของคุณและตั้งชื่อว่า web.config กรอกด้วย XML ต่อไปนี้:

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])

เชื่อมต่อกับเซิร์ฟเวอร์ FTP โดยใช้ข้อมูลประจำตัวที่ได้รับจากศูนย์การปรับใช้ (คุณจะต้องคลิกที่ตัวเลือก FTP) ย้าย web.config ไปที่โฟลเดอร์ wwwroot ของไซต์ FTP บริการแอปของคุณ

ตอนนี้เราต้องการสร้างและเผยแพร่แอปพลิเคชันของเรา แต่ก่อนที่จะดำเนินการเราจำเป็นต้องทำการเปลี่ยนแปลงเล็กน้อยกับรหัสเซิร์ฟเวอร์ ไปที่ฟังก์ชัน runServer ของคุณและเปลี่ยน 3 บรรทัดแรกเป็นดังต่อไปนี้:

*.azurewebsites.net

ซึ่งช่วยให้แอปพลิเคชันดูอาร์กิวเมนต์ที่ส่งเข้ามาและใช้อาร์กิวเมนต์แรกเป็นหมายเลขพอร์ตแทนที่จะกำหนดให้พอร์ตถูกฮาร์ดโค้ดเป็น 8080 ในการกำหนดค่าเว็บเราส่ง% HTTP_PLATFORM_PORT% เป็นอาร์กิวเมนต์แรกดังนั้นเรา ควรตั้งค่า

สร้างแอปพลิเคชันในโหมดเผยแพร่เผยแพร่แอปพลิเคชันและคัดลอกโฟลเดอร์ที่เผยแพร่ไปยัง wwwroot รีสตาร์ทแอปพลิเคชันและคุณจะเห็นผลลัพธ์ JSON API ที่ [] 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(Resources.Id.myButton) button.Click.Add (fun args -> button.Text <- sprintf '%d clicks!' count count <- count + 1 ) เว็บไซต์.

ตอนนี้แอปพลิเคชันของเราถูกนำไปใช้งานแล้ว!

ส่วนหน้า

ตอนนี้เราได้ติดตั้งเซิร์ฟเวอร์แล้วเราสามารถสร้างส่วนหน้าได้ สำหรับส่วนหน้าเราจะสร้างแอปพลิเคชัน Android โดยใช้ Xamarin และ F # สแต็กนี้เช่นสภาพแวดล้อมส่วนหลังของเรามีการผสานรวมอย่างลึกซึ้งกับ Visual Studio แน่นอนว่าระบบนิเวศ F # รองรับตัวเลือกการพัฒนาส่วนหน้าค่อนข้างน้อย (WebSharper, Fable / Elmish, Xamarin.iOS, DotLiquid ฯลฯ ) แต่เพื่อความสั้นเราจะพัฒนาโดยใช้ Xamarin เท่านั้น Android สำหรับโพสต์นี้และจากไป สำหรับโพสต์ในอนาคต

การตั้งค่า

ในการตั้งค่าแอพ Android ให้เริ่มโปรเจ็กต์ใหม่และเลือกตัวเลือก Xamarin Android ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้งเครื่องมือพัฒนา Android แล้ว เมื่อตั้งค่าโครงการแล้วคุณจะเห็นสิ่งนี้ในไฟล์รหัสหลักของคุณ

It's 5PM Somewhere! 5PM Finder

นี่คือรหัสเริ่มต้นสำหรับ F # Android Xamarin ปัจจุบันโค้ดจะติดตามจำนวนครั้งที่มีการคลิกปุ่มและแสดงค่าการนับปัจจุบัน คุณสามารถเห็นการทำงานได้โดยการกดปุ่ม F5 เพื่อเปิดโปรแกรมจำลองและเริ่มแอปพลิเคชันในโหมดดีบัก

การเพิ่มส่วนประกอบ UI

มาเพิ่มส่วนประกอบ UI และทำให้มีประโยชน์มากขึ้น เปิดทรัพยากร / เค้าโครงและไปที่ Main.axml

คุณควรเห็นการแสดงภาพของเค้าโครงกิจกรรมหลัก คุณสามารถแก้ไของค์ประกอบ UI ต่างๆได้โดยคลิกที่องค์ประกอบ คุณสามารถเพิ่มองค์ประกอบได้โดยไปที่กล่องเครื่องมือและเลือกองค์ประกอบที่คุณต้องการเพิ่ม เปลี่ยนชื่อปุ่มและเพิ่ม textView ด้านล่างปุ่ม การแสดง XML ของ AXML ของคุณควรมีลักษณะดังนี้:

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(Resources.Id.myButton) let txtView = this.FindViewById(Resources.Id.textView1); button.Click.Add (fun args -> let webClient = new WebClient() txtView.Text <- webClient.DownloadString('https://fivepm.azurewebsites.net/') )

AXML อ้างอิงไฟล์รีซอร์ส strings ดังนั้นให้เปิด resource / values ​​/ strings.xml ของคุณและทำการเปลี่ยนแปลงต่อไปนี้:

type TZInfo = { tzName:string localTime: string }

ตอนนี้เราได้สร้าง AXML ส่วนหน้าแล้ว ตอนนี้มาเชื่อมต่อกับโค้ดกัน ไปที่ MainActivity.fs และทำการเปลี่ยนแปลงต่อไปนี้กับฟังก์ชัน onCreate ของคุณ:

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

แทนที่ fivepm.azurewebsites.net ด้วย URL ของการปรับใช้ JSON API ของคุณเอง เรียกใช้แอปพลิเคชันและคลิกที่ปุ่มในโปรแกรมจำลอง ในอีกสักครู่คุณจะเห็น JSON API ส่งคืนพร้อมกับผลลัพธ์ API ของคุณ

การแยกวิเคราะห์ JSON

ใกล้จะถึงแล้ว! ขณะนี้แอปของเรากำลังแสดง JSON แบบดิบและค่อนข้างอ่านไม่ได้ ขั้นตอนต่อไปคือการแยกวิเคราะห์ JSON และส่งออกสตริงที่มนุษย์อ่านได้มากขึ้น ในการแยกวิเคราะห์ JSON เราสามารถใช้ไลบรารี Newtonsoft.JSON จากเซิร์ฟเวอร์

ไปที่ตัวจัดการแพ็คเกจ NuGet ของคุณและค้นหา Newtonsoft.JSON ติดตั้งและกลับไปที่ไฟล์ MainActivity.fs นำเข้าโดยเพิ่ม 'เปิด Newtonsoft.Json'

ตอนนี้เพิ่มประเภท TZInfo ลงในโครงการ เราสามารถนำ TZInfo กลับมาใช้ใหม่จากเซิร์ฟเวอร์ได้ แต่เนื่องจากจริงๆแล้วเราต้องการเพียงสองฟิลด์เราจึงสามารถกำหนดประเภทที่กำหนดเองได้ที่นี่:

|_+_|

เพิ่มนิยามประเภทเหนือฟังก์ชันหลักและตอนนี้เปลี่ยนฟังก์ชันหลักดังนี้:

|_+_|

ตอนนี้ผลลัพธ์ JSON API ถูก deserialized ลงในวัตถุ TZInfo และใช้เพื่อสร้างสตริง เรียกใช้แอพและคลิกปุ่ม คุณจะเห็นสตริงที่จัดรูปแบบปรากฏบนหน้าจอ

วิธีตั้งโปรแกรมบอท

แม้ว่าแอปพลิเคชันนี้จะเรียบง่ายมากและอาจไม่ได้รับการปรับแต่ง แต่เราได้สร้างแอปพลิเคชันมือถือที่ใช้งานและ F # JSON API แปลงข้อมูลและแสดงให้ผู้ใช้เห็น และเราทำทั้งหมดใน F # อย่าลังเลที่จะเล่นกับการควบคุมต่างๆและดูว่าคุณสามารถปรับปรุงการออกแบบได้หรือไม่

และเรามี! แอปพลิเคชันมือถือ F # ที่เรียบง่ายและ F # JSON API และบอกผู้ใช้ว่าอยู่ที่ใด

ห่อ

วันนี้เราได้เรียนรู้การสร้าง Web API แบบธรรมดาและแอปพลิเคชัน Android แบบง่ายๆโดยใช้ F # เพียงอย่างเดียวซึ่งแสดงให้เห็นทั้งการแสดงออกของภาษา F # และความแข็งแกร่งของระบบนิเวศ F # อย่างไรก็ตามเราแทบไม่มีรอยขีดข่วนพื้นผิวของการพัฒนา F # ดังนั้นฉันจะเขียนโพสต์อีกสองสามโพสต์เพื่อต่อยอดจากสิ่งที่เราได้พูดคุยกันในวันนี้ นอกจากนี้ฉันหวังว่าโพสต์นี้เป็นแรงบันดาลใจให้คุณสร้างแอปพลิเคชัน F # ของคุณเอง!

คุณสามารถค้นหารหัสที่เราใช้สำหรับบทช่วยสอนนี้ GitHub . ฉันยังสร้างเวอร์ชันที่มีส่วนหน้าของเว็บและระฆังและนกหวีดเพิ่มเติมซึ่งคุณสามารถหาได้ https://fivepm.azurewebsites.net .

ทำความเข้าใจพื้นฐาน

F # เป็นภาษาที่ใช้งานได้หรือไม่?

ใช่แม้ว่า F # ไม่ใช่ภาษาโปรแกรมที่ใช้งานได้เท่านั้น เป็นภาษาหลายกระบวนทัศน์ที่ครอบคลุมวิธีการเขียนโปรแกรมที่จำเป็นเชิงวัตถุและเชิงฟังก์ชัน

F # ใช้ทำอะไร?

F # ได้รับการออกแบบมาเพื่อเปิดใช้งานตัวแปรของ OCaml เพื่อทำงานบน. NET แม้ว่า F # ควรถูกมองว่าเป็นภาษาสำหรับวัตถุประสงค์ทั่วไป แต่เป้าหมายหลักคือการนำการเขียนโปรแกรมเชิงฟังก์ชันไปสู่แนวนอน. NET

ทำไมต้องเลือก F #

มีสาเหตุหลายประการที่คุณควรพิจารณาและเลือก F # นำเสนอการผสานรวมที่ยอดเยี่ยมกับระบบนิเวศ. NET ที่เหลือ มันกระชับมากเนื่องจากไวยากรณ์ที่สั้นและคุณสามารถพึ่งพาเครื่องมือสำหรับนักพัฒนามากมาย