Panduan sintaks XAML

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 bagaimana bahasa XAML bekerja dan menginginkan lebih banyak latar belakang dan konteks.

XAML adalah XML.

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

Kosakata XAML

Salah satu area di mana XAML berbeda dari kebanyakan penggunaan XML adalah bahwa XAML biasanya tidak diberlakukan dengan skema, seperti file XSD. Itu karena XAML dimaksudkan untuk dapat diperluas, itulah arti "X" dalam akronim XAML. Setelah XAML diurai, elemen dan atribut yang Anda rujuk di XAML diharapkan ada di beberapa representasi kode pendukung, baik dalam jenis inti yang ditentukan oleh runtime Windows, atau dalam jenis yang memanjang atau didasarkan pada runtime Windows. Dokumentasi SDK terkadang mengacu pada jenis yang sudah terpasang ke runtime Windows dan dapat digunakan di XAML sebagai kosakata XAML untuk runtime Windows. 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 info selengkapnya tentang XAML dan tipe kustom, lihat ruang nama XAML dan pemetaan namespace.

Mendeklarasikan objek

Programmer sering berpikir dalam hal objek dan anggota, sedangkan bahasa markup dikonseptualisasikan sebagai elemen dan atribut. Dalam arti yang paling dasar, elemen yang Anda nyatakan dalam markup XAML menjadi objek dalam representasi objek runtime pendukung. Untuk membuat objek run-time untuk aplikasi Anda, Anda mendeklarasikan elemen XAML dalam markup XAML. Objek dibuat saat Runtime Windows memuat XAML Anda.

File XAML selalu memiliki tepat satu elemen yang berfungsi sebagai akarnya, yang menyatakan 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 instantiate objek sebagai elemen xml-form. Anda dapat menggunakan sintaks ini untuk mendeklarasikan objek root atau membuat objek bertumpuk 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 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 relatif jarang dalam kosakata XAML. Bahkan jika kedua bentuk sintaks 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 dapat 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 tipe untuk objek yang ingin Anda instantiate. 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 sendiri 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 wadah. Contoh berikut menunjukkan kontainer Canvas yang berisi satu elemen, Rectangle.

<Canvas>
  <Rectangle />
</Canvas>

Mendeklarasikan objek dengan menggunakan sintaks atribut

Karena perilaku ini terkait dengan pengaturan properti, kita akan membicarakan hal ini lebih lanjut 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 sintaksis 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 dapat melakukan ini jika Anda berbagi nilai struktur itu 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, Thickness, GridLength , atau Color yang berguna dan dapat dibagikan.

Contoh singkat ini menggunakan teks inisialisasi untuk menentukan nilai untuk Ketebalan, dalam hal ini menentukan nilai yang mengatur Kiri dan Kanan ke 20, dan Baik Atas dan Bawah ke 10. Contoh ini menunjukkan Ketebalan yang dibuat sebagai sumber daya yang di-keyed, lalu referensi ke sumber daya tersebut. Untuk info 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 ...>

Nota 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 ini adalah: Durasi, RepeatBehavior, Point, Rect dan Size.

Mengatur properti

Anda dapat mengatur properti pada objek yang Anda nyatakan 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 dari suatu objek.
  • Dengan menggunakan sintaks koleksi (yang biasanya sintaks koleksi implisit).

Seperti halnya deklarasi objek, daftar ini tidak berarti 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 API Runtime Windows, Anda akan melihat penggunaan XAML yang dapat Anda gunakan di bagian Sintaks. Terkadang ada penggunaan alternatif yang akan berhasil tetapi akan lebih bertele-tele. Penggunaan bertele-tele tersebut tidak selalu ditampilkan karena kami mencoba menunjukkan kepada Anda praktik terbaik atau skenario dunia nyata untuk menggunakan properti itu di XAML. Panduan untuk sintaks XAML disediakan di bagian Penggunaan XAML dari 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 bekerja dengan di kode-belakang, bukan di XAML.

Properti baca-saja tidak dapat diatur dalam XAML. Bahkan dalam kode, jenis kepemilikan harus mendukung beberapa cara lain untuk mengaturnya, seperti kelebihan konstruktor, metode pembantu, atau dukungan properti yang dihitung. Properti yang dihitung bergantung pada nilai properti yang dapat diatur lainnya ditambah terkadang peristiwa dengan penanganan bawaan; fitur-fitur ini tersedia dalam sistem properti dependensi. Untuk info 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 di topik ini.

Mengatur properti dengan menggunakan sintaks atribut

