Panduan sintaks XAML

  • Artikel

Kami menjelaskan aturan sintaks XAML dan terminologi yang menjelaskan batasan atau pilihan yang tersedia untuk sintaks XAML. Anda akan menemukan topik ini berguna jika Anda baru menggunakan bahasa XAML, Anda menginginkan penyegaran pada terminologi atau bagian sintaksis, atau Anda ingin tahu tentang cara kerja bahasa XAML dan menginginkan lebih banyak latar belakang dan konteks.

XAML adalah XML

Extensible Application Markup Language (XAML) memiliki sintaks dasar yang dibangun pada XML, dan menurut definisi XAML yang valid harus XML yang valid. Tetapi XAML juga memiliki konsep sintaksis sendiri yang memperluas XML. Entitas XML tertentu mungkin valid dalam XML biasa, tetapi sintaks tersebut mungkin memiliki arti yang berbeda dan lebih lengkap sebagai XAML. Topik ini menjelaskan konsep sintaks XAML ini.

Kosakata XAML

Satu area di mana XAML berbeda dari sebagian besar penggunaan XML adalah bahwa XAML biasanya tidak diberlakukan dengan skema, seperti file XSD. Itu karena XAML dimaksudkan untuk diperluas, itulah yang dimaksudkan "X" dalam akronim XAML. Setelah XAML diurai, elemen dan atribut yang Anda referensikan di XAML diharapkan ada dalam beberapa representasi kode dukungan, baik dalam jenis inti yang ditentukan oleh Windows Runtime, atau dalam jenis yang memperluas atau didasarkan dari Windows Runtime. Dokumentasi SDK terkadang mengacu pada jenis yang sudah bawaan ke Windows Runtime dan dapat digunakan dalam XAML sebagai kosakata XAML untuk Windows Runtime. Microsoft Visual Studio membantu Anda menghasilkan markup yang valid dalam kosakata XAML ini. Visual Studio juga dapat menyertakan jenis kustom Anda untuk penggunaan XAML selama sumber jenis tersebut direferensikan dengan benar dalam proyek. Untuk informasi selengkapnya tentang XAML dan jenis kustom, lihat namespace XAML dan pemetaan namespace layanan.

Mendeklarasikan objek

Programmer sering berpikir dalam hal objek dan anggota, sedangkan bahasa markup dikonsepkan sebagai elemen dan atribut. Dalam arti yang paling mendasar, elemen yang Anda deklarasikan dalam markup XAML menjadi objek dalam representasi objek runtime dukungan. Untuk membuat objek run-time untuk aplikasi, Anda mendeklarasikan elemen XAML di markup XAML. Objek dibuat ketika Windows Runtime memuat XAML Anda.

File XAML selalu memiliki tepat satu elemen yang berfungsi sebagai akarnya, yang mendeklarasikan objek yang akan menjadi akar konseptual dari beberapa struktur pemrograman seperti halaman, atau grafik objek dari seluruh definisi run-time aplikasi.

Dalam hal sintaks XAML, ada tiga cara untuk mendeklarasikan objek dalam XAML:

  • Secara langsung, menggunakan sintaks elemen objek: Ini menggunakan tag pembuka dan penutup untuk membuat instans objek sebagai elemen bentuk XML. Anda dapat menggunakan sintaks ini untuk mendeklarasikan objek akar atau untuk membuat objek berlapis yang mengatur nilai properti.
  • Secara tidak langsung, menggunakan sintaks atribut: Ini menggunakan nilai string sebaris yang memiliki instruksi tentang cara membuat objek. Parser XAML menggunakan string ini untuk mengatur nilai properti ke nilai referensi yang baru dibuat. Dukungan untuk itu terbatas pada objek dan properti umum tertentu.
  • Menggunakan ekstensi markup.

Ini tidak berarti bahwa Anda selalu memiliki pilihan sintaksis apa pun untuk pembuatan objek dalam kosakata XAML. Beberapa objek hanya dapat dibuat dengan menggunakan sintaks elemen objek. Beberapa objek hanya dapat dibuat dengan awalnya diatur dalam atribut . Bahkan, objek yang dapat dibuat dengan elemen objek atau sintaks atribut relatif jarang dalam kosakata XAML. Bahkan jika kedua bentuk sintaksis dimungkinkan, salah satu sintaks akan lebih umum sebagai masalah gaya. Ada juga teknik yang dapat Anda gunakan di XAML untuk mereferensikan objek yang ada daripada membuat nilai baru. Objek yang ada mungkin didefinisikan baik di area lain dari XAML, atau mungkin ada secara implisit melalui beberapa perilaku platform dan aplikasi atau model pemrogramannya.

Mendeklarasikan objek dengan menggunakan sintaks elemen objek

