بناء تطبيقات عبر الأنظمة الأساسية باستخدام Xamarin: منظور مطور Android

كانت كتابة الكود مرة واحدة واستخدامها على منصات متعددة بمثابة حلم للعديد من مطوري البرامج. على الرغم من أن هذا كان ممكنًا لبعض الوقت الآن ، إلا أنه جاء دائمًا على حساب إمكانية الصيانة أو سهولة الاختبار أو الأسوأ من ذلك ، تجربة المستخدم السيئة.

ربما يكون تطوير تطبيقات الأجهزة المحمولة باستخدام SDK الأصلي هو نقطة البداية لجميع المطورين الذين لديهم جذور في مجال تطوير تطبيقات سطح المكتب. ستصبح لغات البرمجة عائقًا بالنسبة للبعض: إذا كان شخص ما لديه خبرة في تطوير سطح مكتب Java أو تطبيقات الخلفية ، فإن الانتقال إلى شركة تطوير تطبيقات الأجهزة المحمولة والعمل مع Android سيبدو أسهل بكثير من البدء بـ Objective-C من البداية لنظام iOS.

كنت دائمًا متشككًا في تطوير التطبيقات عبر الأنظمة الأساسية. الأطر المستندة إلى JavaScript مثل Sencha و Cordova و Titanium وما إلى ذلك لا تثبت أبدًا أنها خيار حكيم عندما يكون الأداء مهمًا. تم تقديم الافتقار إلى واجهات برمجة التطبيقات وتجربة المستخدم الملتوية مع هذه الأطر.

لكن بعد ذلك ، صادفت Xamarin.

في هذه المقالة ، ستتعلم كيف يمكنك استخدام Xamarin لمشاركة التعليمات البرمجية عبر منصات متعددة دون المساس بأي من الجوانب الأخرى لتطوير تطبيقات الهاتف المحمول. ستركز المقالة على Android و iOS بشكل خاص ، ولكن يمكنك استخدام نهج مماثل لإضافة دعم لأي نظام أساسي آخر يدعمه Xamarin.

ما هو Xamarin؟

Xamarin هو نظام أساسي للتطوير يسمح لك بكتابة تطبيقات عبر الأنظمة الأساسية - ولكنها أصلية - لأنظمة iOS و Android و Windows Phone في C # و .NET.

يوفر Xamarin روابط C # لواجهات برمجة تطبيقات Android و iOS الأصلية. يمنحك هذا القدرة على استخدام كل واجهة المستخدم الأصلية لنظامي التشغيل Android و iOS والإشعارات والرسومات والرسوم المتحركة وميزات الهاتف الأخرى - كل ذلك باستخدام C #.

كل إصدار جديد من Android و iOS يقابله Xamarin ، مع إصدار جديد يتضمن روابط لواجهات برمجة التطبيقات الجديدة الخاصة بهم.

يتضمن منفذ NET الخاص بـ Xamarin ميزات مثل أنواع البيانات ، والأدوية ، وجمع البيانات المهملة ، والاستعلام المتكامل اللغوي (LINQ) ، وأنماط البرمجة غير المتزامنة ، والمفوضين ، ومجموعة فرعية من Windows Communication Foundation (WCF). تدار المكتبات مع فترة أطول لتضمين المكونات المشار إليها فقط.

Xamarin.Forms هي طبقة أعلى روابط واجهة المستخدم الأخرى وواجهة برمجة تطبيقات Windows Phone ، والتي توفر مكتبة واجهة مستخدم عبر الأنظمة الأساسية بالكامل.

كتابة تطبيقات متعددة المنصات

من أجل كتابة تطبيقات عبر الأنظمة الأساسية باستخدام Xamarin ، يحتاج المطورون إلى اختيار أحد نوعي المشاريع المتاحين:

• مكتبة الفئات المحمولة (PCL)
• مشروع مشترك

يتيح لك PCL كتابة التعليمات البرمجية التي يمكن مشاركتها بين أنظمة أساسية متعددة ، ولكن مع تقييد واحد. نظرًا لعدم توفر جميع واجهات برمجة تطبيقات .NET على جميع الأنظمة الأساسية ، باستخدام مشروع PCL ، فإنك ستحد من تشغيله على الأنظمة الأساسية المستهدفة له.

