Bagikan melalui

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 ingin 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 di XML, dan berdasarkan 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 sintaksis 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 XAML biasanya tidak diberlakukan dengan skema, seperti file XSD. Itu karena XAML dimaksudkan untuk diperluas, itulah arti "X" dalam akronim XAML. Setelah XAML diurai, elemen dan atribut yang Anda referensikan di XAML diharapkan ada di beberapa representasi kode cadangan, baik dalam jenis inti yang ditentukan oleh Windows Runtime, atau dalam jenis yang diperluas 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 layanan XAML dan pemetaan namespace layanan.

Mendeklarasikan objek

Programmer sering berpikir dalam hal objek dan anggota, sedangkan bahasa markup dikonsep sebagai elemen dan atribut. Dalam arti paling dasar, 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 buka dan tutup 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. Pengurai 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 sintaks 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 jarang terjadi 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 XAML lain, 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 adalah penggunaan elemen objek untuk mendeklarasikan objek Canvas :

<Canvas>
</Canvas>

Jika objek tidak berisi objek lain, Anda dapat mendeklarasikan elemen objek dengan menggunakan satu tag penutupan mandiri alih-alih pasangan pembuka/penutup: <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 berbicara tentang ini lebih banyak di bagian yang akan datang.

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, Ketebalan, 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 ...>

Perhatikan Beberapa struktur tidak dapat dideklarasikan 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 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 turunan) 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 di XAML dengan cara apa pun, dan hanya dapat diatur menggunakan kode. Biasanya ini adalah properti yang lebih sesuai untuk bekerja dengan kode di 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 sebenarnya Anda tidak. Lihat "Sintaks Koleksi" nanti dalam topik ini.

Mengatur properti dengan menggunakan sintaks atribut

Mengatur nilai atribut adalah cara umum untuk menetapkan nilai properti dalam bahasa markup, misalnya di XML atau HTML. Mengatur atribut XAML mirip dengan cara Anda menetapkan nilai atribut di XML. Nama atribut ditentukan pada titik mana pun 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 sampai pengurai 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.

<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 atas namanya. Namun, di XAML, titik dalam nama elemen mengidentifikasi elemen sebagai elemen properti, dengan properti yang diharapkan menjadi anggota objek dalam implementasi model objek cadangan. 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 mandiri.

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

<object>

<properti objek.>

propertyValueAsObjectElement

</properti objek.>

</object>

Contoh berikut menggunakan sintaks elemen properti untuk mengatur Fill of a Rectangle dengan elemen objek SolidColorBrush. (Dalam SolidColorBrush, Warna 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 Windows Runtime XAML 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 diwariskan 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 diwarisi dalam arti kosakata XAML. Peristiwa (seperti berbagai peristiwa UIElement ) juga diwariskan.

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 mendefinisikan properti, karena topik referensi tersebut dibagikan oleh semua jenis yang mungkin yang mewarisinya dari kelas dasar. Jika Anda menggunakan IntelliSense untuk XAML Visual Studio di editor XML, IntelliSense dan drop-downnya melakukan pekerjaan yang bagus untuk menyatukan warisan dan menyediakan daftar atribut akurat yang tersedia untuk diatur setelah Anda memulai dengan elemen objek untuk instans kelas.

Properti konten XAML

Beberapa jenis menentukan salah satu propertinya sehingga properti mengaktifkan sintaksis 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 berlapis.

Jika sintaksis 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 sintaksis konten XAML alih-alih sintaks elemen properti untuk mengatur nilai Border.Child objek tunggal dari Batas, seperti ini:

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

Jika properti yang dideklarasikan sebagai properti konten XAML adalah Jenis objek , atau adalah jenis String, maka sintaks konten XAML mendukung apa yang pada dasarnya teks dalam dalam model dokumen XML: string antara tag objek pembuka dan penutup. Misalnya, halaman properti Teks untuk TextBlock memperlihatkan sintaksis 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 "Nama" adalah nama properti 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 turunan. 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 tersebut. Kombinasi pemrosesan koleksi implisit dan sintaksis konten XAML sering terlihat dalam jenis yang digunakan untuk pengkomposisian 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

Pada awalnya mungkin 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 jenis koleksi pendukung untuk mengaktifkan sintaks ini. Biasanya ada properti cadangan seperti properti pengindeks atau Item yang mengacu pada 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 pengurai 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 melempar pengecualian penguraian XAML. Cukup gunakan sintaks koleksi implisit, dan Anda tidak akan melihat pengecualian tersebut.

Kapan 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 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 pengurai XAML harus membacanya: sebagai sekumpulan token string yang ditemui dalam urutan linier. Pengurai XAML harus menafsirkan token ini di bawah seperangkat aturan yang merupakan bagian dari definisi cara kerja XAML.

Mengatur nilai atribut adalah cara umum untuk menetapkan nilai properti dalam bahasa markup, misalnya di XML atau HTML. Dalam sintaks berikut, objectName adalah objek yang ingin Anda buat, 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 tersebut 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.

Perhatikan perancang 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 sintaksis yang dikenal sebagai properti terlampir. Mirip dengan sintaks elemen properti, sintaks properti yang dilampirkan berisi titik, dan titik memegang 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 mereka 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 tersebut dengan memberikan nilai atribut. Anda mengidentifikasi nilai enumerasi mana yang akan digunakan sebagai nilai properti dengan menggunakan nama nama konstanta yang tidak memenuhi syarat . 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 ditentukan. 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 properti sintaksis. 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 (,) antara setiap nama, dan tidak ada karakter spasi intervensi. Atribut flagwise tidak umum dalam kosakata XAML Runtime Windows, 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 CommandParameter buttonBase. Properti ini mendukung pola desain Model-View-ViewModel (MVVM) di mana antarmuka ICommand adalah kontrak tentang 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 menyertakan 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 akhir Anda 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 secara harfiah bukan kelas yang menentukan, 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 ditampilkan 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 dalam sintaks. 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 didefinisikan 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 keluar 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 lebih lanjut.
  • properti objek: properti objek 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:< object property="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 untuk mengisyaratkan apa pun tentang jenis delegasi dalam sintaks XAML. Jika Anda ingin mengetahui delegasi mana yang harus Anda terapkan untuk suatu peristiwa, itu ada di bagian Informasi peristiwa dari topik referensi untuk peristiwa tersebut, dalam 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 dapat menggunakan string apa pun yang tercantum di kolom Anggota dari daftar Anggota.
  • double, int, string, bool: Ini adalah jenis primitif yang diketahui 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 anda di .NET code-behind. Jika Anda memprogram menggunakan C++/CX, Anda akan menggunakan jenis primitif C++ tetapi Anda juga dapat mempertimbangkan jenis yang setara dengan 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 Komentar 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 memperhitungkan XAML Anda ke sumber daya yang dapat digunakan kembali yang berasal dari XAML ResourceDictionary. 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 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.