Menetapkan nilai atribut adalah cara khas di mana Anda menetapkan nilai properti dalam bahasa markup, misalnya dalam XML atau HTML. Mengatur atribut XAML mirip dengan cara Anda mengatur nilai atribut dalam XML. Nama atribut ditentukan pada titik mana pun dalam tag mengikuti nama elemen, dipisahkan dari nama elemen oleh setidaknya satu spasi. Nama atribut diikuti dengan tanda sama dengan. Nilai atribut terkandung dalam sepasang tanda kutip. Kutipan dapat berupa tanda kutip ganda atau kutipan tunggal selama mereka cocok dan melampirkan nilainya. Nilai atribut itu sendiri harus dapat dinyatakan sebagai string. String sering berisi angka, tetapi untuk XAML, semua nilai atribut adalah nilai string sampai 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: <objectproperty>..

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, di XAML, titik dalam nama elemen mengidentifikasi elemen sebagai elemen properti, dengan properti diharapkan menjadi anggota objek dalam implementasi model objek pendukung. Untuk menggunakan sintaks elemen properti, 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 yang menutup diri.

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

<object>

<benda.harta benda>

propertyValueAsObjectElement

</benda.harta benda>

</object>

Contoh berikut menggunakan sintaks elemen properti untuk mengatur IsianPersegi Panjang dengan elemen objek SolidColorBrush . (Dalam SolidColorBrush, Warna diatur sebagai atribut.) Hasil yang diurai dari XAML ini identik dengan contoh XAML sebelumnya yang mengatur Isian 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 tipe runtime XAML Windows sering diwarisi dari tipe dasar. Pertimbangkan contoh ini: <Button Background="Blue" .../>. Properti Latar Belakang bukanlah properti yang segera dinyatakan pada kelas Tombol . Sebaliknya, Latar Belakang diwarisi dari kelas Kontrol dasar. Bahkan, jika Anda melihat topik referensi untuk Button , Anda akan melihat bahwa daftar anggota berisi setidaknya satu anggota yang diwarisi dari masing-masing 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 Runtime Windows untuk panduan XAML, nama elemen yang ditampilkan dalam sintaks atau bahkan dalam kode contoh terkadang untuk jenis yang awalnya mendefinisikan 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-down-nya melakukan pekerjaan yang bagus untuk menyatukan warisan dan menyediakan daftar atribut akurat yang tersedia untuk pengaturan setelah Anda memulai dengan elemen objek untuk instans kelas.

Properti konten XAML

Beberapa jenis menentukan salah satu propertinya sehingga properti memungkinkan sintaks konten XAML. Untuk properti konten XAML dari suatu 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 batin itu langsung dalam tag elemen objek tipe pemilik. Properti konten XAML mendukung sintaks markup langsung untuk properti itu dan membuat XAML lebih mudah dibaca manusia dengan mengurangi bersarang.

Jika sintaks konten XAML tersedia, sintaks tersebut akan ditampilkan di bagian Sintaks "XAML" untuk properti tersebut dalam dokumentasi referensi runtime Windows. Misalnya, halaman Properti turunan untuk Batas menampilkan 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 tipe Objek , atau tipe 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 menampilkan 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 "Nama". Nilai "Nama" adalah nama properti kelas itu yang merupakan properti konten XAML. Misalnya, di halaman Referensi batas , Anda akan melihat ini: ContentProperty("Name=Child").

Salah satu aturan sintaks XAML penting yang harus kami sebutkan adalah Anda tidak dapat mencampur 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>

Sintaks koleksi

Semua sintaks yang ditampilkan sejauh ini adalah pengaturan properti ke objek tunggal. Tetapi banyak skenario UI mengharuskan elemen induk tertentu dapat memiliki beberapa elemen turunan. Misalnya, UI untuk formulir input membutuhkan 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 turunan serta mendukung model koleksi pendukung yang khas dengan memperlakukan properti yang menggunakan jenis koleksi sebagai implisit, dan melakukan penanganan khusus untuk setiap elemen turunan dari jenis koleksi.

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

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

Mekanisme sintaks pengumpulan XAML

Mungkin pada awalnya muncul bahwa XAML memungkinkan "satu set" properti koleksi baca-saja. Pada kenyataannya, apa yang XAML memungkinkan di sini adalah menambahkan item ke koleksi yang ada. Bahasa XAML dan prosesor XAML yang menerapkan dukungan XAML bergantung pada konvensi dalam mendukung jenis koleksi untuk mengaktifkan sintaks ini. Biasanya ada properti pendukung seperti pengindeks atau properti Item yang mengacu pada item tertentu dari koleksi. Umumnya, properti itu tidak eksplisit dalam sintaks XAML. Untuk koleksi, mekanisme yang mendasari penguraian XAML bukanlah properti, tetapi metode: khususnya, metode Tambahkan dalam banyak kasus. Ketika prosesor XAML menemukan satu atau lebih elemen objek dalam sintaks pengumpulan XAML, setiap objek tersebut pertama kali dibuat dari suatu 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 metode Tambahkan yang menentukan apakah elemen XAML yang diberikan adalah item yang diizinkan dari objek koleksi. Banyak jenis koleksi sangat diketik oleh implementasi backing, yang berarti bahwa parameter input Add mengharapkan bahwa apa pun yang dilewati harus sesuai dengan tipe parameter Add .