يوضح الجدول أدناه واجهات برمجة التطبيقات المتاحة على الأنظمة الأساسية:

أثناء عملية الإنشاء ، يتم تجميع PCL في مكتبات DLL منفصلة وتحميلها بواسطة Mono أثناء وقت التشغيل. يمكن توفير تطبيق مختلف للواجهة نفسها أثناء وقت التشغيل.

من ناحية أخرى ، تمنحك المشاريع المشتركة مزيدًا من التحكم من خلال السماح لك بكتابة رمز خاص بالنظام الأساسي لكل نظام أساسي تريد دعمه. يمكن أن تحتوي التعليمات البرمجية في مشروع مشترك على توجيهات للمترجم تعمل على تمكين أو تعطيل أقسام من التعليمات البرمجية بناءً على مشروع التطبيق الذي يستخدم الرمز.

على عكس PCL ، لا ينتج المشروع المشترك أي DLL. يتم تضمين الرمز مباشرة في المشروع النهائي.

إعطاء هيكل للرمز عبر الأنظمة الأساسية الخاص بك مع MvvmCross

قد يوفر الرمز القابل لإعادة الاستخدام المال والوقت لفرق التطوير. ومع ذلك ، فإن التعليمات البرمجية جيدة التنظيم تجعل الحياة أسهل بكثير للمطورين. لا أحد يقدر التعليمات البرمجية الخالية من الأخطاء المكتوبة بشكل جيد أكثر من المطورين.

يوفر Xamarin في حد ذاته آلية تجعل كتابة التعليمات البرمجية عبر الأنظمة الأساسية القابلة لإعادة الاستخدام أسهل بكثير.

مطورو الأجهزة المحمولة معتادون على السيناريوهات حيث يتعين عليهم كتابة نفس المنطق مرتين أو أكثر من أجل دعم أنظمة التشغيل iOS و Android والأنظمة الأساسية الأخرى. ولكن مع Xamarin ، كما هو موضح في الفصل السابق ، من السهل إعادة استخدام الكود المكتوب لمنصة واحدة لبعض الأنظمة الأساسية الأخرى أيضًا.

أين يأتي MvvmCross ، إذن؟

MvvmCross ، كما قد ألمح الاسم ، يجعل من الممكن استخدام نمط MVVM في تطبيقات Xamarin. يأتي مزودًا بمجموعة من المكتبات وواجهات برمجة التطبيقات والمرافق المفيدة حقًا في تطوير التطبيقات عبر الأنظمة الأساسية.

يمكن أن يقلل MvvmCross بشكل كبير من مقدار التعليمات البرمجية المعيارية التي كنت ستكتبها (أحيانًا عدة مرات بلغات مختلفة) في أي نهج آخر لتطوير التطبيق.

هيكل حل MvvmCross

يوصي مجتمع MvvmCross بطريقة بسيطة وفعالة جدًا لهيكلة حل MvvmCross:

 <ProjectName>.Core <ProjectName>.UI.Droid <ProjectName>.UI.iOS

يرتبط المشروع الأساسي في حل MvvmCross بالكود القابل لإعادة الاستخدام. المشروع الأساسي هو مشروع Xamarin PCL حيث ينصب التركيز الرئيسي على إعادة الاستخدام.

يجب أن يكون أي رمز مكتوب في Core حيادي النظام الأساسي بأقصى طريقة ممكنة. يجب أن يحتوي فقط على منطق يمكن إعادة استخدامه على جميع الأنظمة الأساسية. يجب ألا يستخدم مشروع Core أي واجهة برمجة تطبيقات Android أو iOS ولا يصل إلى أي شيء محدد لأي نظام أساسي.

تعتبر طبقة منطق الأعمال وطبقة البيانات والاتصال الخلفي جميعها مرشحين مثاليين للتضمين في المشروع الأساسي. سيتم التنقل عبر التسلسل الهرمي لطرق العرض (الأنشطة ، الأجزاء ، إلخ) في المركز.