Untuk mendeklarasikan objek dengan sintaks elemen objek, Anda menulis tag seperti ini: <objectName> </objectName>, di mana objectName adalah nama jenis untuk objek yang ingin Anda buat instansnya. Berikut penggunaan elemen objek untuk mendeklarasikan objek Canvas :

<Canvas>
</Canvas>

Jika objek tidak berisi objek lain, Anda dapat mendeklarasikan elemen objek dengan menggunakan satu tag penutup mandiri alih-alih pasangan buka/tutup: <Canvas />

Kontainer

Banyak objek yang digunakan sebagai elemen UI, seperti Canvas, dapat berisi objek lain. Ini kadang-kadang disebut sebagai kontainer. Contoh berikut menunjukkan kontainer Canvas yang berisi satu elemen, Persegi Panjang.

<Canvas>
  <Rectangle />
</Canvas>

Mendeklarasikan objek dengan menggunakan sintaks atribut

Karena perilaku ini terkait dengan pengaturan properti, kita akan membahas lebih lanjut tentang ini di bagian mendatang.

Teks inisialisasi

Untuk beberapa objek, Anda dapat mendeklarasikan nilai baru menggunakan teks dalam yang digunakan sebagai nilai inisialisasi untuk konstruksi. Dalam XAML, teknik dan sintaks ini disebut teks inisialisasi. Secara konseptual, teks inisialisasi mirip dengan memanggil konstruktor yang memiliki parameter. Teks inisialisasi berguna untuk mengatur nilai awal struktur tertentu.

Anda sering menggunakan sintaks elemen objek dengan teks inisialisasi jika Anda menginginkan nilai struktur dengan x:Key, sehingga dapat ada di ResourceDictionary. Anda mungkin melakukan ini jika Anda berbagi nilai struktur tersebut di antara beberapa properti target. Untuk beberapa struktur, Anda tidak dapat menggunakan sintaks atribut untuk mengatur nilai struktur: teks inisialisasi adalah satu-satunya cara untuk menghasilkan sumber daya CornerRadius, Tebal, GridLength , atau Warna yang berguna dan dapat dibagikan.

Contoh singkatan ini menggunakan teks inisialisasi untuk menentukan nilai ketebalan, dalam hal ini menentukan nilai yang mengatur Kiri dan Kanan ke 20, dan Atas dan Bawah ke 10. Contoh ini menunjukkan Ketebalan yang dibuat sebagai sumber daya kunci, lalu referensi ke sumber daya tersebut. Untuk informasi selengkapnya tentang teks inisialisasi Ketebalan , lihat Ketebalan.

<UserControl ...>
  <UserControl.Resources>
    <Thickness x:Key="TwentyTenThickness">20,10</Thickness>
    ....
  </UserControl.Resources>
  ...
  <Grid Margin="{StaticResource TwentyTenThickness}">
  ...
  </Grid>
</UserControl ...>

Catatan Beberapa struktur tidak dapat dinyatakan sebagai elemen objek. Teks inisialisasi tidak didukung dan tidak dapat digunakan sebagai sumber daya. Anda harus menggunakan sintaks atribut untuk mengatur properti ke nilai-nilai ini di XAML. Jenis-jenis ini adalah: Durasi, RepeatBehavior, Point, Rect dan Size.

Mengatur properti

Anda dapat mengatur properti pada objek yang Anda deklarasikan dengan menggunakan sintaks elemen objek. Ada beberapa cara untuk mengatur properti di XAML:

  • Dengan menggunakan sintaks atribut.
  • Dengan menggunakan sintaks elemen properti.
  • Dengan menggunakan sintaks elemen di mana konten (teks dalam atau elemen anak) mengatur properti konten XAML objek.
  • Dengan menggunakan sintaks koleksi (yang biasanya merupakan sintaks koleksi implisit).

Seperti halnya deklarasi objek, daftar ini tidak menyiratkan bahwa properti apa pun dapat diatur dengan masing-masing teknik. Beberapa properti hanya mendukung salah satu teknik. Beberapa properti mendukung lebih dari satu bentuk; misalnya, ada properti yang dapat menggunakan sintaks elemen properti, atau sintaks atribut. Apa yang mungkin tergantung pada properti dan pada jenis objek yang digunakan properti. Dalam referensi Windows Runtime API, Anda akan melihat penggunaan XAML yang dapat Anda gunakan di bagian Sintaks . Terkadang ada penggunaan alternatif yang akan berfungsi tetapi akan lebih verbose. Penggunaan verbose tersebut tidak selalu ditampilkan karena kami mencoba menunjukkan kepada Anda praktik terbaik atau skenario dunia nyata untuk menggunakan properti tersebut di XAML. Panduan untuk sintaks XAML disediakan di bagian Penggunaan XAML halaman referensi untuk properti yang dapat diatur dalam XAML.

