Bagikan melalui

Arsitektur Xamarin.Mac

  • Artikel

Panduan ini menjelajahi Xamarin.Mac dan hubungannya dengan Objective-C pada tingkat rendah. Ini menjelaskan konsep seperti kompilasi, pemilih, registrars, peluncuran aplikasi, dan generator.

Gambaran Umum

Aplikasi Xamarin.Mac berjalan dalam lingkungan eksekusi Mono, dan menggunakan kompilator Xamarin untuk mengkompilasi ke Bahasa Perantara ( IL), yang kemudian dikompilasi just-in-Time ( JIT) ke kode asli pada run-time. Ini berjalan berdampingan Objective-C dengan Runtime. Kedua lingkungan runtime berjalan di atas kernel seperti UNIX, khususnya XNU, dan mengekspos berbagai API ke kode pengguna yang memungkinkan pengembang mengakses sistem asli atau terkelola yang mendasarinya.

Diagram di bawah ini menunjukkan gambaran umum dasar arsitektur ini:

Diagram showing a basic overview of the architecture

Kode asli dan terkelola

Saat mengembangkan untuk Xamarin, istilah kode asli dan terkelola sering digunakan. Kode terkelola adalah kode yang memiliki eksekusi yang dikelola oleh .NET Framework Common Language Runtime, atau dalam kasus Xamarin: Mono Runtime.

Kode asli adalah kode yang akan berjalan secara asli pada platform tertentu (misalnya, Objective-C atau bahkan kode yang dikompilasi AOT, pada chip ARM). Panduan ini mengeksplorasi bagaimana kode terkelola Anda dikompilasi ke kode asli, dan menjelaskan cara kerja aplikasi Xamarin.Mac, memanfaatkan API Mac Apple sepenuhnya melalui penggunaan pengikatan, sekaligus memiliki akses ke . BCL NET dan bahasa canggih seperti C#.

Persyaratan

Berikut ini diperlukan untuk mengembangkan aplikasi macOS dengan Xamarin.Mac:

  • Mac yang menjalankan macOS Sierra (10.12) atau lebih tinggi.
  • Versi terbaru Xcode (diinstal dari App Store)
  • Versi terbaru Xamarin.Mac dan Visual Studio untuk Mac

Menjalankan aplikasi Mac yang dibuat dengan Xamarin.Mac memiliki persyaratan sistem berikut:

  • Mac yang menjalankan Mac OS X 10.7 atau lebih tinggi.

Kompilasi

Ketika Anda mengkompilasi aplikasi platform Xamarin apa pun, kompilator Mono C# (atau F#) akan berjalan dan akan mengkompilasi kode C# dan F# Anda ke dalam Microsoft Intermediate Language (MSIL atau IL). Xamarin.Mac kemudian menggunakan kompilator Just in Time (JIT) pada runtime untuk mengkompilasi kode asli, memungkinkan eksekusi pada arsitektur yang benar sesuai kebutuhan.

Hal ini berbeda dengan Xamarin.iOS yang menggunakan kompilasi AOT. Saat menggunakan kompilator AOT, semua rakitan dan semua metode di dalamnya dikompilasi pada waktu build. Dengan JIT, kompilasi terjadi sesuai permintaan hanya untuk metode yang dijalankan.

Dengan aplikasi Xamarin.Mac, Mono biasanya disematkan ke dalam app bundle (dan disebut sebagai Embedded Mono). Saat menggunakan API Classic Xamarin.Mac, aplikasi dapat menggunakan System Mono, namun, ini tidak didukung di API Terpadu. Mono Sistem mengacu pada Mono yang telah diinstal dalam sistem operasi. Pada peluncuran aplikasi, aplikasi Xamarin.Mac akan menggunakan ini.

Pemilih

Dengan Xamarin, kami memiliki dua ekosistem terpisah, .NET dan Apple, yang perlu kita satukan agar tampak sesederhana mungkin, untuk memastikan bahwa tujuan akhir adalah pengalaman pengguna yang lancar. Kita telah melihat di bagian di atas bagaimana kedua runtime berkomunikasi, dan Anda mungkin sangat mendengar istilah 'pengikatan' yang memungkinkan API Mac asli digunakan di Xamarin. Pengikatan dijelaskan secara mendalam dalam Objective-C dokumentasi pengikatan, jadi untuk saat ini, mari kita jelajahi cara kerja Xamarin.Mac di bawah tenda.

Pertama, harus ada cara untuk mengekspos Objective-C C#, yang dilakukan melalui Pemilih. Pemilih adalah pesan yang dikirim ke objek atau kelas. Dengan Objective-C ini dilakukan melalui fungsi objc_msgSend . Untuk informasi selengkapnya tentang menggunakan Pemilih, lihat panduan Pemilih iOS.Objective-C Juga harus ada cara untuk mengekspos kode terkelola ke Objective-C, yang lebih rumit karena fakta yang Objective-C tidak tahu apa-apa tentang kode terkelola. Untuk mengatasi hal ini, kita menggunakan registrar. Ini dijelaskan secara lebih rinci di bagian berikutnya.

Registrar

Seperti disebutkan di atas, registrar adalah kode yang mengekspos kode terkelola ke Objective-C. Ini dilakukan dengan membuat daftar setiap kelas terkelola yang berasal dari NSObject:

  • Untuk semua kelas yang tidak membungkus kelas yang ada Objective-C , kelas tersebut membuat kelas baru Objective-C dengan Objective-C anggota yang mencerminkan semua anggota terkelola yang memiliki [Export] atribut.
  • Dalam implementasi untuk setiap anggota Objective–C, kode ditambahkan secara otomatis untuk memanggil anggota terkelola yang dicerminkan.