قبل المتابعة ، من الضروري فهم نمط تصميم معماري واحد وهو أمر حاسم لفهم MvvmCross وكيف يعمل. كما يتضح من الاسم ، يعتمد MvvmCross بشكل كبير على نمط MVVM.

MVVM هو نمط تصميم معماري يسهل فصل واجهة المستخدم الرسومية عن منطق الأعمال والبيانات الخلفية.

كيف يتم استخدام هذا النمط في MvvmCross؟

حسنًا ، نظرًا لأننا نريد تحقيق قابلية عالية لإعادة استخدام الكود الخاص بنا ، فنحن نريد الحصول على أكبر قدر ممكن في Core الخاص بنا ، وهو مشروع PCL. نظرًا لأن طرق العرض هي الجزء الوحيد من الكود الذي يختلف من نظام أساسي إلى آخر ، فلا يمكننا إعادة استخدامها عبر الأنظمة الأساسية. يتم تنفيذ هذا الجزء في المشاريع المتعلقة بالمنصة.

يمنحنا MvvmCross القدرة على تنظيم التنقل في التطبيق من Core باستخدام ViewModels.

مع الأساسيات والتفاصيل التقنية بعيدًا عن الطريق ، فلنبدأ مع Xamarin من خلال إنشاء مشروع MvvmCross Core الخاص بنا:

إنشاء مشروع MvvmCross الأساسية

افتح Xamarin Studio وقم بإنشاء حل يسمى ToptalExampleSolution :

نظرًا لأننا ننشئ مشروعًا أساسيًا ، فمن الجيد الالتزام باتفاقية التسمية. تأكد من إضافة اللاحقة Core إلى اسم المشروع.

من أجل الحصول على دعم MvvmCross ، يلزم إضافة مكتبات MvvmCross إلى مشروعنا. لإضافة أنه يمكننا استخدام الدعم المدمج لـ NuGet في Xamarin Studio.

لإضافة مكتبة ، انقر بزر الماوس الأيمن على مجلد الحزم وحدد خيار إضافة حزم… .

في حقل البحث ، يمكننا البحث عن MvvmCross ، والذي سيقوم بتصفية النتائج المتعلقة بـ MvvmCross كما هو موضح أدناه:

سيؤدي النقر فوق الزر " إضافة حزمة " إلى إضافتها إلى المشروع.

مع إضافة MvvmCross إلى مشروعنا ، نحن على استعداد لكتابة الكود الأساسي الخاص بنا.

دعونا نحدد أول نموذج عرض لدينا. لإنشاء واحد ، قم بإنشاء تسلسل هرمي للمجلدات على النحو التالي:

إليك ما يدور حوله كل مجلد:

• النماذج: نماذج المجال التي تمثل محتوى حقيقي
• الخدمات: مجلد يحتوي على خدمتنا (منطق الأعمال ، قاعدة البيانات ، إلخ.)
• 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<SecondViewModel>(); }); } } }

الآن بعد أن أصبح لدينا نموذج ViewModel الأول ، يمكننا إنشاء عرضنا الأول وربط الأشياء معًا.

واجهة مستخدم Android

لإظهار محتوى ViewModel ، نحتاج إلى إنشاء واجهة مستخدم.

تتمثل الخطوة الأولى لإنشاء واجهة مستخدم Android في إنشاء مشروع Android في الحل الحالي. للقيام بذلك ، انقر بزر الماوس الأيمن على اسم الحل وحدد إضافة -> إضافة مشروع جديد… . في المعالج ، حدد تطبيق Android وتأكد من تسمية مشروعك ToptalExample.UI.Droid .

كما هو موضح سابقًا ، نحتاج الآن إلى إضافة تبعيات MvvmCross لنظام Android. للقيام بذلك ، اتبع نفس الخطوات الخاصة بالمشروع الأساسي لإضافة تبعيات NuGet.

