portaldacalheta.pt
  • หลัก
  • การจัดการโครงการ
  • การเพิ่มขึ้นของระยะไกล
  • การบริหารโครงการ
  • เครื่องมือและบทช่วยสอน
มือถือ

การสร้างแอปข้ามแพลตฟอร์มด้วย Xamarin: มุมมองของนักพัฒนา Android



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

การพัฒนาแอปพลิเคชันมือถือโดยใช้ SDK ดั้งเดิมน่าจะเป็นจุดเริ่มต้นสำหรับนักพัฒนาทุกคนที่มีรากฐานมาจากการพัฒนาแอปพลิเคชันบนเดสก์ท็อป ภาษาการเขียนโปรแกรมจะกลายเป็นอุปสรรคสำหรับบางคน: หากใครบางคนมีประสบการณ์ในการพัฒนาเดสก์ท็อป Java หรือแอปพลิเคชันส่วนหลังให้ย้ายไปที่ไฟล์ บริษัท พัฒนาแอพมือถือ และการทำงานกับ Android จะรู้สึกง่ายกว่าการเริ่มต้นด้วย Objective-C ตั้งแต่เริ่มต้นสำหรับ iOS



ฉันมักจะสงสัยในการพัฒนาแอปพลิเคชันข้ามแพลตฟอร์ม เฟรมเวิร์กที่ใช้ JavaScript เช่น Sencha, Cordova, Titanium และอื่น ๆ ไม่เคยพิสูจน์ว่าเป็นทางเลือกที่ชาญฉลาดเมื่อประสิทธิภาพเป็นสิ่งสำคัญ การขาด API และประสบการณ์การใช้งานที่แปลกใหม่เป็นผลมาจากกรอบงานเหล่านี้



แต่แล้วฉันก็เจอ Xamarin



การพัฒนาข้ามแพลตฟอร์มด้วย 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



การเขียนแอปพลิเคชันข้ามแพลตฟอร์ม

ในการเขียนแอปพลิเคชันข้ามแพลตฟอร์มด้วย Xamarin นักพัฒนาจำเป็นต้องเลือกหนึ่งในสองประเภทของโครงการที่มีให้:

  • Portable Class Library (PCL)
  • โครงการที่ใช้ร่วมกัน

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



Xamarin

ตารางด้านล่างแสดง 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

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 ให้คลิกขวาที่โฟลเดอร์การอ้างอิงและเลือก แก้ไขข้อมูลอ้างอิง ... ตัวเลือก บนแท็บโครงการเลือกโครงการหลักที่สร้างไว้ก่อนหน้านี้แล้วคลิกตกลง

การเพิ่มการอ้างอิงโครงการ 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 และเป็นแรงบันดาลใจให้คุณสร้างแอปพลิเคชันข้ามแพลตฟอร์มถัดไปด้วย

มีความสุขมากขึ้นมีประสิทธิผลมากขึ้น - กรณีศึกษาปัญญาประดิษฐ์

ทีมแบบกระจาย

มีความสุขมากขึ้นมีประสิทธิผลมากขึ้น - กรณีศึกษาปัญญาประดิษฐ์
ARKit Demo: การสร้างภาพยนตร์เสมือนจริง

ARKit Demo: การสร้างภาพยนตร์เสมือนจริง

มือถือ

โพสต์ยอดนิยม
ตลาด Crowdfunding Equity ของสหรัฐมีการเติบโตขึ้นตามความคาดหวังหรือไม่?
ตลาด Crowdfunding Equity ของสหรัฐมีการเติบโตขึ้นตามความคาดหวังหรือไม่?
คู่มือสำคัญสำหรับ Qmake
คู่มือสำคัญสำหรับ Qmake
หลักการออกแบบ Mobile UX
หลักการออกแบบ Mobile UX
MIDI Tutorial: การสร้างแอปพลิเคชั่นเสียงบนเบราว์เซอร์ที่ควบคุมโดยฮาร์ดแวร์ MIDI
MIDI Tutorial: การสร้างแอปพลิเคชั่นเสียงบนเบราว์เซอร์ที่ควบคุมโดยฮาร์ดแวร์ MIDI
Init.js: คำแนะนำเกี่ยวกับสาเหตุและวิธีการใช้ JavaScript แบบ Full-Stack
Init.js: คำแนะนำเกี่ยวกับสาเหตุและวิธีการใช้ JavaScript แบบ Full-Stack
 
Splash of EarlGrey - UI การทดสอบแอพ ApeeScape Talent
Splash of EarlGrey - UI การทดสอบแอพ ApeeScape Talent
จาก Node.js ไปจนถึงการจ่ายภาษีอิสระของคุณ: บทสัมภาษณ์กับ Developer ที่ประสบความสำเร็จ
จาก Node.js ไปจนถึงการจ่ายภาษีอิสระของคุณ: บทสัมภาษณ์กับ Developer ที่ประสบความสำเร็จ
ขายธุรกิจของคุณ? หยุดทิ้งเงินไว้บนโต๊ะ
ขายธุรกิจของคุณ? หยุดทิ้งเงินไว้บนโต๊ะ
บทช่วยสอนเกี่ยวกับส่วนขยายแอป iOS 8
บทช่วยสอนเกี่ยวกับส่วนขยายแอป iOS 8
ผู้จัดการการเติบโต
ผู้จัดการการเติบโต
โพสต์ยอดนิยม
  • เอกสารการทำงานได้รับการออกแบบ
  • ลินุกซ์เขียนด้วยอะไร
  • วิธีรับหมายเลขบัตรเครดิตออนไลน์
  • ar กับ vr กับ mr
  • วิธีการออกแบบ api
หมวดหมู่
  • การจัดการโครงการ
  • การเพิ่มขึ้นของระยะไกล
  • การบริหารโครงการ
  • เครื่องมือและบทช่วยสอน
  • © 2022 | สงวนลิขสิทธิ์

    portaldacalheta.pt