- Razor Pages menawarkan model berpusatkan halaman di atas ASP.NET Core, berkongsi enjin penghalaan, perisian tengah dan paparan Razor yang berkuasa sama seperti MVC.
- Projek sebenar berpusat di sekitar folder Pages, wwwroot, appsettings.json dan Program.cs, tempat perkhidmatan, perisian tengah dan pengendalian ralat dikonfigurasikan.
- Alatan seperti Visual Studio, Rider dan VS Code memperkemas pembangunan, penyahpepijatan, navigasi dan pemfaktoran semula model, pandangan dan sintaks Razor.
- ASP.NET Core memudahkan penerbitan aplikasi Razor ke IIS, Azure, pelayan tersuai atau Docker, membolehkan penggunaan yang boleh diskala dan diulang.
Jika anda datang dari Angular plus ASP.NET Web API dan anda mula menikmati C# di bahagian belakang, Razor Pages ialah cara yang sangat semula jadi untuk membawa kegembiraan itu ke bahagian hadapan tanpa meninggalkan pengetahuan JavaScript sedia ada anda. Daripada melompat ke dalam susunan UI yang sama sekali berbeza, anda boleh kekal dalam wilayah Teras ASP.NET yang biasa, menggunakan sintaks Razor untuk pemaparan bahagian pelayan dan masih menaburkan JavaScript di mana sahaja ia masuk akal.
ASP.NET Core Razor Pages ialah pendekatan yang disyorkan oleh Microsoft untuk membina aplikasi web moden di .NET, menawarkan model berasaskan halaman yang bersih yang berada di atas saluran paip ASP.NET Core yang berkuasa. Ia merentas platform, berfungsi dengan lancar dengan alatan seperti Visual Studio, Visual Studio Code dan JetBrains Rider, dan boleh diskalakan daripada prototaip kecil kepada aplikasi berasaskan pangkalan data gred pengeluaran. Dalam panduan ini, kita akan menerangkan cara aplikasi Razor Pages dunia sebenar distrukturkan, cara Program.cs menggabungkan semuanya, cara fail statik dan konfigurasi berfungsi, serta cara perkakasan, penyahpepijatan dan penggunaan memainkan peranan.
Apakah sebenarnya ASP.NET Core Razor Pages (dan bagaimana ia dibandingkan dengan MVC)
Razor Pages ialah ciri ASP.NET Core yang membolehkan anda membina aplikasi web di sekitar halaman dan bukannya pengawal, menawarkan model mental yang lebih mudah sambil masih menggunakan rangka kerja asas yang sama seperti MVC. Di bawah hud, ia berjalan pada susunan penghalaan, middleware dan hosting yang sama seperti pengawal dan pandangan, tetapi setiap halaman mengendalikan tingkah lakunya sendiri dan bukannya memusatkan semuanya dalam kelas pengawal.
Setiap Halaman Razor biasanya diwakili oleh sepasang fail: fail .cshtml untuk markup dan fail .cshtml.cs untuk logik C# halaman. Fail .cshtml mengandungi HTML anda yang dicampur dengan sintaks Razor (contohnya gelung, syarat dan pembantu HTML), manakala fail .cshtml.cs di sebalik kod menyimpan kaedah pengendali seperti OnGet, OnPost, sifat model dan sebarang logik yang diperlukan untuk memaparkan atau memproses halaman.
Sebelum Razor Pages, corak dominan dalam ASP.NET ialah MVC, di mana pengawal mengembalikan pandangan dan menghalakan semua permintaan melalui kaedah tindakan. MVC masih disokong sepenuhnya dan merupakan corak yang telah diuji dalam pertempuran dengan konvensyen yang kukuh, tetapi untuk banyak senario, Razor Pages lebih pantas untuk dipertimbangkan kerana kod yang memuatkan dan memproses halaman secara fizikalnya berada di sebelah markupnya dan bukannya tersembunyi dalam pengawal berasingan.
Walaupun Razor Pages mengalihkan fokus daripada pengawal, ia masih menggunakan enjin paparan Razor yang sama dan menyokong kedua-dua HtmlHelpers dan TagHelpers untuk menjana HTML dinamik. TagHelpers amat berguna: ia melanjutkan tag HTML biasa dengan atribut seperti asp-action, asp-controller or asp-route jadi anda boleh menghubungkan pautan dan borang ke titik akhir backend tanpa menulis banyak URL manual atau JavaScript sebaris.
Bagi pembangun yang sudah mengetahui JavaScript dan pernah menggunakan rangka kerja SPA, Razor Pages menawarkan pendekatan hibrid: HTML yang dipaparkan oleh pelayan untuk pemuatan pertama yang pantas dan SEO, dengan JavaScript dan pustaka bahagian hadapan berlapis di atas jika perlu. Anda tidak terikat dengan atau menentang mana-mana rangka kerja JS tertentu, dan anda boleh mengekalkan bahagian belakang dan bahagian hadapan dalam penyelesaian yang sama, yang memudahkan penggunaan dan penyelenggaraan.
Mencipta dan menjalankan aplikasi web Razor Pages
Apabila anda mencipta projek ASP.NET Core Razor Pages baharu menggunakan Visual Studio, Visual Studio Code atau Rider, templat tersebut akan menyediakan aplikasi yang minimum tetapi lengkap, termasuk Program.cs, folder Pages, fail konfigurasi dan root web statik. Secara automatik, anda akan mendapat laman web berfungsi yang boleh anda jalankan serta-merta dan kemudian berkembang menjadi sesuatu yang lebih sofistikated seperti katalog filem atau mana-mana aplikasi berasaskan data yang lain.
Sebelum menjalankan aplikasi pada HTTPS, ASP.NET Core perlu menggunakan sijil pembangunan yang dipercayai oleh sistem pengendalian anda dan kali pertama anda menjalankan projek, anda mungkin melihat dialog yang meminta anda untuk mempercayainya. Apabila dialog itu muncul, pilih Ya menunjukkan bahawa anda bersetuju dengan sijil pembangunan setempat yang digunakan untuk trafik HTTPS pada mesin anda, yang diperlukan untuk pengujian titik akhir selamat yang betul tanpa amaran pelayar.
Pada Windows, macOS atau Linux, Visual Studio Code membolehkan anda melancarkan aplikasi dengan menekan Ctrl+F5 untuk dijalankan tanpa penyahpepijatan atau menggunakan panel Jalankan dan Nyahpepijat jika anda ingin melampirkan penyahpepijat. Kali pertama, Kod VS mungkin meminta anda memilih jenis penyahpepijat seperti C#, .NET 5+ dan .NET Core atau konfigurasi pelancaran tertentu seperti C#: RazorPagesMovie [https] RazorPagesMovie bergantung pada versi .NET dan konfigurasi ruang kerja anda.
Selepas dilancarkan, pelayar lalai anda akan dibuka pada URL yang serupa dengan https://localhost:<port>, di mana port ditugaskan atau ditentukan secara rawak dalam launchSettings.json, dan anda sedang melihat halaman utama yang dilayan oleh aplikasi Razor Pages. Dalam sesetengah templat, anda sebaliknya akan melihat http://localhost:5001 atau pelabuhan lain; perkara utama ialah localhost menunjukkan ia adalah mesin anda sendiri dan bukan hos luaran.
Sebaik sahaja anda selesai menguji, anda boleh menghentikan aplikasi yang sedang berjalan daripada IDE anda: dalam Visual Studio Code gunakan menu Run dan pilih Stop Debugging atau tekan Beralih+F5, semasa dalam Visual Studio untuk Mac, anda menggunakan Debug > Stop Debugging. Ini akan membunuh tika pelayan web Kestrel yang dimulakan untuk sesi tersebut dan membebaskan port untuk larian lain.
Memahami struktur projek: folder dan fail utama
Aplikasi Razor Pages dunia sebenar disusun di sekitar beberapa folder penting dan fail konfigurasi yang akan anda gunakan secara berterusan: Pages, wwwroot, appsettings.json dan Program.cs (dan dalam versi lama, Startup.cs). Kebiasaan menavigasi bahagian-bahagian ini adalah penting kerana hampir setiap tutorial, sampel atau projek pengeluaran menggunakan konvensyen yang sama.
Folder Pages ialah teras projek Razor Pages, yang mengandungi semua halaman .cshtml dan fail kod di sebalik .cshtml.cs mereka berserta susun atur kongsi dan paparan separa. Setiap pasangan halaman (contohnya Index.cshtml dan Index.cshtml.cs) mewakili titik akhir yang boleh dipanggil dalam aplikasi anda dan fail khas yang bermula dengan garis bawah, seperti _Layout.cshtml, takrifkan kandungan yang digunakan semula merentasi banyak halaman.
Fail susun atur, biasanya dinamakan _Layout.cshtml, mentakrifkan krom tapak anda, seperti bar navigasi atas, pengaki dan notis hak cipta serta menyediakan tempat untuk memaparkan isi setiap halaman individu. Apabila anda menukar susun atur, anda serta-merta mempengaruhi rupa dan gaya semua Razor Pages yang menggunakannya, jadi ia merupakan tempat pilihan untuk mengedit menu, penjenamaan dan skrip atau gaya yang dikongsi.
Folder wwwroot ialah root web yang ditetapkan di mana aset statik berada, termasuk CSS, JavaScript, imej dan fail HTML biasa yang boleh dilayan secara langsung oleh pelayan web. Apa-apa sahaja yang diletakkan di bawah wwwroot boleh diakses oleh pelayar (tertakluk pada konfigurasi fail statik anda), menjadikannya tempat yang sesuai untuk helaian gaya tapak, pustaka bahagian klien dan imej yang dirujuk dalam markup anda.
Konfigurasi untuk aplikasi biasanya disimpan dalam appsettings.json (dan varian khusus persekitaran seperti appsettings.Development.json), yang mengandungi tetapan seperti rentetan sambungan dan bendera ciri. Sistem konfigurasi ASP.NET Core memuatkan fail-fail ini dan menggabungkannya dengan pembolehubah persekitaran dan penyedia lain, menjadikannya mudah untuk mengikat bahagian kepada kelas pilihan yang ditaip kuat dalam kod anda.
Program.cs dan saluran paip Teras ASP.NET
Fail Program.cs mengandungi titik masuk untuk aplikasi Razor Pages anda dan mentakrifkan cara hos web, perkhidmatan dan saluran paip middleware dikonfigurasikan sebelum permintaan pertama sampai ke tapak anda. Dalam versi ASP.NET Core moden, Program.cs menggunakan model "hosting minimum" yang diperkemas dengan pernyataan peringkat atasan yang mencipta WebApplicationBuilder dan kemudian membina dan mengkonfigurasi WebApplication contohnya.
Corak tipikal dalam Program.cs bermula dengan var builder = WebApplication.CreateBuilder(args); yang menyediakan hos dengan lalai biasa, kemudian memanggil builder.Services.AddRazorPages(); untuk mendaftarkan Razor Pages dengan bekas suntikan kebergantungan. Selepas mengkonfigurasi perkhidmatan, var app = builder.Build(); mencipta objek aplikasi yang kemudian anda sambungkan dengan perisian tengah dan titik akhir.
Pengendalian ralat dan tingkah laku keselamatan sangat bergantung pada persekitaran, jadi anda biasanya melihat semakan persekitaran seperti if (!app.Environment.IsDevelopment()) untuk mendayakan ciri gred pengeluaran. Di dalam keadaan itu, anda biasanya akan menemui app.UseExceptionHandler("/Error"); yang menghantar ralat yang tidak dikendalikan ke halaman Ralat khusus, dan app.UseHsts(); yang mengaktifkan HTTP Strict Transport Security (HSTS) untuk mengarahkan pelayar supaya sentiasa menggunakan HTTPS untuk domain anda.
Saluran paip middleware kemudiannya dipasang dengan panggilan seperti app.UseHttpsRedirection();, app.UseStaticFiles(); or app.MapStaticAssets();, app.UseRouting(); dan pilihan app.UseAuthorization(); diikuti dengan pemetaan titik akhir. Pengalihan HTTPS memaksa permintaan HTTP yang tidak selamat untuk dinaik taraf kepada HTTPS, perisian tengah fail statik (atau pemetaan aset statik yang lebih baharu dalam .NET 9) membenarkan penyampaian sumber secara langsung daripada wwwroot dan penghalaan menentukan titik akhir yang mengendalikan setiap URL masuk.
Akhirnya, Razor Pages disambungkan ke penghalaan dengan app.MapRazorPages(); secara pilihan dirantai dengan .WithStaticAssets(); dalam templat yang lebih baharu untuk mengintegrasikan pengoptimuman aset statik, dan aplikasi dimulakan menggunakan app.Run();. Pada ketika itu, aplikasi sedang mendengar pada port yang dikonfigurasikan dan pelayan Kestrel bersedia untuk mengendalikan permintaan sebenar, sama ada dalam pembangunan setempat atau pada hos pengeluaran seperti IIS, Azure App Service atau Docker.
Halaman Razor, model dan model pandangan dalam aplikasi sebenar
Di sebalik setiap aplikasi Razor Pages yang mudah didapati terdapat satu set model domain dan model paparan yang mewakili data anda dan cara ia dipaparkan, sama ada anda mengurus katalog filem, blog atau papan pemuka perniagaan. Model biasanya dipetakan rapat dengan entiti pangkalan data, manakala model paparan boleh disesuaikan dengan satu skrin atau aliran pengguna tertentu, menggabungkan berbilang model atau nilai yang telah diformatkan terlebih dahulu untuk pemaparan yang lebih mudah.
Aliran kerja pembangunan yang biasa adalah bermula dengan kelas C# mudah yang menggunakan medan dan tandatangan kaedah sebagai stub, dan secara beransur-ansur mengembangkannya menjadi model yang betul dengan sifat yang dienkapsulasi, atribut pengesahan dan logik. Alat seperti JetBrains Rider menjadikan evolusi itu lebih lancar dengan tindakan niat yang secara automatik menukar medan kepada sifat, mencipta jenis terbitan untuk hierarki pewarisan dan menggunakan pemfaktoran semula lain semasa anda memperhalusi model objek anda.
Pewarisan dan antara muka membantu menguatkuasakan struktur yang koheren untuk model anda, menyelaraskannya dengan peraturan perniagaan sebenar dan membolehkan polimorfisme di mana tingkah laku tertentu dikongsi tetapi pelaksanaannya berbeza. Contohnya, anda mungkin mempunyai asas ContentItem jenis dengan terbitan Movie, Series and Documentary kelas, setiap satunya dengan perbezaan yang ketara tetapi kontrak biasa yang digunakan di seluruh aplikasi anda.
Sebaik sahaja model anda tersedia, paparan Razor Pages atau MVC boleh dicipta sama ada dengan tangan atau melalui alat perancah yang menjana halaman untuk menyenaraikan, mencipta, mengedit dan memadam entiti. Perancah mempercepatkan pembangunan awal secara mendadak dan memastikan penghalaan, pengikatan model dan pengesahan diwayarkan dengan betul, yang kemudiannya boleh anda sesuaikan dengan markup dan penggayaan anda sendiri.
Sintaks Razor yang digunakan dalam fail .cshtml digabungkan dengan lancar dengan model yang ditaip kuat dan model paparan, membolehkan anda memaparkan data, menjalankan gelung dan syarat serta menjana pautan dan borang menggunakan HtmlHelpers atau TagHelpers tanpa kehilangan keselamatan masa kompilasi. Gabungan C# dan markup ini mengekalkan banyak logik bahagian pelayan tetapi masih menghasilkan HTML bersih dalam pelayar yang berfungsi dengan baik dengan CSS dan JavaScript.
Bekerja dengan sintaks Razor, TagHelpers dan navigasi dalam Rider
Sintaks Razor ialah lapisan ringan di atas HTML yang berfungsi apabila @ simbol muncul, menjadikannya mudah untuk membenamkan ungkapan, pernyataan atau panggilan pembantu C# terus dalam markup anda. Anda boleh menyemak semula senarai item, menunjukkan atau menyembunyikan elemen berdasarkan syarat atau memaparkan nilai dan tarikh berformat tanpa menulis bahasa templat berasingan atau menaburkan JavaScript di merata tempat.
TagHelpers terasa seperti lanjutan semula jadi HTML di mana atribut khas bermula dengan asp- mengubah suai tingkah laku atau output elemen, selalunya menggantikan kaedah HtmlHelper yang lebih lama dan menghapuskan keperluan untuk gam skrip sebaris. Sebagai contoh, termasuk asp-action and asp-controller untuk menghalakan tag dan borang sauh kepada tindakan tertentu atau atribut laluan seperti asp-route-id untuk menyampaikan parameter dengan bersih dalam URL.
Sokongan IDE sangat penting apabila anda mendalami HTML dan Rider menyediakan ciri-ciri berguna seperti breadcrumbs di bahagian bawah editor untuk menunjukkan lokasi semasa anda dalam struktur dokumen. Serbuk roti boleh disesuaikan di bawah Keutamaan atau Pilihan dalam bahagian Editor, dan ia menjadikan navigasi fail Razor yang panjang dengan tag bersarang jauh lebih mudah.
Dalam projek MVC, Rider juga memahami konvensyen yang menghubungkan pengawal, tindakan dan pandangan, jadi meletakkan tetikus di atas hasil tindakan boleh menunjukkan laluan pandangan yang mungkin dan Ctrl + Klik (Atau Cmd-Klik pada macOS) terus ke fail .cshtml yang sepadan. Pintasan seperti Ctrl + B or Cmd-B berikan cara cepat untuk menavigasi pangkalan kod anda tanpa perlu mencari peneroka penyelesaian.
Selain perkakasan khusus Razor, Rider merangkumi satu set tujuan dan penyelesaian pantas yang luas untuk HTML, CSS dan JavaScript yang membantu anda menulis kod sisi klien yang bersih dan berstruktur dengan baik di dalam IDE yang sama seperti bahagian belakang C# anda. Integrasi yang ketat ini dapat menjimatkan banyak suis konteks semasa membina UI interaktif yang kompleks yang masih bergantung pada paparan atau halaman Razor yang diberikan oleh pelayan.
Menyahpepijat Razor Pages dan aplikasi ASP.NET Core
Penyahpepijatan merupakan aktiviti harian dalam pembangunan web dan aplikasi ASP.NET Core yang menjalankan Razor Pages tidak terkecuali, jadi mempunyai sokongan penyahpepijatan yang kuat dalam IDE anda adalah penting. Kedua-dua Visual Studio dan Rider menyediakan penyahpepijat interaktif yang boleh dilampirkan pada proses Kestrel anda, melangkah melalui kod C#, memeriksa pembolehubah dan menilai ungkapan semasa aplikasi berjalan.
Penyahpepijat Rider pada Windows menyokong Edit dan Continue, yang membolehkan anda mengubah suai kod semasa aplikasi dijeda pada titik putus dan menggunakan perubahan tanpa memulakan semula keseluruhan sesi penyahpepijatan. Keupayaan untuk membetulkan kesilapan kecil atau bereksperimen semasa proses penyahpepijatan mempercepatkan penyelesaian masalah dengan ketara, terutamanya dalam projek besar dengan masa permulaan yang tidak remeh.
Halaman pengecualian pembangun lalai dalam ASP.NET Core diaktifkan secara automatik apabila persekitaran ditetapkan kepada Pembangunan, memberikan anda jejak tindanan terperinci, maklumat permintaan dan diagnostik apabila pengecualian yang tidak dikendalikan berlaku. Paparan ini sangat membantu semasa penyahpepijatan setempat tetapi berbahaya dalam pengeluaran kerana ia boleh membocorkan butiran dalaman tentang aplikasi dan persekitaran anda.
Untuk melindungi maklumat sensitif, persekitaran pengeluaran dan ujian biasanya melumpuhkan halaman pengecualian pembangun dan sebaliknya menggunakan laluan pengendali pengecualian yang dikonfigurasikan, selalunya /Error, untuk menunjukkan skrin ralat mesra pengguna semasa merekodkan butiran sebenar di bahagian pelayan. Tingkah laku ini dikawal dalam Program.cs melalui semakan persekitaran dan panggilan kepada UseExceptionHandler and UseHsts.
Apabila sesuatu benar-benar tersasar dan tutorial tidak sepadan dengan tingkah laku anda, selalunya berguna untuk membandingkan projek anda dengan sampel yang diketahui baik yang disediakan oleh Microsoft atau sumber berwibawa yang lain. Banyak tutorial rasmi Razor Pages menerbitkan projek sampel yang telah siap yang boleh anda lihat atau muat turun untuk membezakannya daripada kod anda sendiri dan mengenal pasti konfigurasi yang hilang, kesalahan taip atau fail yang salah letak.
Menerbitkan dan menggunakan aplikasi ASP.NET Core Razor sebenar
Penghantaran aplikasi Razor Pages anda adalah tempat di mana semua struktur dan konfigurasi terdahulu membuahkan hasil, kerana ASP.NET Core menyokong beberapa pilihan penggunaan yang sesuai dengan persekitaran dan aliran kerja hosting yang berbeza. Sama ada anda lebih suka IIS pada Windows, kontena Linux dalam Docker atau platform terurus seperti Azure App Service, proses penerbitan boleh didorong oleh MSBuild dan disepadukan ke dalam saluran paip CI/CD anda.
Visual Studio dan Rider kedua-duanya menawarkan profil penerbitan yang boleh membungkus aplikasi anda dan menggunakanya ke IIS menggunakan Web Deploy (MSDeploy), menyalinnya ke folder tempatan atau rangkaian atau menolaknya terus ke pelayan jauh melalui FTP, FTPS atau SFTP. Mencipta profil penerbitan mengekod tetapan penggunaan anda supaya penerbitan masa hadapan semudah memilih profil dan mengklik butang atau menjalankan arahan.
Untuk senario awan, Azure App Service merupakan sasaran yang popular dan IDE mengintegrasikan perkakasan Azure untuk mencipta dan menerbitkan aplikasi web terus daripada projek anda, sekali lagi menyokong MSBuild dan MSDeploy. Pendekatan ini memastikan binaan dan penggunaan konsisten antara persekitaran tempatan dan awan dan boleh diautomasikan dalam Azure DevOps, GitHub Actions atau sistem CI yang lain.
Docker ialah satu lagi pilihan kelas pertama untuk ASP.NET Core, yang membolehkan anda menyimpan aplikasi Razor Pages anda dalam kontena supaya ia boleh dijalankan secara boleh diramal dalam mana-mana persekitaran yang menyokong kontena. Rider dan Visual Studio boleh membantu anda menjana Dockerfiles dan konfigurasi docker-compose, mendayakan aliran kerja tempat anda membangunkan, menyahpepijat dan menggunakan aplikasi anda di dalam bekas, sama ada secara setempat atau dalam orkestrator seperti Kubernetes.
Terlepas dari sasaran, langkah penerbitan mengkompilkan kod C# anda, menggabungkan paparan Razor, menyalin aset statik dan, bergantung pada tetapan, juga boleh menjana masa jalan yang kendiri supaya mesin hos tidak memerlukan pemasangan .NET yang dikongsi. Penggabungan inilah yang mengubah projek pembangunan anda menjadi artifak yang boleh digunakan dan sedia untuk digunakan oleh pengguna sebenar.
Dengan menggabungkan semua aspek ini—daripada sijil pembangunan dan Program.cs, melalui Pages dan wwwroot, hinggalah penyahpepijatan dan penerbitan—Razor Pages menawarkan cara pragmatik untuk membina aplikasi web ASP.NET Core dunia sebenar yang boleh diselenggara, berprestasi tinggi dan selesa untuk pembangun yang sudah menikmati bekerja dalam C# dan belum bersedia untuk bertaruh sepenuhnya pada rangka kerja satu halaman untuk setiap situasi.
