Mengurus Keadaan Aplikasi
Simpan dan kemas kini data UI.
Mengurus Keadaan Aplikasi ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.
Keadaan pada Struktur App
Dalam egui, keadaan aplikasi anda ialah data Rust biasa yang berada pada struktur yang melaksanakan eframe::App. Tiada stor khas atau model yang dimiliki rangka kerja.
Medan menyimpan segala-galanya: input borang, pilihan, data yang dimuatkan dan penanda. Pada setiap bingkai, update membaca dan mengubah medan ini secara langsung melalui &mut self.
struct App {
query: String,
results: Vec<Item>,
selected: Option<usize>,
loading: bool,
}Menerbitkan Default
eframe membina aplikasi anda dalam penutupan yang dihantar kepada run_native. Corak paling mudah ialah #[derive(Default)] dan membina dengan App::default().
Untuk nilai awal bukan lalai, laksanakan Default secara manual atau tambah pembina yang menerima CreationContext untuk persediaan seperti fon atau pengekalan data.
impl App {
fn new(cc: &eframe::CreationContext) -> Self {
let mut app = Self::default();
app.dark = cc.egui_ctx.style().visuals.dark_mode;
app
}
}Satu-satunya Sumber Kebenaran
Oleh sebab widget meminjam &mut kepada medan sandarannya, struktur sentiasa menjadi satu-satunya sumber kebenaran. Tiada keadaan paparan berasingan yang perlu diselaraskan.
Kotak pilihan yang terikat kepada &mut self.enabled mencerminkan dan mengemas kini bool itu secara langsung — bacanya di mana-mana tempat lain dalam bingkai yang sama dan anda akan melihat nilai semasanya.
ui.checkbox(&mut self.enabled, "Enabled");
if self.enabled {
ui.label("Feature is on");
}Menangguhkan Pengubahan
Isu pinjaman yang halus: anda sering mengiterasi Vec sambil mahu membuang item daripadanya. Anda tidak boleh mengubah vec ketika pinjaman dikongsi masih hidup.
Penyelesaiannya ialah merekod tindakan yang dikehendaki dalam pemboleh ubah setempat semasa gelung, kemudian melaksanakannya selepas gelung tamat.
let mut to_remove = None;
for (i, item) in self.items.iter().enumerate() {
ui.horizontal(|ui| {
ui.label(&item.name);
if ui.button("x").clicked() { to_remove = Some(i); }
});
}
if let Some(i) = to_remove { self.items.remove(i); }Skrin Dipacu Enum
Untuk aplikasi berbilang skrin, modelkan paparan semasa sebagai medan enum. Kaedah update membuat padanan terhadapnya untuk menentukan perkara yang perlu dilukis.
Ini menjadikan navigasi jelas dan menyeluruh — pengkompil memaksa anda mengendalikan setiap skrin, sekali gus menghapuskan seluruh kelas pepijat penghalaan.
enum Screen { Home, Settings, About }
match self.screen {
Screen::Home => self.draw_home(ui),
Screen::Settings => self.draw_settings(ui),
Screen::About => self.draw_about(ui),
}Memori egui untuk Keadaan UI
Sesetengah keadaan hanya berkaitan UI, bukannya domain anda — bahagian yang diruntuhkan, kedudukan tatalan dan keadaan seretan. egui menyimpannya dalam ctx.memory, yang dikunci mengikut Id widget.
Anda jarang menyentuhnya secara langsung, tetapi ctx.data_mut membolehkan anda menyimpan nilai kecil bagi setiap ID yang kekal antara bingkai tanpa memenuhi struktur aplikasi anda.
let id = egui::Id::new("my_toggle");
let mut open = ctx.data_mut(|d| d.get_temp::<bool>(id).unwrap_or(false));
ui.checkbox(&mut open, "Open");
ctx.data_mut(|d| d.insert_temp(id, open));Kerja Latar Belakang dengan Saluran
Jangan sesekali menyekat update dengan I/O perlahan — ia membekukan gelung 60fps. Mulakan utas dan berkomunikasi melalui saluran std::sync::mpsc.
Pekerja menghantar hasil kembali; update mengosongkan penerima secara tidak menyekat dengan try_recv pada setiap bingkai. Panggil ctx.request_repaint() daripada pekerja supaya UI aktif apabila data tiba.
if let Ok(msg) = self.rx.try_recv() {
self.results = msg;
self.loading = false;
}Memulakan Pekerja
Klonkan Context dan penghantar ke dalam utas. Klon itu murah — secara dalaman ia ialah Arc — dan membolehkan pekerja meminta lukisan semula.
Pindahkan pemilikan input kerja ke dalam penutupan untuk memenuhi pemeriksa pinjaman dan mengelakkan isu jangka hayat.
let tx = self.tx.clone();
let ctx = ctx.clone();
std::thread::spawn(move || {
let data = expensive_load();
let _ = tx.send(data);
ctx.request_repaint();
});Mengekalkan Keadaan
eframe boleh menyiri aplikasi anda antara satu pelaksanaan dengan pelaksanaan yang lain. Dayakan ciri persistence, terbitkan serde::Serialize / Deserialize dan laksanakan App::save.
Semasa permulaan, baca keadaan yang disimpan daripada cc.storage dalam pembina anda, dengan kembali kepada nilai lalai apabila tiada apa-apa yang disimpan.
fn save(&mut self, storage: &mut dyn eframe::Storage) {
eframe::set_value(storage, eframe::APP_KEY, self);
}
// in new():
if let Some(s) = cc.storage {
if let Some(app) = eframe::get_value(s, eframe::APP_KEY) { return app; }
}Mengekalkan update Ringan
Oleh sebab update berjalan pada setiap bingkai, elakkan mengira semula data terbitan yang mahal di situ. Simpan hasil dalam medan dan kira semula hanya apabila input berubah.
Corak biasa: jejak penanda dirty yang ditetapkan oleh Response::changed(), kemudian bina semula cache pada permulaan update hanya apabila penanda itu aktif.
if self.dirty {
self.filtered = self.filter_items();
self.dirty = false;
}
for item in &self.filtered { ui.label(&item.name); }Pemilikan Memastikan Ketepatan
Tema berulangnya: egui bergantung pada pemilikan Rust dan bukannya rangka kerja untuk mengurus keadaan. Struktur anda memiliki data, &mut self memberikan akses eksklusif bagi setiap bingkai dan utas berkomunikasi melalui saluran.
Tiada langganan tersembunyi atau graf panggilan balik, jadi penaakulan tentang masa dan cara keadaan berubah kekal setempat dan jelas.
Semakan Pantas
Bagaimanakah anda patut menjalankan pengambilan rangkaian yang perlahan?
Imbas Kembali
Keadaan aplikasi ialah medan biasa pada struktur eframe::App, yang diubah melalui &mut self pada setiap bingkai, menjadikan struktur itu satu-satunya sumber kebenaran.
Tangguhkan pengubahan semasa iterasi, modelkan skrin dengan enum, pindahkan kerja perlahan ke utas menggunakan saluran dan kekalkan keadaan dengan stor eframe. Pastikan update ringan dengan menyimpan data terbitan di sebalik penanda kotor. Seterusnya: membungkus aplikasi anda untuk pengedaran.
Pelajari Rust dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 39
- Pelajaran
- 144
Soalan Lazim
Adakah pelajaran “Mengurus Keadaan Aplikasi” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Mengurus Keadaan Aplikasi”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Mengurus Keadaan Aplikasi”?
Simpan dan kemas kini data UI. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.
Berapa lamakah pelajaran “Mengurus Keadaan Aplikasi” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?
Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Asas UI Mod Segera
- Widget dan Susun Atur
- Mengurus Keadaan Aplikasi
- Membungkus Aplikasi Desktop