بعد إضافة تبعيات MvvmCross ، يلزم إضافة مرجع إلى مشروعنا الأساسي حتى نتمكن من استخدام الكود الخاص بنا المكتوب هناك. لإضافة مرجع إلى مشروع PCL ، انقر بزر الماوس الأيمن فوق مجلد المراجع وحدد خيار تحرير المراجع… . في علامة التبويب "المشاريع" ، حدد المشروع الأساسي الذي تم إنشاؤه مسبقًا وانقر فوق "موافق".

قد يكون الجزء التالي صعب الفهم بعض الشيء.

الآن علينا إخبار MvvmCross كيف يجب أن يقوم بإعداد تطبيقنا. للقيام بذلك ، يتعين علينا إنشاء فئة Setup :

 namespace ToptalExample.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<FirstViewModel>(); } }

في فئة App ، نقوم بإنشاء مثيل AppStart ، والذي سيُظهر نموذج ViewModel الأول الخاص بنا.

الشيء الوحيد المتبقي الآن هو إنشاء ملف Android Layout والذي سيكون مرتبطًا بـ MvvmCross:

 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:andro xmlns:local="http://schemas.android.com/apk/res-auto" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <EditText android:layout_width="match_parent" android:layout_height="match_parent" local:MvxBind="Text FirstName" /> <EditText android:layout_width="match_parent" android:layout_height="match_parent" local:MvxBind="Text LastName" /> <TextView android:layout_width="match_parent" android:layout_height="match_parent" local:MvxBind="Text FullName" /> <Button android:layout_width="match_parent" android:layout_height="wrap_content" local:MvxBind="Click ConcatNameCommand" /> <Button android:layout_width="match_parent" android:layout_height="wrap_content" local:MvxBind="Click NavigateToSecondViewModelCommand" /> </LinearLayout>

في ملف التخطيط ، لدينا روابط يتم حلها تلقائيًا بواسطة MvvmCross. بالنسبة لـ EditText ، نقوم بإنشاء ارتباط لخاصية Text ، والذي سيكون رابطًا ثنائي الاتجاه. أي تغيير يتم استدعاؤه من جانب ViewModel سينعكس تلقائيًا على طريقة العرض والعكس صحيح.

يمكن أن تكون فئة View نشاطًا أو جزءًا. من أجل التبسيط ، نستخدم نشاطًا يقوم بتحميل التخطيط المحدد:

 [Activity(Label = "ToptalExample.UI.Droid", Theme = "@style/Theme.AppCompat", MainLauncher = true, Icon = "@mipmap/icon")] public class MainActivity : MvxAppCompatActivity<FirstViewModel> { protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); SetContentView(Resource.Layout.Main); } }

بالنسبة للزر الأول ، لدينا أمر ملزم مما يعني أنه عندما نضغط على الزر MvvmCross سوف يستدعي ContactNameCommand من ViewModel.

بالنسبة للزر الثاني ، سنقوم بإظهار ViewModel آخر.

واجهة مستخدم iOS

لا يختلف إنشاء مشروع iOS حقًا عن إنشاء مشروع Android. تحتاج إلى اتباع خطوات مماثلة لإضافة مشروع جديد ، هذه المرة فقط ، بدلاً من Android ، ما عليك سوى إنشاء مشروع iOS. فقط تأكد من الحفاظ على اتساق اصطلاح التسمية.

بعد إضافة مشروع iOS ، تحتاج إلى إضافة تبعيات لـ MvvmCross iOS. الخطوات متطابقة تمامًا مع Core و Android (انقر بزر الماوس الأيمن على المراجع في مشروع iOS الخاص بك وانقر فوق إضافة مراجع ... ).

الآن ، كما فعلنا مع Android ، مطلوب إنشاء فئة Setup ، والتي ستخبر MvvmCross بكيفية إعداد تطبيقنا.

 public class Setup : MvxIosSetup { public Setup(MvxApplicationDelegate appDelegate, IMvxIosViewPresenter presenter) : base(appDelegate, presenter) { } protected override MvvmCross.Core.ViewModels.IMvxApplication CreateApp() { return new App(); } }