Kode pseudo di bawah ini menunjukkan contoh bagaimana hal ini dilakukan:

C# (kode terkelola):

class MyViewController : UIViewController{
    [Export ("myFunc")]
    public void MyFunc ()
    {
    }
 }

Objective-C (kode asli):

@interface MyViewController : UIViewController
 - (void)myFunc;
@end

@implementation MyViewController
- (void)myFunc {
    // Code to call the managed C# MyFunc method in MyViewController
}
@end

Kode terkelola dapat berisi atribut, [Register] dan , yang registrar digunakan untuk mengetahui bahwa objek perlu diekspos ke Objective-C[Export]. Atribut [Register] digunakan untuk menentukan nama kelas yang dihasilkan Objective-C jika nama yang dihasilkan default tidak cocok. Semua kelas yang berasal dari NSObject secara otomatis terdaftar dengan Objective-C. Atribut [Ekspor] yang diperlukan berisi string, yang merupakan pemilih yang digunakan di kelas yang dihasilkan Objective-C .

Ada dua jenis yang registrars digunakan dalam Xamarin.Mac – dinamis dan statis:

  • Dinamis registrars – Ini adalah default registrar untuk semua build Xamarin.Mac. Dinamis registrar melakukan pendaftaran semua jenis di assembly Anda pada runtime. Ini dilakukan dengan menggunakan fungsi yang disediakan oleh Objective-CAPI runtime. Oleh karena itu, dinamis registrar memiliki startup yang lebih lambat, tetapi waktu build yang lebih cepat. Fungsi asli (biasanya dalam C), yang disebut trampoline, digunakan sebagai implementasi metode saat menggunakan dinamis registrars. Mereka bervariasi di antara arsitektur yang berbeda.
  • Statis registrars – Statis registrar menghasilkan Objective-C kode selama build, yang kemudian dikompilasi ke dalam pustaka statis dan ditautkan ke dalam yang dapat dieksekusi. Ini memungkinkan startup yang lebih cepat, tetapi membutuhkan waktu lebih lama selama waktu build.

Peluncuran aplikasi

Logika startup Xamarin.Mac akan berbeda tergantung pada apakah disematkan atau sistem Mono digunakan. Untuk melihat kode dan langkah-langkah untuk peluncuran aplikasi Xamarin.Mac, lihat file header peluncuran di repositori publik xamarin-macios.

Generator

Xamarin.Mac berisi definisi untuk setiap Mac API. Anda dapat menelusuri salah satu hal ini di repositori github MaciOS. Definisi ini berisi antarmuka dengan atribut, serta metode dan properti yang diperlukan. Misalnya, kode berikut digunakan untuk menentukan NSBox di namespace AppKit. Perhatikan bahwa itu adalah antarmuka dengan sejumlah metode dan properti:

[BaseType (typeof (NSView))]
public interface NSBox {

    …

    [Export ("borderRect")]
    CGRect BorderRect { get; }

    [Export ("titleRect")]
    CGRect TitleRect { get; }

    [Export ("titleCell")]
    NSObject TitleCell { get; }

    [Export ("sizeToFit")]
    void SizeToFit ();

    [Export ("contentViewMargins")]
    CGSize ContentViewMargins { get; set; }

    [Export ("setFrameFromContentFrame:")]
    void SetFrameFromContentFrame (CGRect contentFrame);

    …

}

Generator, yang disebut bmac di Xamarin.Mac, mengambil file definisi ini dan menggunakan alat .NET untuk mengkompilasinya ke dalam rakitan sementara. Namun, rakitan sementara ini tidak dapat digunakan untuk memanggil Objective-C kode. Generator kemudian membaca rakitan sementara dan menghasilkan kode C# yang dapat digunakan saat runtime. Inilah sebabnya mengapa, misalnya, jika Anda menambahkan atribut acak ke definisi Anda .cs file, itu tidak akan muncul dalam kode yang dihasilkan. Generator tidak tahu tentang hal itu, dan karena itu bmac tidak tahu untuk mencarinya di perakitan sementara untuk menghasilkannya.

Setelah Xamarin.Mac.dll dibuat, packager, mmp, akan menggabungkan semua komponen bersama-sama.

Pada tingkat tinggi, ia mencapai ini dengan menjalankan tugas-tugas berikut:

  • Buat struktur bundel aplikasi.
  • Salin di rakitan terkelola Anda.
  • Jika penautan diaktifkan, jalankan linker terkelola untuk mengoptimalkan rakitan Anda dengan menghapus bagian yang tidak digunakan.
  • Buat aplikasi peluncur, tautkan dalam kode peluncur yang dibicarakan bersama dengan registrar kode jika dalam mode statis.

Ini kemudian dijalankan sebagai bagian dari proses build pengguna yang mengkompilasi kode pengguna ke dalam rakitan yang Xamarin.Mac.dll referensi dan berjalan mmp untuk menjadikannya paket

Untuk informasi lebih rinci tentang linker dan cara penggunaannya, lihat panduan iOS Linker .

Ringkasan

Panduan ini melihat kompilasi aplikasi Xamarin.Mac, dan menjelajahi Xamarin.Mac dan hubungannya dengan Objective-C.