Beberapa properti pada objek tidak dapat diatur dalam XAML dengan cara apa pun, dan hanya dapat diatur menggunakan kode. Biasanya ini adalah properti yang lebih tepat untuk dikerjakan di kode-belakang, bukan di XAML.

Properti baca-saja tidak dapat diatur dalam XAML. Bahkan dalam kode, jenis pemilik harus mendukung beberapa cara lain untuk mengaturnya, seperti kelebihan beban konstruktor, metode pembantu, atau dukungan properti terhitung. Properti terhitung bergantung pada nilai properti lain yang dapat diatur ditambah terkadang peristiwa dengan penanganan bawaan; fitur-fitur ini tersedia dalam sistem properti dependensi. Untuk informasi selengkapnya tentang bagaimana properti dependensi berguna untuk dukungan properti terhitung, lihat Gambaran umum properti dependensi.

Sintaks koleksi di XAML memberikan tampilan bahwa Anda mengatur properti baca-saja, tetapi pada kenyataannya Anda tidak. Lihat "Sintaks Koleksi" nanti dalam topik ini.

Mengatur properti dengan menggunakan sintaks atribut

Mengatur nilai atribut adalah sarana umum di mana Anda menetapkan nilai properti dalam bahasa markup, misalnya di XML atau HTML. Mengatur atribut XAML mirip dengan cara Anda mengatur nilai atribut di XML. Nama atribut ditentukan kapan saja dalam tag mengikuti nama elemen, dipisahkan dari nama elemen dengan setidaknya satu spasi kosong. Nama atribut diikuti dengan tanda sama dengan. Nilai atribut terkandung dalam sepasang tanda kutip. Tanda kutip dapat berupa tanda kutip ganda atau tanda kutip tunggal selama cocok dan mengapit nilai. Nilai atribut itu sendiri harus dapat diekspresikan sebagai string. String sering berisi angka, tetapi untuk XAML, semua nilai atribut adalah nilai string hingga parser XAML terlibat dan melakukan beberapa konversi nilai dasar.

Contoh ini menggunakan sintaks atribut untuk empat atribut untuk mengatur properti Nama, Lebar, Tinggi, dan Isian objek Persegi Panjang.

<Rectangle Name="rectangle1" Width="100" Height="100" Fill="Blue" />

Mengatur properti dengan menggunakan sintaks elemen properti

Banyak properti objek dapat diatur dengan menggunakan sintaks elemen properti. Elemen properti terlihat seperti ini: <properti>objek..

Untuk menggunakan sintaks elemen properti, Anda membuat elemen properti XAML untuk properti yang ingin Anda atur. Dalam XML standar, elemen ini hanya akan dianggap sebagai elemen yang memiliki titik dalam namanya. Namun, dalam XAML, titik dalam nama elemen mengidentifikasi elemen sebagai elemen properti, dengan properti diharapkan menjadi anggota objek dalam implementasi model objek yang mendukung. Untuk menggunakan sintaks elemen properti, harus dimungkinkan untuk menentukan elemen objek untuk "mengisi" tag elemen properti. Elemen properti akan selalu memiliki beberapa konten (elemen tunggal, beberapa elemen, atau teks dalam); tidak ada gunanya memiliki elemen properti penutupan sendiri.

Dalam tata bahasa berikut, properti adalah nama properti yang ingin Anda atur dan propertyValueAsObjectElement adalah elemen objek tunggal, yang diharapkan memenuhi persyaratan jenis nilai properti.

<object>

<Objek.Properti>

propertyValueAsObjectElement

</Objek.Properti>

</object>

Contoh berikut menggunakan sintaks elemen properti untuk mengatur IsianPersegi panjang dengan elemen objek SolidColorBrush . (Dalam SolidColorBrush, Color diatur sebagai atribut.) Hasil yang diurai dari XAML ini identik dengan contoh XAML sebelumnya yang mengatur Isi menggunakan sintaks atribut.

<Rectangle
  Name="rectangle1"
  Width="100" 
  Height="100"
> 
  <Rectangle.Fill> 
    <SolidColorBrush Color="Blue"/> 
  </Rectangle.Fill>
</Rectangle>

Kosakata XAML dan pemrograman berorientasi objek

Properti dan peristiwa saat muncul sebagai anggota XAML dari jenis XAML Windows Runtime sering diwarisi dari jenis dasar. Pertimbangkan contoh ini: <Button Background="Blue" .../>. Properti Latar Belakang bukan properti yang segera dideklarasikan pada kelas Tombol . Sebaliknya, Latar Belakang diwarisi dari kelas Kontrol dasar. Bahkan, jika Anda melihat topik referensi untuk Tombol , Anda akan melihat bahwa daftar anggota berisi setidaknya satu anggota yang diwariskan dari setiap rantai kelas dasar berturut-turut: ButtonBase, Control, FrameworkElement, UIElement, DependencyObject. Dalam daftar Properti , semua properti baca-tulis dan properti koleksi diwariskan dalam arti kosakata XAML. Peristiwa (seperti berbagai peristiwa UIElement ) juga diwarisi.