Untuk properti koleksi, berhati-hatilah saat Anda mencoba menentukan koleksi secara eksplisit sebagai elemen objek. Parser XAML akan membuat objek baru setiap kali menemukan elemen objek. Jika properti koleksi yang Anda coba gunakan hanya baca, ini dapat memberikan pengecualian parse XAML. Cukup gunakan sintaks koleksi implisit, dan Anda tidak akan melihat pengecualian itu.

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 sintaks secara bergantian. Beberapa properti mendukung sintaks, dan beberapa properti mendukung opsi sintaks tambahan seperti properti konten XAML. Jenis sintaks XAML yang didukung oleh properti tergantung pada jenis objek yang digunakan properti sebagai jenis propertinya. Jika tipe properti adalah tipe primitif, seperti double (float atau decimal), integer, Boolean, atau string, properti selalu mendukung sintaks atribut.

Anda juga dapat menggunakan sintaks atribut untuk mengatur properti jika tipe objek yang Anda gunakan untuk mengatur properti tersebut dapat dibuat dengan memproses string. Untuk primitif, ini selalu terjadi, konversi tipe dibangun ke parser. Namun, jenis objek tertentu lainnya juga dapat dibuat dengan menggunakan string yang ditentukan sebagai nilai atribut, bukan elemen objek dalam elemen properti. Agar ini berhasil, harus ada konversi tipe yang mendasarinya, 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, konverter tipe tertentu juga dapat membuat subkelas yang berbeda dari jenis properti umum, tergantung pada bagaimana ia memproses informasi secara unik dalam string. Tipe 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 (dan ada banyak properti Brush di Windows Runtime XAML).

Logika dan aturan penguraian XAML

Terkadang informatif untuk membaca XAML dengan cara yang mirip dengan bagaimana parser XAML harus membacanya: sebagai satu set token string yang ditemui dalam urutan linier. Parser XAML harus menafsirkan token ini di bawah seperangkat aturan yang merupakan bagian dari definisi tentang cara kerja XAML.

Menetapkan nilai atribut adalah cara khas di mana Anda menetapkan nilai properti dalam bahasa markup, misalnya dalam XML atau HTML. Dalam sintaks berikut, objectName adalah objek yang ingin Anda instantiate, propertyName adalah nama properti yang ingin Anda atur pada objek itu, dan propertyValue adalah nilai yang akan ditetapkan.

<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 instantiated. Hanya setelah instans seperti itu ada, properti instans PropertyName akan diatur di atasnya.

Aturan lain dari XAML adalah bahwa atribut suatu 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.

Nota Desainer XAML sering mempromosikan konvensi pemesanan jika Anda menggunakan permukaan desain selain editor XML, tetapi Anda dapat dengan bebas mengedit XAML itu 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 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. Nama Properti 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 dengan nama itu dalam jenis dukungan, dan dengan cara itu berfungsi agak seperti properti global, atau atribut yang ditentukan oleh namespace XML yang berbeda seperti atribut xml: space .

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

Untuk info selengkapnya, lihat Ikhtisar properti terlampir.

Nilai literal "{"

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

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

Nilai pencacahan

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

  • Jangan gunakan formulir yang memenuhi syarat, itu tidak akan berfungsi. Misalnya, ini adalah XAML yang tidak valid: <Button Visibility="Visibility.Visible"/>.
  • Jangan gunakan nilai konstanta. Dengan kata lain, jangan bergantung pada nilai integer dari pencacahan yang ada secara eksplisit atau implisit tergantung pada bagaimana pencacahan didefinisikan. Meskipun mungkin tampak berhasil, 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"/>.

Nota Dalam topik referensi untuk API yang menggunakan XAML dan menggunakan pencacahan, klik tautan ke tipe pencacahan di bagian Nilai propertisintaksis. Ini link ke halaman pencacahan di mana Anda dapat menemukan konstanta bernama untuk pencacahan itu.

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

Antarmuka di XAML

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

Konvensi placeholder XAML dalam referensi runtime Windows

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