لاحظ أن فئة Setup تمتد الآن إلى MvxIosSetup ، وبالنسبة لنظام Android ، كانت توسع MvxAndroidSetup .

إضافة واحدة هنا هي أنه يتعين علينا تغيير فئة AppDelegate بنا.

AppDelegate على iOS هو المسؤول عن تشغيل واجهة المستخدم ، لذلك علينا أن نقول كيف سيتم تقديم العروض على iOS. يمكنك معرفة المزيد عن مقدمي العروض هنا.

 [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<IMvxAppStart>(); startup.Start(); Window.MakeKeyAndVisible(); return true; } }

لتقديم نموذجنا VIewModel ، نحتاج إلى إنشاء عرض. في هذه الحالة ، دعنا ننشئ ViewController عن طريق النقر بزر الماوس الأيمن على المشروع وتحديد Add -> New File وحدد ViewController من قسم iOS ، والذي سنقوم بتسميته FirstViewController.

يقوم Xamarin بإنشاء ثلاثة ملفات سنقوم فيها بتحديد ما ستكون الارتباطات الخاصة بنا. على عكس Android ، بالنسبة لنظام iOS ، يتعين علينا تحديد روابطنا بطريقة مختلفة ، من خلال الكود (على الرغم من أنه يمكننا القيام بذلك على Android أيضًا ، وفي بعض الحالات ، يلزم القيام بذلك).

عندما يكون التنقل بين طرق العرض مطلوبًا ، يتم ذلك عبر ViewModel. في الأمر NavigateToSecondViewModelCommand ، ستعثر طريقة ShowViewModel<SecondViewModel>() على العرض المناسب وتنتقل إليه.

ولكن كيف يعرف MVVMCross أي عرض يتم تحميله؟

لا يوجد سحر في ذلك. عندما ننشئ عرضًا لنظام Android (نشاط أو جزء) ، فإننا نوسع إحدى الفئات الأساسية باستخدام معلمات النوع ( MvxAppCompatActivity<VM> ). عندما ShowViewMolel<VM> ، يبحث MvvmCross عن View تعمل على توسيع فئة Activity أو Fragment باستخدام معلمات النوع VM . هذا هو سبب عدم السماح لك بالحصول على فئتي عرض لنفس ViewModel.

قلب السيطرة

نظرًا لأن Xamarin يوفر مجرد أغلفة C # حول واجهات برمجة التطبيقات الأصلية ، فإنه لا يوفر أي شكل من أشكال حقن التبعية (DI) أو عكس آلية التحكم (IoC).

بدون حقن وقت التشغيل للتبعيات أو حقن وقت التجميع ، ليس من السهل إنشاء مكونات مقترنة بشكل غير محكم وقابلة لإعادة الاستخدام وقابلة للاختبار ويمكن صيانتها بسهولة. كانت فكرة IoC و DI معروفة منذ وقت طويل حقًا ؛ يمكن العثور على تفاصيل حول IoC في العديد من المقالات عبر الإنترنت. يمكنك معرفة المزيد حول هذه الأنماط من مقالة مارتن فاولر التمهيدية.

كان IoC متاحًا منذ الإصدارات الأولى من MvvmCrosses ، ويسمح بإدخال التبعيات في وقت التشغيل عند بدء التطبيق وكلما كان ذلك مطلوبًا.

من أجل الحصول على مكونات مقترنة بشكل غير محكم ، يجب ألا نطلب تطبيقات ملموسة للفئات. إن طلب تطبيقات ملموسة يحد من القدرة على تغيير سلوك عمليات التنفيذ أثناء وقت التشغيل (لا يمكنك استبدالها بتطبيق آخر). يجعل من الصعب اختبار هذه المكونات.

لهذا السبب ، سنعلن عن واجهة سنحصل من أجلها على تطبيق واحد ملموس.

 public interface IPasswordGeneratorService { string Generate(int length); }

والتنفيذ:

 public class PasswordGeneratorService : IPasswordGeneratorService { public string Generate(int length) { var val; var res = new StringBuilder(); var rnd = new Random(); while (0 < length--) { res.Append(valid[rnd.Next(valid.Length)]); } return res.ToString(); } }