Jika Anda menggunakan referensi Windows Runtime untuk panduan XAML, nama elemen yang ditampilkan dalam sintaks atau bahkan dalam contoh kode terkadang untuk jenis yang awalnya menentukan properti, karena topik referensi tersebut dibagikan oleh semua jenis yang mungkin mewarisinya dari kelas dasar. Jika Anda menggunakan IntelliSense visual Studio untuk XAML di editor XML, IntelliSense dan drop-downnya melakukan pekerjaan yang bagus untuk menyatukan pewarisan dan menyediakan daftar atribut akurat yang tersedia untuk pengaturan setelah Anda mulai dengan elemen objek untuk instans kelas.

Properti konten XAML

Beberapa jenis menentukan salah satu propertinya sehingga properti mengaktifkan sintaks konten XAML. Untuk properti konten XAML dari jenis, Anda dapat menghilangkan elemen properti untuk properti tersebut saat menentukannya di XAML. Atau, Anda dapat mengatur properti ke nilai teks dalam dengan menyediakan teks dalam tersebut langsung dalam tag elemen objek jenis pemilik. Properti konten XAML mendukung sintaks markup langsung untuk properti tersebut dan membuat XAML lebih mudah dibaca manusia dengan mengurangi bersarang.

Jika sintaks konten XAML tersedia, sintaks tersebut akan ditampilkan di bagian "XAML" sintaks untuk properti tersebut dalam dokumentasi referensi Windows Runtime. Misalnya, halaman properti Anak untuk Batas memperlihatkan sintaks konten XAML alih-alih sintaks elemen properti untuk mengatur nilai Border.Child objek tunggal dari Batas, seperti ini:

<Border>
  <Button .../>
</Border>

Jika properti yang dinyatakan sebagai properti konten XAML adalah jenis Objek , atau adalah String jenis, maka sintaks konten XAML mendukung apa yang pada dasarnya teks dalam model dokumen XML: string antara tag objek pembuka dan penutup. Misalnya, halaman properti Teks untuk TextBlock memperlihatkan sintaks konten XAML yang memiliki nilai teks dalam untuk mengatur Teks, tetapi string "Teks" tidak pernah muncul di markup. Berikut adalah contoh penggunaan:

<TextBlock>Hello!</TextBlock>

Jika properti konten XAML ada untuk kelas, itu ditunjukkan dalam topik referensi untuk kelas , di bagian "Atribut". Cari nilai ContentPropertyAttribute. Atribut ini menggunakan bidang bernama "Name". Nilai "Name" adalah nama properti dari kelas tersebut yang merupakan properti konten XAML. Misalnya, pada halaman referensi Batas , Anda akan melihat ini: ContentProperty("Name=Child").

Salah satu aturan sintaks XAML penting yang harus kami sebutkan adalah Anda tidak dapat mengintermix properti konten XAML dan elemen properti lain yang Anda tetapkan pada elemen . Properti konten XAML harus diatur sepenuhnya sebelum elemen properti apa pun, atau sepenuhnya setelahnya. Misalnya, ini adalah XAML yang tidak valid:

<StackPanel>
  <Button>This example</Button>
  <StackPanel.Resources>
    <SolidColorBrush x:Key="BlueBrush" Color="Blue"/>
  </StackPanel.Resources>
  <Button>... is illegal XAML</Button>
</StackPanel>

Sintaksis kumpulan

Semua sintaks yang ditampilkan sejauh ini mengatur properti ke objek tunggal. Tetapi banyak skenario UI mengharuskan elemen induk tertentu dapat memiliki beberapa elemen anak. Misalnya, UI untuk formulir input memerlukan beberapa elemen kotak teks, beberapa label, dan mungkin tombol "Kirim". Namun, jika Anda menggunakan model objek pemrograman untuk mengakses beberapa elemen ini, mereka biasanya akan menjadi item dalam satu properti koleksi, daripada setiap item menjadi nilai properti yang berbeda. XAML mendukung beberapa elemen anak serta mendukung model pengumpulan pendukung yang khas dengan memperlakukan properti yang menggunakan jenis koleksi sebagai implisit, dan melakukan penanganan khusus untuk setiap elemen anak dari jenis koleksi.

Banyak properti koleksi juga diidentifikasi sebagai properti konten XAML untuk kelas . Kombinasi pemrosesan koleksi implisit dan sintaks konten XAML sering terlihat dalam jenis yang digunakan untuk komposit kontrol, seperti panel, tampilan, atau kontrol item. Misalnya, contoh berikut menunjukkan XAML paling sederhana untuk menyusun dua elemen UI serekan dalam StackPanel.