Ketika Anda melihat nama tipe / nama elemen dalam sintaks XAML untuk properti, nama yang ditampilkan adalah untuk jenis yang awalnya mendefinisikan properti. Tetapi Windows Runtime XAML mendukung model pewarisan kelas untuk kelas berbasis DependencyObject. Jadi Anda sering dapat menggunakan atribut pada kelas yang tidak secara harfiah menentukan kelas, melainkan berasal dari kelas yang pertama kali mendefinisikan properti / atribut. Misalnya, Anda dapat mengatur Visibilitas sebagai atribut pada kelas turunan UIElement menggunakan pewarisan yang dalam. Contoh: <Button Visibility="Visible" />. Jadi jangan mengambil nama elemen yang ditampilkan dalam sintaks penggunaan XAML terlalu harfiah; sintaks mungkin layak untuk elemen yang mewakili kelas itu, dan juga elemen yang mewakili kelas turunan. Dalam kasus di mana jarang atau tidak mungkin untuk jenis yang ditampilkan sebagai elemen yang menentukan berada dalam penggunaan dunia nyata, nama tipe itu sengaja huruf kecil dalam sintaks. Misalnya, sintaks yang Anda lihat untuk UIElement.Visibility adalah :

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

Banyak bagian sintaks XAML menyertakan placeholder dalam "Penggunaan" yang kemudian didefinisikan di bagian Nilai XAML yang berada langsung di bawah bagian Sintaks .

Bagian penggunaan XAML juga menggunakan berbagai placeholder umum. Placeholder ini tidak didefinisikan ulang setiap saat dalam Nilai XAML, karena Anda akan menebak atau akhirnya mempelajari apa yang mereka wakili. Kami pikir sebagian besar pembaca akan bosan melihat mereka di XAML Values lagi dan lagi sehingga kami meninggalkan mereka dari definisi. Sebagai referensi, berikut adalah daftar beberapa placeholder ini dan apa artinya dalam arti 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 di halaman referensi untuk info lebih lanjut.
  • objectproperty: objectproperty 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 event handler. Fungsi itu harus didefinisikan dalam kode-belakang untuk halaman XAML. Pada tingkat pemrograman, fungsi tersebut harus sesuai dengan tanda tangan delegasi acara yang Anda tangani, atau kode aplikasi Anda tidak akan dikompilasi. Tapi 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 acara, itu ada di bagian Informasi acara dari topik referensi untuk acara tersebut, di baris tabel yang diberi label Delegasi.
  • enumMemberName: ditampilkan dalam sintaks atribut untuk semua pencacahan. Ada placeholder serupa untuk properti yang menggunakan nilai pencacahan, tetapi biasanya awalan placeholder dengan sedikit nama pencacahan. Misalnya, sintaks yang ditampilkan untuk FrameworkElement.FlowDirection adalah <frameworkElementFlowDirection="flowDirectionMemberName"/>. Jika Anda berada di salah satu halaman referensi properti tersebut, klik link ke tipe pencacahan yang muncul di bagian Nilai Properti , di samping jenis teks:. Untuk nilai atribut properti yang menggunakan pencacahan tersebut, Anda dapat menggunakan string apa pun yang tercantum di kolom Anggota daftar Anggota .
  • double, int, string, bool: Ini adalah tipe primitif yang dikenal dengan bahasa XAML. Jika Anda memprogram menggunakan C# atau Visual Basic, jenis ini diproyeksikan ke tipe setara Microsoft .NET seperti Double, Int32, String, dan Boolean, dan Anda dapat menggunakan anggota mana pun pada tipe .NET tersebut saat Anda bekerja dengan nilai yang ditentukan XAML di .NET code-behind. Jika Anda memprogram menggunakan C ++/CX, Anda akan menggunakan tipe primitif C ++ tetapi Anda juga dapat mempertimbangkan ini setara dengan jenis yang ditentukan oleh namespace Platform , misalnya Platform::String. Terkadang akan ada batasan 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 batasan tersebut berlaku baik untuk penggunaan kode dan penggunaan XAML.

Tips dan trik, catatan tentang gaya

  • Ekstensi markup secara umum dijelaskan dalam ikhtisar XAML utama. Tetapi ekstensi markup yang paling memengaruhi panduan yang diberikan dalam topik ini adalah ekstensi markup StaticResource (dan ThemeResource terkait). Fungsi ekstensi markup StaticResource adalah untuk mengaktifkan anjak XAML Anda menjadi sumber daya yang dapat digunakan kembali yang berasal dari XAML ResourceDictionary. Anda hampir selalu menentukan template kontrol dan gaya terkait dalam ResourceDictionary. Anda sering menentukan bagian yang lebih kecil dari definisi template 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 seharusnya memerlukan penggunaan elemen properti untuk diatur sekarang dapat diatur dalam sintaks atribut. Tetapi manfaat anjak XAML untuk digunakan kembali melampaui hanya menyederhanakan sintaks tingkat halaman. Untuk info 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 konvensi yang berbeda untuk 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 putih dalam file XAML dianggap signifikan; untuk info lebih lanjut lihat XAML dan whitespace.