يمكن أن يتطلب نموذجنا ViewModel الآن مثيلاً للواجهة IPasswordGenerationService ، ونحن مسؤولون عن توفيره.

لكي يقوم MvvmCross بحقن تطبيق PasswordGeneratorService في وقت التشغيل ، نحتاج إلى إخبار MvvmCross بالتطبيق الذي يجب استخدامه. إذا أردنا استخدام تطبيق واحد لكلا النظامين الأساسيين ، فيمكننا تسجيل عمليات التنفيذ في App.cs ، بعد تسجيل التطبيق:

 public override void Initialize() { RegisterAppStart(new AppStart()); Mvx.LazyConstructAndRegisterSingleton<IPasswordGeneratorService, PasswordGeneratorService>(); }

الاستدعاء أعلاه للطريقة الثابتة LazyConstructAndRegisterSingleton<TInterface, TType> يسجل التنفيذ المراد حقنه. يسجل هذا الأسلوب التطبيق المناسب ولكن لا يقوم بإنشاء كائن.

يتم إنشاء الكائن فقط عندما يكون مطلوبًا ومرة ​​واحدة فقط منذ تسجيله كعنصر منفرد.

إذا أردنا إنشاء كائن مفرد على الفور ، فيمكن تحقيق ذلك عن طريق استدعاء Mvx.RegisterSingleton<TInterface>() .

هناك حالات لا نريد أن يكون لدينا فيها أحاديات فقط في طلبنا. قد لا يكون كائننا آمنًا أو قد يكون هناك سبب آخر وراء رغبتنا دائمًا في الحصول على مثيل جديد. إذا كان الأمر كذلك ، يوفر MvvmCross الطريقة Mvx.RegisterType<TInterface,TType>() ، والتي يمكن استخدامها لتسجيل التنفيذ بطريقة تؤدي إلى إنشاء مثيل جديد كلما كان ذلك مطلوبًا.

في حالة احتياجك إلى توفير عمليات تنفيذ ملموسة منفصلة لكل منصة ، يمكنك دائمًا القيام بذلك في المشاريع الخاصة بالمنصة:

 public class DroidPasswodGeneratorService : IPasswordGeneratorService { public string Generate(int length) { return "DroidPasswordGenerator"; } }

ويتم تسجيل تنفيذنا في فئة Setup.cs ضمن مشروع Droid:

 protected override void InitializePlatformServices() { base.InitializePlatformServices(); Mvx.LazyConstructAndRegisterSingleton<IPasswordGeneratorService, DroidPasswodGeneratorService>(); }

بعد تهيئة كود PCL ، سيقوم MvvmCross بالاتصال بـ InitializePlatformServices وتسجيل تطبيقات خدمة النظام الأساسي الخاصة بنا.

عندما نسجل تطبيقات فردية متعددة ، سيستخدم MvvmCross فقط التطبيق الذي تم تسجيله مؤخرًا. سيتم تجاهل جميع التسجيلات الأخرى.

أنشئ تطبيقات عبر الأنظمة الأساسية باستخدام Xamarin

في هذه المقالة ، رأيت كيف يتيح لك Xamarin مشاركة التعليمات البرمجية عبر منصات مختلفة مع الحفاظ على المظهر الأصلي وأداء التطبيقات.

يمنح MvvmCross طبقة أخرى من التجريد مما يعزز تجربة إنشاء تطبيقات عبر الأنظمة الأساسية باستخدام Xamarin. يوفر نمط MVVM طريقة لإنشاء التنقل وتدفقات تفاعل المستخدم الشائعة لجميع الأنظمة الأساسية ، مما يجعل مقدار التعليمات البرمجية الخاصة بالمنصة التي تحتاج إلى كتابتها مقصورة على طرق العرض وحدها.

آمل أن يكون هذا المقال قد أعطاك سببًا لإلقاء نظرة خاطفة على Xamarin وحفزك على إنشاء تطبيقك التالي عبر الأنظمة الأساسية باستخدامه.