การเขียนโค้ดเพียงครั้งเดียวและใช้งานบนหลายแพลตฟอร์มเป็นความฝันของนักพัฒนาซอฟต์แวร์จำนวนมาก แม้ว่าสิ่งนี้จะเป็นไปได้มาระยะหนึ่งแล้ว แต่ก็มักจะมีค่าใช้จ่ายในการบำรุงรักษาความง่ายในการทดสอบหรือที่แย่กว่านั้นคือประสบการณ์การใช้งานที่ไม่ดี
การพัฒนาแอปพลิเคชันมือถือโดยใช้ SDK ดั้งเดิมน่าจะเป็นจุดเริ่มต้นสำหรับนักพัฒนาทุกคนที่มีรากฐานมาจากการพัฒนาแอปพลิเคชันบนเดสก์ท็อป ภาษาการเขียนโปรแกรมจะกลายเป็นอุปสรรคสำหรับบางคน: หากใครบางคนมีประสบการณ์ในการพัฒนาเดสก์ท็อป Java หรือแอปพลิเคชันส่วนหลังให้ย้ายไปที่ไฟล์ บริษัท พัฒนาแอพมือถือ และการทำงานกับ Android จะรู้สึกง่ายกว่าการเริ่มต้นด้วย Objective-C ตั้งแต่เริ่มต้นสำหรับ iOS
ฉันมักจะสงสัยในการพัฒนาแอปพลิเคชันข้ามแพลตฟอร์ม เฟรมเวิร์กที่ใช้ JavaScript เช่น Sencha, Cordova, Titanium และอื่น ๆ ไม่เคยพิสูจน์ว่าเป็นทางเลือกที่ชาญฉลาดเมื่อประสิทธิภาพเป็นสิ่งสำคัญ การขาด API และประสบการณ์การใช้งานที่แปลกใหม่เป็นผลมาจากกรอบงานเหล่านี้
แต่แล้วฉันก็เจอ Xamarin
ในบทความนี้คุณจะได้เรียนรู้วิธีใช้ Xamarin เพื่อแชร์โค้ดในหลาย ๆ แพลตฟอร์มโดยไม่กระทบต่อการพัฒนาแอปพลิเคชันมือถือในด้านอื่น ๆ บทความนี้จะมุ่งเน้นไปที่ Android และ iOS โดยเฉพาะ แต่คุณสามารถใช้แนวทางเดียวกันนี้เพื่อเพิ่มการสนับสนุนสำหรับแพลตฟอร์มอื่น ๆ ที่ Xamarin รองรับ
Xamarin คืออะไร?
Xamarin เป็นแพลตฟอร์มการพัฒนา ที่ช่วยให้คุณสามารถเขียนข้ามแพลตฟอร์ม - แต่เป็นแอปพลิเคชันสำหรับ iOS, Android และ Windows Phone ใน C # และ. NET
Xamarin ให้การเชื่อมโยง C # กับ Android และ iOS APIs สิ่งนี้ช่วยให้คุณใช้อินเทอร์เฟซผู้ใช้เนทีฟการแจ้งเตือนกราฟิกแอนิเมชั่นและคุณสมบัติอื่น ๆ ของโทรศัพท์ของ Android และ iOS ได้ทั้งหมดโดยใช้ C #
Android และ iOS รุ่นใหม่แต่ละรุ่นจับคู่โดย Xamarin โดยรุ่นใหม่ที่มีการเชื่อมโยงสำหรับ API ใหม่
พอร์ตของ. NET ของ Xamarin ประกอบด้วยคุณลักษณะต่างๆเช่นชนิดข้อมูลข้อมูลทั่วไปการรวบรวมขยะแบบสอบถามแบบรวมภาษา (LINQ) รูปแบบการเขียนโปรแกรมแบบอะซิงโครนัสผู้รับมอบสิทธิ์และชุดย่อยของ Windows Communication Foundation (WCF) ไลบรารีได้รับการจัดการด้วยการคงอยู่เพื่อรวมเฉพาะส่วนประกอบที่อ้างอิงเท่านั้น
Xamarin.Forms เป็นเลเยอร์ที่อยู่ด้านบนของการผูก UI อื่น ๆ และ Windows Phone API ซึ่งมีไลบรารีส่วนต่อประสานผู้ใช้ข้ามแพลตฟอร์มอย่างสมบูรณ์
การเขียนแอปพลิเคชันข้ามแพลตฟอร์ม
ในการเขียนแอปพลิเคชันข้ามแพลตฟอร์มด้วย Xamarin นักพัฒนาจำเป็นต้องเลือกหนึ่งในสองประเภทของโครงการที่มีให้:
- Portable Class Library (PCL)
- โครงการที่ใช้ร่วมกัน
PCL อนุญาตให้คุณเขียนโค้ดที่สามารถแชร์ระหว่างแพลตฟอร์มต่างๆได้ แต่มีข้อ จำกัด ประการหนึ่ง เนื่องจาก. NET API ทั้งหมดไม่สามารถใช้งานได้ในทุกแพลตฟอร์มด้วยโปรเจ็กต์ PCL คุณจะถูก จำกัด ให้ทำงานบนแพลตฟอร์มที่กำหนดเป้าหมายไว้
ตารางด้านล่างแสดง API ที่พร้อมใช้งานบนแพลตฟอร์มใดบ้าง:
| ลักษณะเฉพาะ | .NET Framework | แอพ Windows Store | ซิลเวอร์ไลท์ | Windows Phone | Xamarin |
|---|---|---|---|---|---|
| แกน | ย | ย | ย | ย | ย |
| LINQ | ย | ย | ย | ย | ย |
| ฉลาดมาก | ย | ย | ย | 7.5+ | ย |
| การทำให้เป็นอนุกรม | ย | ย | ย | ย | ย |
| คำอธิบายประกอบข้อมูล | 4.0.3+ | ย | ย | ย | ย |
ในระหว่างกระบวนการสร้าง PCL จะถูกคอมไพล์เป็น DLL แยกกันและโหลดโดย Mono ระหว่างรันไทม์ สามารถจัดเตรียมการใช้งานอินเทอร์เฟซเดียวกันที่แตกต่างกันระหว่างรันไทม์
ในทางกลับกันโครงการที่แชร์จะช่วยให้คุณควบคุมได้มากขึ้นโดยให้คุณเขียนโค้ดเฉพาะแพลตฟอร์มสำหรับแต่ละแพลตฟอร์มที่คุณต้องการสนับสนุน โค้ดในโปรเจ็กต์ที่แชร์สามารถมีคำสั่งคอมไพเลอร์ที่จะเปิดหรือปิดใช้งานส่วนต่างๆของโค้ดขึ้นอยู่กับโปรเจ็กต์แอปพลิเคชันที่ใช้โค้ด
ซึ่งแตกต่างจาก PCL โครงการที่ใช้ร่วมกันจะไม่สร้าง DLL ใด ๆ รหัสจะรวมอยู่ในโครงการสุดท้ายโดยตรง
มอบโครงสร้างให้กับรหัสข้ามแพลตฟอร์มของคุณด้วย MvvmCross
โค้ดที่ใช้ซ้ำได้อาจช่วยประหยัดเงินและเวลาสำหรับทีมพัฒนา อย่างไรก็ตามโค้ดที่มีโครงสร้างดีทำให้ชีวิตง่ายขึ้นสำหรับนักพัฒนา ไม่มีใครชื่นชมโค้ดที่ไม่มีข้อผิดพลาดที่เขียนขึ้นอย่างสวยงามมากกว่านักพัฒนา
Xamarin มีกลไกที่ทำให้การเขียนโค้ดข้ามแพลตฟอร์มแบบใช้ซ้ำได้ง่ายขึ้นมาก
นักพัฒนาอุปกรณ์เคลื่อนที่คุ้นเคยกับสถานการณ์ที่ต้องเขียนตรรกะเดียวกันสองครั้งขึ้นไปเพื่อให้รองรับ iOS, Android และแพลตฟอร์มอื่น ๆ แต่ด้วย Xamarin ตามที่อธิบายไว้ในบทก่อนหน้านี้การใช้โค้ดซ้ำซึ่งเขียนขึ้นสำหรับแพลตฟอร์มเดียวสำหรับแพลตฟอร์มอื่น ๆ ก็ทำได้ง่ายเช่นกัน
แล้ว MvvmCross มาจากไหน?
MvvmCross เนื่องจากชื่ออาจบอกใบ้ทำให้สามารถใช้รูปแบบ MVVM ในแอปพลิเคชัน Xamarin ได้ มาพร้อมกับไลบรารี API และยูทิลิตี้จำนวนมากซึ่งมีประโยชน์มากในการพัฒนาแอปพลิเคชันข้ามแพลตฟอร์ม
MvvmCross สามารถลดจำนวนโค้ดสำเร็จรูปที่คุณจะต้องเขียน (บางครั้งหลายครั้งในภาษาที่แตกต่างกัน) ในแนวทางอื่น ๆ ในการพัฒนาแอปพลิเคชัน
โครงสร้างของโซลูชัน MvvmCross
ชุมชน MvvmCross แนะนำวิธีที่ค่อนข้างง่ายและมีประสิทธิภาพในการจัดโครงสร้างโซลูชัน MvvmCross:
.Core .UI.Droid .UI.iOS โครงการหลักในโซลูชัน MvvmCross เกี่ยวข้องกับโค้ดที่ใช้ซ้ำได้ โครงการหลักคือโครงการ Xamarin PCL ที่เน้นหลักคือการนำกลับมาใช้ใหม่
โค้ดใด ๆ ที่เขียนใน Core ควรเป็นแพลตฟอร์มที่ไม่เชื่อเรื่องพระเจ้าในวิธีที่เป็นไปได้สูงสุด ควรมีเฉพาะตรรกะที่สามารถใช้ซ้ำได้ในทุกแพลตฟอร์ม โครงการหลักจะต้องไม่ใช้ Android หรือ iOS API ใด ๆ และไม่สามารถเข้าถึงสิ่งที่เฉพาะเจาะจงกับแพลตฟอร์มใด ๆ
ชั้นตรรกะทางธุรกิจชั้นข้อมูลและการสื่อสารส่วนหลังล้วนเป็นตัวเลือกที่สมบูรณ์แบบสำหรับรวมไว้ในโครงการหลัก การนำทางผ่านลำดับชั้นของมุมมอง (กิจกรรมชิ้นส่วน ฯลฯ ) จะทำได้ใน Core
ก่อนดำเนินการต่อจำเป็นต้องเข้าใจรูปแบบการออกแบบสถาปัตยกรรมอย่างหนึ่งซึ่งมีความสำคัญอย่างยิ่งต่อการทำความเข้าใจ MvvmCross และวิธีการทำงาน ดังที่เห็นได้จากชื่อ MvvmCross ขึ้นอยู่กับรูปแบบ MVVM เป็นอย่างมาก
MVVM เป็นรูปแบบการออกแบบสถาปัตยกรรมที่อำนวยความสะดวกในการแยกส่วนติดต่อผู้ใช้แบบกราฟิกออกจากตรรกะทางธุรกิจและข้อมูลส่วนหลัง
รูปแบบนี้ใช้ใน MvvmCross อย่างไร?
เนื่องจากเราต้องการให้โค้ดของเราสามารถนำกลับมาใช้ใหม่ได้สูงเราจึงต้องการให้มี Core มากที่สุดเท่าที่จะทำได้ใน Core ซึ่งเป็นโครงการ PCL เนื่องจากมุมมองเป็นเพียงส่วนเดียวของโค้ดที่แตกต่างจากแพลตฟอร์มหนึ่งไปยังอีกแพลตฟอร์มหนึ่งเราจึงไม่สามารถนำกลับมาใช้ซ้ำในแพลตฟอร์มต่างๆได้ ส่วนนั้นจะถูกนำไปใช้ในโครงการที่เกี่ยวข้องกับแพลตฟอร์ม
MvvmCross ช่วยให้เราสามารถจัดเตรียมการนำทางแอปพลิเคชันจาก Core โดยใช้ ViewModels
ด้วยข้อมูลพื้นฐานและรายละเอียดทางเทคนิคที่ไม่ถูกต้องเรามาเริ่มต้นกับ Xamarin ด้วยการสร้างโครงการ MvvmCross Core ของเราเอง:
การสร้างโครงการหลักของ MvvmCross
เปิด Xamarin Studio และสร้างโซลูชันชื่อ ApeeScapeExampleSolution:
เนื่องจากเรากำลังสร้างโปรเจ็กต์หลักจึงเป็นความคิดที่ดีที่จะยึดหลักการตั้งชื่อ ตรวจสอบให้แน่ใจว่า Core เพิ่มคำต่อท้ายในชื่อโปรเจ็กต์
ในการรับการสนับสนุน MvvmCross จำเป็นต้องเพิ่มไลบรารี MvvmCross ในโครงการของเรา เพื่อเพิ่มว่าเราสามารถใช้การสนับสนุนในตัวสำหรับ NuGet ใน Xamarin Studio
ในการเพิ่มไลบรารีให้คลิกขวาที่โฟลเดอร์ Packages แล้วเลือกไฟล์ เพิ่มแพ็คเกจ ... ตัวเลือก
ในช่องค้นหาเราสามารถค้นหา MvvmCross ซึ่งจะกรองผลลัพธ์ที่เกี่ยวข้องกับ MvvmCross ดังที่แสดงด้านล่าง:
คลิกที่ไฟล์ เพิ่มแพ็คเกจ ปุ่มจะเพิ่มลงในโครงการ
เมื่อเพิ่ม MvvmCross ในโครงการของเราเราก็พร้อมที่จะเขียนโค้ดหลักของเรา
มากำหนด ViewModel แรกของเรากัน ในการสร้างโฟลเดอร์ให้สร้างลำดับชั้นของโฟลเดอร์ดังนี้:
นี่คือสิ่งที่แต่ละโฟลเดอร์เกี่ยวกับ:
- รุ่น: แบบจำลองโดเมนที่แสดงเนื้อหาสถานะจริง
- บริการ: โฟลเดอร์ที่เก็บบริการของเรา (ตรรกะทางธุรกิจฐานข้อมูล ฯลฯ )
- ดู วิธีที่เราสื่อสารกับโมเดลของเรา
ViewModel แรกของเรามีชื่อว่า FirstViewModel.cs
public class FirstViewModel : MvxViewModel { private string _firstName; private string _lastName; private string _fullName; public string FirstName { get { return _firstName; } set { _lastName = value; RaisePropertyChanged(); } } public string LastName { get { return _lastName; } set { _lastName = value; RaisePropertyChanged(); } } public string FullName { get { return _fullName; } set { _fullName = value; RaisePropertyChanged(); } } public IMvxCommand ConcatNameCommand { get { return new MvxCommand(() => { FullName = $'{FirstName} {LastName}'; }); } public IMvxCommand NavigateToSecondViewModelCommand { get { return new MvxCommand(() => { ShowViewModel(); }); } } } ตอนนี้เรามี ViewModel แรกแล้วเราสามารถสร้างมุมมองแรกและเชื่อมโยงสิ่งต่างๆเข้าด้วยกัน
UI ของ Android
ในการแสดงเนื้อหาของ ViewModel เราจำเป็นต้องสร้าง UI
ขั้นตอนแรกในการสร้าง Android UI คือการสร้างโครงการ Android ในโซลูชันปัจจุบัน โดยคลิกขวาที่ชื่อโซลูชันแล้วเลือก เพิ่ม -> เพิ่มโครงการใหม่ ... . ในวิซาร์ดให้เลือกแอพ Android และตรวจสอบให้แน่ใจว่าคุณตั้งชื่อโปรเจ็กต์ของคุณ ApeeScapeExample.UI.Droid
ตามที่อธิบายไว้ก่อนหน้านี้ตอนนี้เราจำเป็นต้องเพิ่มการอ้างอิง MvvmCross สำหรับ Android โดยทำตามขั้นตอนเดียวกับโปรเจ็กต์หลักสำหรับการเพิ่มการอ้างอิง NuGet
หลังจากเพิ่มการอ้างอิง MvvmCross แล้วจำเป็นต้องเพิ่มการอ้างอิงไปยังโครงการหลักของเราเพื่อให้เราสามารถใช้โค้ดของเราที่เขียนไว้ที่นั่นได้ หากต้องการเพิ่มการอ้างอิงไปยังโครงการ PCL ให้คลิกขวาที่โฟลเดอร์การอ้างอิงและเลือก แก้ไขข้อมูลอ้างอิง ... ตัวเลือก บนแท็บโครงการเลือกโครงการหลักที่สร้างไว้ก่อนหน้านี้แล้วคลิกตกลง
ส่วนถัดไปอาจเป็นเรื่องยุ่งยากเล็กน้อยในการทำความเข้าใจ
ตอนนี้เราต้องบอก MvvmCross ว่าควรตั้งค่าแอปพลิเคชันของเราอย่างไร ในการทำเช่นนั้นเราต้องสร้าง Setup ชั้น:
namespace ApeeScapeExample.UI.Droid { public class Setup : MvxAndroidSetup { public Setup(Context context) : base(context) { } protected override IMvxApplication CreateApp() { return new Core.App(); } } } ดังที่เห็นได้จากชั้นเรียนเรากำลังบอกให้ MvvmCross เป็น CreateApp ขึ้นอยู่กับ Core.App การใช้งานซึ่งเป็นคลาสที่กำหนดไว้ใน Core และแสดงด้านล่าง:
public class App : MvxApplication { public override void Initialize() { RegisterAppStart(new AppStart()); } } public class AppStart : MvxNavigatingObject, IMvxAppStart { public void Start(object hint = null) { ShowViewModel(); } } ใน App เรากำลังสร้างอินสแตนซ์ของ AppStart ซึ่งจะแสดง ViewModel แรกของเรา
สิ่งเดียวที่เหลืออยู่ตอนนี้คือการสร้างไฟล์เค้าโครง Android ซึ่งจะถูกผูกไว้โดย MvvmCross:
EditTextในไฟล์เลย์เอาต์เรามีการผูกซึ่งได้รับการแก้ไขโดยอัตโนมัติโดย MvvmCross สำหรับ View เรากำลังสร้างการผูกสำหรับคุณสมบัติ Text ซึ่งจะเป็นการผูกแบบสองทาง การเปลี่ยนแปลงใด ๆ ที่เรียกใช้จากฝั่ง ViewModel จะแสดงโดยอัตโนมัติในมุมมองและในทางกลับกัน
[Activity(Label = 'ApeeScapeExample.UI.Droid', Theme = '@style/Theme.AppCompat', MainLauncher = true, Icon = '@mipmap/icon')] public class MainActivity : MvxAppCompatActivity { protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); SetContentView(Resource.Layout.Main); } } ชั้นเรียนสามารถเป็นกิจกรรมหรือส่วนย่อย เพื่อความง่ายเรากำลังใช้กิจกรรมที่โหลดเค้าโครงที่กำหนด:
ContactNameCommandสำหรับปุ่มแรกเรามีการผูกคำสั่งซึ่งหมายความว่าเมื่อเราคลิกที่ปุ่ม MvvmCross จะเรียก Setup จาก ViewModel
สำหรับปุ่มที่สองเราจะแสดง ViewModel อื่น
UI ของ iOS
การสร้างโครงการ iOS ไม่แตกต่างจากการสร้างโครงการ Android คุณต้องทำตามขั้นตอนที่คล้ายกันในการเพิ่มโปรเจ็กต์ใหม่คราวนี้เพียงแค่สร้างโปรเจ็กต์ iOS แทน Android เพียงตรวจสอบให้แน่ใจว่าคุณมีหลักการตั้งชื่อที่สอดคล้องกัน
หลังจากเพิ่มโปรเจ็กต์ iOS คุณต้องเพิ่มการอ้างอิงสำหรับ MvvmCross iOS ขั้นตอนจะเหมือนกับ Core และ Android ทุกประการ (คลิกขวาที่การอ้างอิงในโครงการ iOS ของคุณแล้วคลิก เพิ่มการอ้างอิง ... ).
ตอนนี้เช่นเดียวกับที่เราทำกับ Android จำเป็นต้องสร้าง public class Setup : MvxIosSetup { public Setup(MvxApplicationDelegate appDelegate, IMvxIosViewPresenter presenter) : base(appDelegate, presenter) { } protected override MvvmCross.Core.ViewModels.IMvxApplication CreateApp() { return new App(); } } class ซึ่งจะบอกให้ MvvmCross ตั้งค่าแอปพลิเคชันของเรา
Setupโปรดทราบว่า AppDelegate ขยายชั้นเรียนแล้ว MvxIosSetup และสำหรับ Android มันกำลังขยายออกไป MvxAndroidSetup .
นอกจากนี้อีกอย่างหนึ่งคือเราต้องเปลี่ยน AppDelegate ของเรา ชั้นเรียน.
[Register('AppDelegate')] public class AppDelegate : MvxApplicationDelegate { // class-level declarations public override UIWindow Window { get; set; } public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions) { Window = new UIWindow(UIScreen.MainScreen.Bounds); var presenter = new MvxIosViewPresenter(this, Window); var setup = new Setup(this, presenter); setup.Initialize(); var startup = Mvx.Resolve(); startup.Start(); Window.MakeKeyAndVisible(); return true; } } บน iOS มีหน้าที่ในการเปิดตัวอินเทอร์เฟซผู้ใช้ดังนั้นเราต้องบอกว่าจะนำเสนอมุมมองอย่างไรบน iOS คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับผู้นำเสนอ ที่นี่ .
NavigateToSecondViewModelCommandในการนำเสนอ VIewModel ของเราเราจำเป็นต้องสร้างมุมมอง ในกรณีนั้นเรามาสร้าง ViewController โดยคลิกขวาที่โปรเจ็กต์แล้วเลือก เพิ่ม -> ไฟล์ใหม่ และเลือก ViewController จากส่วน iOS ซึ่งเราจะตั้งชื่อว่า FirstViewController
Xamarin สร้างไฟล์สามไฟล์ซึ่งเราจะกำหนดว่าการผูกของเราจะเป็นอย่างไร ซึ่งแตกต่างจาก Android สำหรับ iOS เราต้องกำหนดการเชื่อมโยงด้วยวิธีที่แตกต่างกันโดยใช้รหัส (แม้ว่าเราจะทำได้บน Android ด้วยและในบางกรณีก็จำเป็นต้องทำเช่นนั้น)
เมื่อจำเป็นต้องเลื่อนไปมาระหว่างมุมมองจะดำเนินการผ่าน ViewModel ในคำสั่ง ShowViewModel(), วิธีการ MvxAppCompatActivity จะพบมุมมองที่เหมาะสมและไปที่มุมมองนั้น
แต่ MVVMCross รู้ได้อย่างไรว่าจะโหลดมุมมองใด
โครงการเว็บเซิร์ฟเวอร์ raspberry pi
ไม่มีเวทมนตร์ใด ๆ ในนั้น เมื่อเราสร้างมุมมองสำหรับ Android (กิจกรรมหรือ Fragment) เรากำลังขยายคลาสพื้นฐานที่มีพารามิเตอร์ประเภท (ShowViewMolel) เมื่อเราเรียก View MvvmCross จะค้นหา Activity ซึ่งขยาย Fragment หรือ VM คลาสที่มีพารามิเตอร์ประเภท public interface IPasswordGeneratorService { string Generate(int length); } . นี่คือเหตุผลที่คุณไม่ได้รับอนุญาตให้มีคลาสมุมมองสองคลาสสำหรับ ViewModel เดียวกัน
การผกผันของการควบคุม
เนื่องจาก Xamarin เป็นเพียงการจัดเตรียม C # wrappers รอบ ๆ API ดั้งเดิมจึงไม่ได้จัดเตรียมกลไกการฉีดขึ้นลง (DI) หรือกลไกการควบคุม (Inversion of Control) ในรูปแบบใด ๆ
หากไม่มีการแทรกรันไทม์ของการพึ่งพาหรือการแทรกเวลาคอมไพล์มันไม่ใช่เรื่องง่ายที่จะสร้างส่วนประกอบที่เชื่อมโยงกันนำกลับมาใช้ใหม่ทดสอบได้และบำรุงรักษาได้ง่าย แนวคิดของ IoC และ DI เป็นที่รู้จักกันมานานแล้ว รายละเอียดเกี่ยวกับ IoC สามารถพบได้ในบทความออนไลน์มากมาย คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับรูปแบบเหล่านี้ได้จาก บทความเบื้องต้นของ Martin Fowler .
IoC มีให้ใช้งานตั้งแต่ MvvmCrosses เวอร์ชันแรกและอนุญาตให้มีการแทรกการอ้างอิงที่รันไทม์เมื่อแอปพลิเคชันเริ่มทำงานและเมื่อใดก็ตามที่จำเป็น
เพื่อให้ได้ส่วนประกอบที่เชื่อมโยงกันอย่างหลวม ๆ เราไม่ควรกำหนดให้มีการนำคลาสไปใช้อย่างเป็นรูปธรรม การกำหนดให้มีการใช้งานที่เป็นรูปธรรมจำกัดความสามารถในการเปลี่ยนแปลงพฤติกรรมของการนำไปใช้งานระหว่างรันไทม์ (คุณไม่สามารถแทนที่ด้วยการนำไปใช้งานอื่นได้) ทำให้ยากต่อการทดสอบส่วนประกอบเหล่านี้
ด้วยเหตุนี้เราจึงจะประกาศอินเทอร์เฟซที่เรากำลังจะนำไปใช้อย่างเป็นรูปธรรม
public class PasswordGeneratorService : IPasswordGeneratorService { public string Generate(int length) { var valid = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'; var res = new StringBuilder(); var rnd = new Random(); while (0 และการนำไปใช้:
IPasswordGenerationServiceขณะนี้ ViewModel ของเราต้องการอินสแตนซ์ของอินเทอร์เฟซ PasswordGeneratorService ซึ่งเรารับผิดชอบในการจัดหา
เพื่อให้ MvvmCross ฉีด App.cs การใช้งานที่รันไทม์เราจำเป็นต้องบอก MvvmCross ว่าจะใช้การนำไปใช้งานใด หากเราต้องการใช้การใช้งานเดียวสำหรับทั้งสองแพลตฟอร์มเราสามารถลงทะเบียนการใช้งานใน public override void Initialize() { RegisterAppStart(new AppStart()); Mvx.LazyConstructAndRegisterSingleton(); } หลังจากการลงทะเบียนแอปพลิเคชัน:
LazyConstructAndRegisterSingletonการเรียกใช้วิธีการแบบคงที่ข้างต้น Mvx.RegisterSingleton() ลงทะเบียนการใช้งานที่จะฉีด วิธีนี้จะลงทะเบียนการใช้งานที่เหมาะสม แต่ไม่ได้สร้างวัตถุ
อ็อบเจ็กต์ถูกสร้างขึ้นเมื่อจำเป็นเท่านั้นและมีเพียงครั้งเดียวเนื่องจากมีการลงทะเบียนเป็นซิงเกิลตัน
หากเราต้องการสร้างวัตถุเดี่ยวทันทีสามารถทำได้โดยการเรียก Mvx.RegisterType()
มีหลายกรณีที่เราไม่ต้องการให้มีเพียงเสื้อกล้ามในแอปพลิเคชันของเรา วัตถุของเราอาจไม่ปลอดภัยต่อเธรดหรืออาจมีเหตุผลอื่นที่ทำให้เราต้องการมีอินสแตนซ์ใหม่อยู่เสมอ หากเป็นเช่นนั้น MvvmCross จะมี method public class DroidPasswodGeneratorService : IPasswordGeneratorService { public string Generate(int length) { return 'DroidPasswordGenerator'; } } ซึ่งสามารถใช้เพื่อลงทะเบียนการใช้งานในลักษณะที่สร้างอินสแตนซ์ใหม่เมื่อใดก็ตามที่จำเป็น
ในกรณีที่คุณจำเป็นต้องจัดเตรียมการใช้งานที่เป็นรูปธรรมแยกกันสำหรับแต่ละแพลตฟอร์มคุณสามารถทำได้ในโครงการเฉพาะแพลตฟอร์ม:
Setup.csและการลงทะเบียนการใช้งานของเราจะเสร็จสิ้นใน protected override void InitializePlatformServices() { base.InitializePlatformServices(); Mvx.LazyConstructAndRegisterSingleton(); } ชั้นเรียนภายใต้โครงการ Droid:
InitializePlatformServicesหลังจากเริ่มต้นรหัส PCL แล้ว MvvmCross จะเรียก
|_+_|
และลงทะเบียนการใช้งานบริการเฉพาะแพลตฟอร์มของเรา เมื่อเราลงทะเบียนการใช้งานซิงเกิลตันหลายรายการ MvvmCross จะใช้เฉพาะการใช้งานที่ลงทะเบียนล่าสุด การลงทะเบียนอื่น ๆ ทั้งหมดจะถูกยกเลิก
สร้างแอพข้ามแพลตฟอร์มด้วย Xamarin
ในบทความนี้คุณจะได้เห็นว่า Xamarin ช่วยให้คุณแชร์โค้ดข้ามแพลตฟอร์มต่างๆได้อย่างไรและยังคงให้ความรู้สึกและประสิทธิภาพของแอปพลิเคชัน
MvvmCross มอบความเป็นนามธรรมอีกชั้นที่ช่วยเพิ่มประสบการณ์ในการสร้างแอปพลิเคชันข้ามแพลตฟอร์มด้วย Xamarin รูปแบบ MVVM เป็นวิธีสร้างการนำทางและขั้นตอนการโต้ตอบกับผู้ใช้ซึ่งเป็นเรื่องปกติสำหรับทุกแพลตฟอร์มทำให้จำนวนโค้ดเฉพาะแพลตฟอร์มที่คุณต้องเขียน จำกัด ไว้ที่การดูเพียงอย่างเดียว
ฉันหวังว่าบทความนี้จะให้เหตุผลแก่คุณในการดู Xamarin และเป็นแรงบันดาลใจให้คุณสร้างแอปพลิเคชันข้ามแพลตฟอร์มถัดไปด้วย