<StackPanel>
  <TextBlock>Hello</TextBlock>
  <TextBlock>World</TextBlock>
</StackPanel>

Mekanisme sintaks pengumpulan XAML

Mungkin pada awalnya muncul bahwa XAML mengaktifkan "set" properti koleksi baca-saja. Pada kenyataannya, apa yang XAML aktifkan di sini adalah menambahkan item ke koleksi yang ada. Bahasa XAML dan prosesor XAML yang menerapkan dukungan XAML mengandalkan konvensi dalam mendukung jenis koleksi untuk mengaktifkan sintaks ini. Biasanya ada properti cadangan seperti properti pengindeks atau Item yang merujuk ke item tertentu dari koleksi. Umumnya, properti tersebut tidak eksplisit dalam sintaks XAML. Untuk koleksi, mekanisme yang mendasar untuk penguraian XAML bukanlah properti, tetapi metode: khususnya, metode Tambahkan dalam banyak kasus. Ketika prosesor XAML menemukan satu atau beberapa elemen objek dalam sintaks koleksi XAML, setiap objek tersebut pertama kali dibuat dari elemen, maka setiap objek baru ditambahkan untuk koleksi yang berisi dengan memanggil metode Tambahkan koleksi.

Ketika parser XAML menambahkan item ke koleksi, itu adalah logika dari metode Tambahkan yang menentukan apakah elemen XAML tertentu adalah anak item yang diizinkan dari objek koleksi. Banyak jenis koleksi dititik dengan kuat oleh implementasi backing, yang berarti bahwa parameter input Add mengharapkan bahwa apa pun yang diteruskan harus merupakan jenis yang cocok dengan jenis Tambahkan parameter.

Untuk properti koleksi, berhati-hatilah ketika Anda mencoba menentukan koleksi secara eksplisit sebagai elemen objek. Parser XAML akan membuat objek baru setiap kali menemukan elemen objek. Jika properti koleksi yang coba Anda gunakan bersifat baca-saja, ini dapat melemparkan pengecualian penguraian XAML. Cukup gunakan sintaks pengumpulan implisit, dan Anda tidak akan melihat pengecualian tersebut.

Kapan harus menggunakan sintaks atribut atau elemen properti

Semua properti yang mendukung diatur dalam XAML akan mendukung sintaks atribut atau elemen properti untuk pengaturan nilai langsung, tetapi berpotensi tidak akan mendukung sintaksis secara bergantian. Beberapa properti mendukung sintaksis, dan beberapa properti mendukung opsi sintaks tambahan seperti properti konten XAML. Jenis sintaks XAML yang didukung oleh properti bergantung pada jenis objek yang digunakan properti sebagai jenis propertinya. Jika jenis properti adalah jenis primitif, seperti ganda (float atau desimal), bilangan bulat, Boolean, atau string, properti selalu mendukung sintaks atribut.

Anda juga dapat menggunakan sintaks atribut untuk mengatur properti jika jenis objek yang Anda gunakan untuk mengatur properti tersebut dapat dibuat dengan memproses string. Untuk primitif, ini selalu terjadi, konversi jenis dibangun ke pengurai. Namun, jenis objek tertentu lainnya juga dapat dibuat dengan menggunakan string yang ditentukan sebagai nilai atribut, bukan elemen objek dalam elemen properti. Agar ini berfungsi, harus ada konversi jenis yang mendasar, didukung baik oleh properti tertentu atau didukung secara umum untuk semua nilai yang menggunakan jenis properti tersebut. Nilai string atribut digunakan untuk mengatur properti yang penting untuk inisialisasi nilai objek baru. Berpotensi, pengonversi jenis tertentu juga dapat membuat subkelas yang berbeda dari jenis properti umum, tergantung pada caranya memproses informasi secara unik dalam string. Jenis objek yang mendukung perilaku ini akan memiliki tata bahasa khusus yang tercantum di bagian sintaks dokumentasi referensi. Sebagai contoh, sintaks XAML untuk Brush menunjukkan bagaimana sintaks atribut dapat digunakan untuk membuat nilai SolidColorBrush baru untuk properti jenis Brush apa pun (dan ada banyak properti Brush di Windows Runtime XAML).

Logika dan aturan penguraian XAML

Kadang-kadang informatif untuk membaca XAML dengan cara yang sama dengan bagaimana parser XAML harus membacanya: sebagai sekumpulan token string yang ditemui dalam urutan linier. Parser XAML harus menafsirkan token ini di bawah seperangkat aturan yang merupakan bagian dari definisi cara kerja XAML.

Mengatur nilai atribut adalah cara umum di mana Anda menetapkan nilai properti dalam bahasa markup, misalnya di XML atau HTML. Dalam sintaks berikut, objectName adalah objek yang ingin Anda instanskan, propertyName adalah nama properti yang ingin Anda atur pada objek tersebut, dan propertyValue adalah nilai yang akan diatur.

<objectName propertyName="propertyValue" .../>

-or-

<objectName propertyName="propertyValue">

...<!--element children -->

</objectName>

Salah satu sintaks memungkinkan Anda untuk mendeklarasikan objek dan mengatur properti pada objek tersebut. Meskipun contoh pertama adalah elemen tunggal dalam markup, sebenarnya ada langkah-langkah diskrit di sini sehubungan dengan bagaimana prosesor XAML mengurai markup ini.

Pertama, keberadaan elemen objek menunjukkan bahwa objek objectName baru harus dibuat. Hanya setelah instans seperti itu ada, properti instans propertyName dapat diatur di dalamnya.

Aturan lain dari XAML adalah bahwa atribut elemen harus dapat diatur dalam urutan apa pun. Misalnya, tidak ada perbedaan antara <Rectangle Height="50" Width="100" /> dan <Rectangle Width="100" Height="50" />. Urutan mana yang Anda gunakan adalah masalah gaya.

Catatan Desainer XAML sering mempromosikan konvensi pemesanan jika Anda menggunakan permukaan desain selain editor XML, tetapi Anda dapat dengan bebas mengedit XAML tersebut nanti, untuk menyusun ulang atribut atau memperkenalkan yang baru.

Properti terlampir

XAML memperluas XML dengan menambahkan elemen sintaks yang dikenal sebagai properti terlampir. Mirip dengan sintaks elemen properti, sintaks properti yang terlampir berisi titik, dan titik memiliki arti khusus untuk penguraian XAML. Secara khusus, titik memisahkan penyedia properti terlampir, dan nama properti.

Di XAML, Anda mengatur properti terlampir dengan menggunakan sintaks AttachedPropertyProvider. PropertyName Berikut adalah contoh bagaimana Anda dapat mengatur properti terlampir Canvas.Left di XAML:

<Canvas>
  <Button Canvas.Left="50">Hello</Button>
</Canvas>

Anda dapat mengatur properti terlampir pada elemen yang tidak memiliki properti nama tersebut dalam jenis backing, dan dengan cara itu properti tersebut berfungsi agak seperti properti global, atau atribut yang ditentukan oleh namespace XML yang berbeda seperti atribut xml:space .

Di Windows Runtime XAML Anda akan melihat properti terlampir yang mendukung skenario ini:

Untuk informasi selengkapnya, lihat Gambaran umum properti terlampir.

Nilai harfiah "{"

Karena simbol kurung kurawal pembuka { adalah pembukaan urutan ekstensi markup, Anda menggunakan urutan escape untuk menentukan nilai string literal yang dimulai dengan "{". Urutan escape adalah "{}". Misalnya, untuk menentukan nilai string yang merupakan kurung kurawal pembuka tunggal, tentukan nilai atribut sebagai "{}{". Anda juga dapat menggunakan tanda kutip alternatif (misalnya, ' dalam nilai atribut yang dibatasi oleh "") untuk memberikan nilai "{" sebagai string.

Catatan "\}" juga berfungsi jika berada di dalam atribut yang dikutip.  

Nilai enumerasi

Banyak properti di WINDOWS Runtime API menggunakan enumerasi sebagai nilai. Jika anggota adalah properti baca-tulis, Anda dapat mengatur properti seperti itu dengan memberikan nilai atribut. Anda mengidentifikasi nilai enumerasi mana yang akan digunakan sebagai nilai properti dengan menggunakan nama yang tidak memenuhi syarat dari nama konstanta . Misalnya berikut cara mengatur UIElement.Visibility di XAML: <Button Visibility="Visible"/>. Di sini "Terlihat" sebagai string langsung dipetakan ke konstanta bernama enumerasi Visibilitas , Terlihat.

  • Jangan gunakan formulir yang memenuhi syarat, formulir tidak akan berfungsi. Misalnya, ini adalah XAML yang tidak valid: <Button Visibility="Visibility.Visible"/>.
  • Jangan gunakan nilai konstanta. Dengan kata lain, jangan mengandalkan nilai bilangan bulat enumerasi yang ada di sana secara eksplisit atau implisit tergantung pada bagaimana enumerasi didefinisikan. Meskipun mungkin tampak berfungsi, ini adalah praktik yang buruk baik di XAML atau dalam kode karena Anda mengandalkan apa yang bisa menjadi detail implementasi sementara. Misalnya, jangan lakukan ini: <Button Visibility="1"/>.

Catatan Dalam topik referensi untuk API yang menggunakan XAML dan menggunakan enumerasi, klik tautan ke jenis enumerasi di bagian Nilai propertidari Sintaks. Ini menautkan ke halaman enumerasi tempat Anda dapat menemukan konstanta bernama untuk enumerasi tersebut.

Enumerasi dapat berbendera, yang berarti bahwa mereka dikaitkan dengan FlagsAttribute. Jika Anda perlu menentukan kombinasi nilai untuk enumerasi berbendera sebagai nilai atribut XAML, gunakan nama setiap konstanta enumerasi, dengan koma (,) di antara setiap nama, dan tanpa karakter spasi intervensi. Atribut flagwise tidak umum dalam kosakata XAML Windows Runtime, tetapi ManipulationModes adalah contoh di mana mengatur nilai enumerasi berbendera di XAML didukung.

Antarmuka di XAML

Dalam kasus yang jarang terjadi, Anda akan melihat sintaks XAML di mana jenis properti adalah antarmuka. Dalam sistem jenis XAML, jenis yang mengimplementasikan antarmuka tersebut dapat diterima sebagai nilai saat diurai. Harus ada instans yang dibuat dari jenis seperti itu yang tersedia untuk berfungsi sebagai nilai. Anda akan melihat antarmuka yang digunakan sebagai jenis dalam sintaks XAML untuk properti Command dan CommandParameterdari ButtonBase. Properti ini mendukung pola desain Model-View-ViewModel (MVVM) di mana antarmuka ICommand adalah kontrak untuk bagaimana tampilan dan model berinteraksi.

Konvensi tempat penampung XAML dalam referensi Windows Runtime

Jika Anda telah memeriksa salah satu bagian Sintaks topik referensi untuk WINDOWS Runtime API yang dapat menggunakan XAML, Anda mungkin telah melihat bahwa sintaksnya mencakup beberapa tempat penampung. Sintaks XAML berbeda dari sintaks C#, ekstensi komponen Microsoft Visual Basic atau Visual C++ (C++/CX) karena sintaks XAML adalah sintaks penggunaan. Ini mengisyaratkan penggunaan Anda pada akhirnya dalam file XAML Anda sendiri, tetapi tanpa terlalu preskriptif tentang nilai yang dapat Anda gunakan. Jadi biasanya penggunaan menjelaskan jenis tata bahasa yang mencampur literal dan tempat penampung, dan mendefinisikan beberapa tempat penampung di bagian Nilai XAML .

Saat Anda melihat nama jenis / nama elemen dalam sintaks XAML untuk properti, nama yang ditampilkan adalah untuk jenis yang awalnya menentukan properti . Tetapi Windows Runtime XAML mendukung model pewarisan kelas untuk kelas berbasis DependencyObject. Jadi Anda sering dapat menggunakan atribut pada kelas yang bukan secara harfiah yang menentukan kelas, tetapi sebaliknya berasal dari kelas yang pertama kali menentukan properti/atribut. Misalnya, Anda dapat mengatur Visibilitas sebagai atribut pada kelas turunan UIElement apa pun menggunakan pewarisan mendalam. Misalnya: <Button Visibility="Visible" />. Jadi jangan mengambil nama elemen yang ditunjukkan dalam sintaks penggunaan XAML apa pun secara harfiah; sintaks mungkin layak untuk elemen yang mewakili kelas tersebut, dan juga elemen yang mewakili kelas turunan. Dalam kasus di mana jarang atau tidak mungkin untuk jenis yang ditunjukkan sebagai elemen yang menentukan berada dalam penggunaan dunia nyata, nama jenis tersebut sengaja diturunkan huruf kecilnya dalam sintaksis. Misalnya, sintaks yang Anda lihat untuk UIElement.Visibility adalah :

<uiElement Visibility="Visible"/>
-or-
<uiElement Visibility="Collapsed"/>

Banyak bagian sintaks XAML menyertakan tempat penampung dalam "Penggunaan" yang kemudian ditentukan di bagian Nilai XAML yang berada langsung di bawah bagian Sintaks .

Bagian penggunaan XAML juga menggunakan berbagai tempat penampung umum. Tempat penampung ini tidak ditentukan ulang setiap kali dalam Nilai XAML, karena Anda akan menebak atau akhirnya mempelajari apa yang diwakilinya. Kami pikir sebagian besar pembaca akan bosan melihatnya dalam Nilai XAML lagi dan lagi sehingga kami meninggalkannya dari definisi. Sebagai referensi, berikut adalah daftar beberapa tempat penampung ini dan apa artinya secara umum:

  • objek: secara teoritis nilai objek apa pun, tetapi seringkali praktis terbatas pada jenis objek tertentu seperti pilihan string atau objek, dan Anda harus memeriksa Komentar pada halaman referensi untuk informasi selengkapnya.
  • propertiobjek: propertiobjek dalam kombinasi digunakan untuk kasus di mana sintaks yang ditampilkan adalah sintaks untuk jenis yang dapat digunakan sebagai nilai atribut untuk banyak properti. Misalnya, Penggunaan Atribut Xaml yang ditampilkan untuk Brush meliputi: <objectproperty="predefinedColorName"/>
  • eventhandler: Ini muncul sebagai nilai atribut untuk setiap sintaks XAML yang ditampilkan untuk atribut peristiwa. Apa yang Anda berikan di sini adalah nama fungsi untuk fungsi penanganan aktivitas. Fungsi tersebut harus didefinisikan dalam code-behind untuk halaman XAML. Pada tingkat pemrograman, fungsi tersebut harus cocok dengan tanda tangan delegasi peristiwa yang Anda tangani, atau kode aplikasi Anda tidak akan dikompilasi. Tetapi itu benar-benar pertimbangan pemrograman, bukan pertimbangan XAML, jadi kami tidak mencoba mengisyaratkan apa pun tentang jenis delegasi dalam sintaks XAML. Jika Anda ingin mengetahui delegasi mana yang harus Anda terapkan untuk suatu peristiwa, yang ada di bagian Informasi peristiwa dari topik referensi untuk peristiwa tersebut, di baris tabel yang berlabel Delegasi.
  • enumMemberName: ditampilkan dalam sintaks atribut untuk semua enumerasi. Ada tempat penampung serupa untuk properti yang menggunakan nilai enumerasi, tetapi biasanya mengawali tempat penampung dengan petunjuk nama enumerasi. Misalnya, sintaks yang ditampilkan untuk FrameworkElement.FlowDirection adalah <frameworkElementFlowDirection="flowDirectionMemberName"/>. Jika Anda berada di salah satu halaman referensi properti tersebut, klik tautan ke jenis enumerasi yang muncul di bagian Nilai Properti , di samping teks Jenis:. Untuk nilai atribut properti yang menggunakan enumerasi tersebut, Anda bisa menggunakan string apa pun yang tercantum di kolom Anggota dari daftar Anggota .
  • double, int, string, bool: Ini adalah jenis primitif yang dikenal oleh bahasa XAML. Jika Anda memprogram menggunakan C# atau Visual Basic, jenis ini diproyeksikan ke jenis setara Microsoft .NET seperti Double, Int32, String dan Boolean, dan Anda dapat menggunakan anggota apa pun pada jenis .NET tersebut saat Anda bekerja dengan nilai yang ditentukan XAML di kode .NET-behind. Jika Anda memprogram menggunakan C++/CX, Anda akan menggunakan jenis primitif C++ tetapi Anda juga dapat mempertimbangkan ini setara dengan jenis yang ditentukan oleh namespace platform , misalnya Platform::String. Terkadang akan ada pembatasan nilai tambahan untuk properti tertentu. Tetapi Anda biasanya akan melihat ini dicatat di bagian Nilai properti atau bagian Keterangan dan bukan di bagian XAML, karena pembatasan tersebut berlaku untuk penggunaan kode dan penggunaan XAML.

Tips dan trik, catatan tentang gaya

  • Ekstensi markup secara umum dijelaskan dalam gambaran umum XAML utama. Tetapi ekstensi markup yang paling berdampak pada panduan yang diberikan dalam topik ini adalah ekstensi markup StaticResource (dan ThemeResource terkait). Fungsi ekstensi markup StaticResource adalah memungkinkan faktor XAML Anda menjadi sumber daya yang dapat digunakan kembali yang berasal dari ResourceDictionary XAML. Anda hampir selalu menentukan templat kontrol dan gaya terkait dalam ResourceDictionary. Anda sering menentukan bagian yang lebih kecil dari definisi templat kontrol atau gaya khusus aplikasi dalam ResourceDictionary juga, misalnya SolidColorBrush untuk warna yang digunakan aplikasi Anda lebih dari sekali untuk berbagai bagian UI. Dengan menggunakan StaticResource, properti apa pun yang jika tidak memerlukan penggunaan elemen properti untuk diatur sekarang dapat diatur dalam sintaks atribut. Tetapi manfaat memperhitungkan XAML untuk digunakan kembali melampaui hanya menyederhanakan sintaks tingkat halaman. Untuk informasi selengkapnya, lihat Referensi sumber daya ResourceDictionary dan XAML.
  • Anda akan melihat beberapa konvensi berbeda tentang bagaimana spasi putih dan umpan baris diterapkan dalam contoh XAML. Secara khusus, ada berbagai konvensi tentang cara memecah elemen objek yang memiliki banyak atribut berbeda yang ditetapkan. Itu hanya masalah gaya. Editor XML Visual Studio menerapkan beberapa aturan gaya default saat Anda mengedit XAML, tetapi Anda dapat mengubahnya di pengaturan. Ada sejumlah kecil kasus di mana ruang kosong dalam file XAML dianggap signifikan; untuk informasi selengkapnya lihat XAML dan spasi kosong.