Catatan
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba masuk atau mengubah direktori.
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba mengubah direktori.
Pastikan sistem perangkat lunak Anda memenuhi kebutuhan pengguna dengan menggunakan alat visualisasi dan pemodelan di Visual Studio. Gunakan alat seperti peta kode, diagram dependensi, dan diagram kelas untuk:
Untuk melihat versi Visual Studio mana yang mendukung setiap alat, lihat Dukungan versi untuk arsitektur dan alat pemodelan.
Mengklarifikasi persyaratan pengguna dan proses bisnis.
Visualisasikan dan jelajahi kode yang ada.
Menjelaskan perubahan pada sistem yang ada.
Verifikasi bahwa sistem memenuhi persyaratannya.
Jaga agar kode tetap konsisten dengan desain.
Panduan ini:
Menjelaskan bagaimana alat-alat ini dapat menguntungkan proyek perangkat lunak Anda.
Menunjukkan bagaimana Anda dapat menggunakan alat-alat ini, terlepas dari pendekatan pengembangan Anda, dengan skenario contoh.
Untuk mengetahui selengkapnya tentang alat-alat ini dan skenario yang didukungnya, lihat:
Gambaran umum skenario
Skenario ini menjelaskan episode dari siklus hidup pengembangan perangkat lunak dari dua perusahaan fiktif: Dinner Now dan Lucerne Publishing. Dinner Now menyediakan layanan pengiriman makanan berbasis Web di Seattle. Pelanggan dapat memesan makanan dan membayarnya di situs web Dinner Now. Pesanan kemudian dikirim ke restoran lokal yang sesuai untuk pengiriman. Lucerne Publishing, sebuah perusahaan di New York, menjalankan beberapa bisnis baik nonaktif maupun di Web. Misalnya, mereka menjalankan situs web tempat pelanggan dapat memposting ulasan restoran.
Lucerne baru-baru ini memperoleh Dinner Now dan ingin membuat perubahan berikut:
Integrasikan situs web mereka dengan menambahkan kemampuan ulasan restoran ke Makan Malam Sekarang.
Ganti sistem pembayaran Dinner Now dengan sistem Lucerne.
Perluas layanan Makan Malam Sekarang di seluruh wilayah.
Makan Malam Sekarang menggunakan SCRUM dan Pemrograman eXtreme. Mereka memiliki cakupan pengujian yang sangat tinggi dan kode yang sangat sedikit tidak didukung. Mereka meminimalkan risiko dengan membuat versi sistem yang kecil tetapi berfungsi dan kemudian menambahkan fungsionalitas secara bertahap. Mereka mengembangkan kode mereka melalui iterasi singkat dan sering. Ini memungkinkan mereka merangkul perubahan dengan percaya diri, kode refaktor sering, dan menghindari "desain besar di depan".
Lucerne mempertahankan koleksi sistem yang jauh lebih besar dan kompleks, beberapa di antaranya berusia lebih dari 40 tahun. Mereka sangat berhati-hati dalam membuat perubahan karena kompleksitas dan cakupan kode warisan. Mereka mengikuti proses pengembangan yang lebih ketat, lebih suka merancang solusi terperinci dan mendokumen desain dan perubahan yang terjadi selama pengembangan.
Kedua tim menggunakan diagram pemodelan di Visual Studio untuk membantu mereka mengembangkan sistem yang memenuhi kebutuhan pengguna. Mereka menggunakan Team Foundation Server bersama alat lain untuk membantu mereka merencanakan, mengatur, dan mengelola pekerjaan mereka.
Untuk informasi selengkapnya tentang Team Foundation Server, lihat:
Peran Arsitektur dan Diagram Pemodelan dalam Pengembangan Perangkat Lunak
Tabel berikut menjelaskan peran yang dapat dimainkan alat-alat ini selama beberapa dan berbagai tahap siklus hidup pengembangan perangkat lunak:
| Alat / Peran | Pemodelan Persyaratan Pengguna | Pemodelan Proses Bisnis | Arsitektur & Desain Sistem | Visualisasi Kode & Eksplorasi | Verifikasi |
|---|---|---|---|---|---|
| Diagram Bahasa Khusus Domain (DSL) | Ya | Ya | Ya | ||
| Diagram dependensi, validasi lapisan | Ya | Ya | Ya | ||
| Peta kode | Ya | Ya | Ya | ||
| Perancang Kelas (berbasis kode) | Ya |
Untuk menggambar diagram dependensi, Anda harus membuat proyek pemodelan sebagai bagian dari solusi yang ada atau yang baru. Diagram ini harus dibuat dalam proyek pemodelan. Item pada diagram dependensi terletak di proyek pemodelan, tetapi tidak disimpan dalam model umum. Peta kode dan diagram kelas .NET yang dibuat dari kode ada di luar proyek pemodelan.
Lihat:
Catatan
Komponen Transformasi Template Teks secara otomatis diinstal sebagai bagian dari beban kerja pengembangan ekstensi Visual Studio. Anda juga dapat menginstalnya dari tab Komponen individual Alat Penginstal Visual Studio, di bawah kategori SDK, pustaka, dan kerangka kerja. Instal komponen SDK Pemodelan dari tab Komponen individual.
Kedua tim juga menggunakan validasi dependensi untuk memastikan bahwa kode yang sedang dikembangkan tetap konsisten dengan desain. Lihat:
Catatan
Beberapa versi Visual Studio mendukung validasi dependensi dan versi peta kode baca-saja untuk visualisasi dan pemodelan. Untuk melihat edisi Visual Studio mana yang mendukung fitur ini, lihat Dukungan edisi untuk arsitektur dan alat pemodelan.
Memahami dan mengomunikasikan informasi tentang sistem
Tidak ada urutan yang ditentukan untuk menggunakan diagram pemodelan Visual Studio, sehingga Anda dapat menggunakannya sesuai dengan kebutuhan atau pendekatan Anda. Biasanya, tim mengunjungi kembali model mereka secara berulang dan sering di seluruh proyek. Setiap diagram menawarkan kekuatan khusus untuk membantu Anda memahami, menggambarkan, dan mengomunikasikan berbagai aspek sistem yang sedang dikembangkan.
Makan Malam Sekarang dan Lucerne berkomunikasi satu sama lain dan dengan pemangku kepentingan proyek dengan menggunakan diagram sebagai bahasa umum mereka. Misalnya, Dinner Now menggunakan diagram untuk melakukan tugas-tugas ini:
Visualisasikan kode yang ada.
Berkomunikasi dengan Lucerne tentang cerita pengguna baru atau yang diperbarui.
Identifikasi perubahan yang diperlukan untuk mendukung cerita pengguna baru atau yang diperbarui.
Lucerne menggunakan diagram untuk melakukan tugas-tugas ini:
Pelajari tentang proses bisnis Dinner Now.
Pahami desain sistem.
Berkomunikasi dengan Makan Malam Sekarang tentang persyaratan pengguna baru atau yang diperbarui.
Pembaruan dokumen untuk sistem.
Diagram terintegrasi dengan Team Foundation Server sehingga tim dapat merencanakan, mengelola, dan melacak pekerjaan mereka dengan lebih mudah. Misalnya, mereka menggunakan model untuk mengidentifikasi kasus pengujian dan tugas pengembangan dan untuk memperkirakan pekerjaan mereka. Lucerne menautkan item kerja Team Foundation Server untuk memodelkan elemen sehingga mereka dapat memantau kemajuan dan memastikan bahwa sistem memenuhi persyaratan pengguna. Misalnya, mereka menautkan kasus penggunaan untuk menguji item kerja kasus sehingga mereka dapat melihat bahwa kasus penggunaan terpenuhi ketika semua pengujian lulus.
Sebelum tim memeriksa perubahan mereka, mereka memvalidasi kode terhadap pengujian dan desain dengan menjalankan build yang mencakup validasi dependensi dan pengujian otomatis. Ini membantu memastikan bahwa kode yang diperbarui tidak bertentangan dengan desain dan merusak fungsionalitas kerja sebelumnya.
Mengidentifikasi Perubahan pada Sistem yang Ada
Makan Malam Sekarang harus memperkirakan biaya memenuhi persyaratan baru. Hal ini sebagian tergantung pada seberapa banyak perubahan ini akan memengaruhi bagian lain dari sistem. Untuk membantu mereka memahami hal ini, salah satu pengembang Dinner Now membuat peta dan diagram ini dari kode yang ada:
| Peta atau diagram | Menunjukkan |
|---|---|
| Peta kode Lihat: - Memetakan dependensi di seluruh solusi Anda - Menjelajah dan mengatur ulang peta kode - Menyesuaikan peta kode dengan mengedit file DGML |
Dependensi dan hubungan lain dalam kode. Misalnya, Makan Malam Sekarang mungkin dimulai dengan meninjau peta kode perakitan untuk gambaran umum rakitan dan dependensinya. Mereka dapat menelusuri peta untuk menjelajahi namespace layanan dan kelas di rakitan tersebut. Makan Malam Sekarang juga dapat membuat peta untuk menjelajahi area tertentu dan jenis hubungan lainnya dalam kode. Mereka menggunakan Penjelajah Solusi untuk menemukan dan memilih area dan hubungan yang menarik minat mereka. |
| Diagram kelas berbasis kode Lihat Cara: Menambahkan Diagram Kelas ke Proyek (Perancang Kelas). |
Kelas yang ada dalam kode |
Misalnya, pengembang membuat peta kode. Dia menyesuaikan cakupannya untuk fokus pada area yang akan terpengaruh oleh skenario baru. Area ini dipilih dan disorot di peta:
Peta kode namespace
Pengembang memperluas namespace yang dipilih untuk melihat kelas, metode, dan hubungan mereka:
Peta kode namespace yang diperluas dengan tautan lintas grup yang terlihat
Pengembang memeriksa kode untuk menemukan kelas dan metode yang terpengaruh. Untuk melihat efek setiap perubahan saat Anda membuatnya, regenerasi peta kode setelah setiap perubahan. Lihat Memvisualisasikan kode.
Untuk menjelaskan perubahan pada bagian lain dari sistem, seperti komponen atau interaksi, tim mungkin menggambar elemen-elemen ini di papan tulis. Mereka mungkin juga menggambar diagram berikut di Visual Studio sehingga detailnya dapat diambil, dikelola, dan dipahami oleh kedua tim:
| Diagram | Menjelaskan |
|---|---|
| Diagram kelas berbasis kode Lihat Cara: Menambahkan Diagram Kelas ke Proyek (Perancang Kelas). |
Kelas yang ada dalam kode. |
Menjaga Kode Tetap Konsisten dengan Desain
Makan Malam Sekarang harus memastikan bahwa kode yang diperbarui tetap konsisten dengan desain. Mereka membuat diagram dependensi yang menjelaskan lapisan fungsionalitas dalam sistem, menentukan dependensi yang diizinkan di antara mereka, dan mengaitkan artefak solusi ke lapisan tersebut.
| Diagram | Menjelaskan |
|---|---|
| Diagram dependensi Lihat: - Membuat diagram dependensi dari kode Anda - Diagram Dependensi: Referensi - Diagram Dependensi: Panduan - Memvalidasi kode dengan diagram dependensi |
Arsitektur logis kode. Diagram dependensi mengatur dan memetakan artefak dalam solusi Visual Studio ke grup abstrak yang disebut lapisan. Lapisan-lapisan ini mengidentifikasi peran, tugas, atau fungsi yang dilakukan artefak ini dalam sistem. Diagram dependensi berguna untuk menjelaskan desain sistem yang dimaksudkan dan memvalidasi kode yang berkembang terhadap desain tersebut. Untuk membuat lapisan, seret item dari Penjelajah Solusi, peta kode, Tampilan Kelas, dan Browser Objek. Untuk menggambar lapisan baru, gunakan kotak alat atau klik kanan permukaan diagram. Untuk melihat dependensi yang ada, klik kanan permukaan diagram dependensi, lalu klik Hasilkan Dependensi. Untuk menentukan dependensi yang dimaksudkan, gambar dependensi baru. |
Misalnya, diagram dependensi berikut menjelaskan dependensi antara lapisan dan jumlah artefak yang terkait dengan setiap lapisan:
Diagram Dependensi
Untuk memastikan bahwa konflik dengan desain tidak terjadi selama pengembangan kode, tim menggunakan validasi dependensi pada build yang dijalankan di Azure DevOps. Mereka juga membuat tugas MSBuild kustom untuk memerlukan validasi dependensi dalam operasi check-in mereka. Mereka menggunakan laporan build untuk mengumpulkan kesalahan validasi.
Lihat:
Tips Umum untuk Membuat dan Menggunakan Model
Sebagian besar diagram terdiri dari simpul yang disambungkan oleh garis. Untuk setiap jenis diagram, kotak alat menyediakan berbagai jenis node dan garis.
Untuk membuka kotak alat, pada menu Tampilan , klik Kotak Alat.
Untuk membuat simpul, seret dari kotak alat ke diagram. Jenis node tertentu harus diseret ke simpul yang ada. Misalnya, pada diagram komponen, port baru harus ditambahkan ke komponen yang ada.
Untuk membuat baris atau koneksi, klik alat yang sesuai di kotak alat, klik simpul sumber, lalu klik simpul target. Beberapa baris hanya dapat dibuat di antara jenis node tertentu. Saat Anda memindahkan penunjuk ke sumber atau target yang mungkin, penunjuk menunjukkan apakah Anda dapat membuat koneksi.
Merencanakan dan melacak pekerjaan
Diagram pemodelan Visual Studio terintegrasi dengan Team Foundation Server sehingga Anda dapat merencanakan, mengelola, dan melacak pekerjaan dengan lebih mudah. Kedua tim menggunakan model untuk mengidentifikasi kasus pengujian dan tugas pengembangan dan untuk memperkirakan pekerjaan mereka. Lucerne membuat dan menautkan item kerja Team Foundation Server ke elemen model, seperti kasus penggunaan atau komponen. Ini membantu mereka memantau kemajuan mereka dan melacak pekerjaan mereka kembali ke persyaratan pengguna. Ini membantu mereka memastikan bahwa perubahan mereka terus memenuhi persyaratan tersebut.
Saat pekerjaan mereka berlangsung, tim memperbarui item kerja mereka untuk mencerminkan waktu yang mereka habiskan untuk tugas mereka. Mereka juga memantau dan melaporkan status pekerjaan mereka dengan menggunakan fitur Team Foundation Server berikut:
Laporan pembakaran harian yang menunjukkan apakah mereka akan menyelesaikan pekerjaan yang direncanakan dalam waktu yang diharapkan. Mereka menghasilkan laporan serupa lainnya dari Team Foundation Server untuk melacak kemajuan bug.
Lembar kerja perulangan yang menggunakan Microsoft Excel untuk membantu tim memantau dan menyeimbangkan beban kerja di antara anggotanya. Lembar kerja ini ditautkan ke Team Foundation Server dan menyediakan fokus untuk diskusi selama rapat kemajuan reguler mereka.
Dasbor pengembangan yang menggunakan Proyek Office untuk menjaga tim mendapatkan informasi tentang informasi proyek penting.
Lihat:
Kode Uji, Validasi, dan Cek Masuk
Saat tim menyelesaikan setiap tugas, mereka memeriksa kode mereka ke kontrol sumber dan menerima pengingat dari Team Foundation Server, jika mereka lupa. Sebelum Team Foundation Server menerima check-in mereka, tim menjalankan pengujian unit dan validasi dependensi untuk memverifikasi kode terhadap kasus pengujian dan desain mereka. Mereka menggunakan Team Foundation Server untuk menjalankan build, pengujian unit otomatis, dan validasi dependensi secara teratur. Ini membantu memastikan bahwa kode memenuhi kriteria berikut:
Berhasil.
Ini tidak merusak kode yang sebelumnya berfungsi.
Ini tidak bertentangan dengan desain.
Dinner Now memiliki banyak koleksi tes otomatis, yang dapat digunakan kembali oleh Lucerne karena hampir semua masih berlaku. Lucerne juga dapat membangun pengujian ini dan menambahkan yang baru untuk mencakup fungsionalitas baru. Keduanya juga menggunakan Visual Studio untuk menjalankan pengujian manual.
Untuk memastikan bahwa kode sesuai dengan desain, tim mengonfigurasi build mereka di Azure DevOps untuk menyertakan validasi dependensi. Jika terjadi konflik, laporan dihasilkan dengan detailnya.
Lihat:
Memperbarui Sistem Menggunakan Visualisasi dan Pemodelan
Lucerne dan Dinner Now harus mengintegrasikan sistem pembayaran mereka. Bagian berikut menunjukkan diagram pemodelan di Visual Studio membantu mereka melakukan tugas ini:
Lihat:
Memvisualisasikan Kode yang Ada: Kode Peta
Peta kode memperlihatkan organisasi dan hubungan saat ini dalam kode. Item diwakili oleh simpul di peta, dan hubungan diwakili oleh tautan. Peta kode dapat membantu Anda melakukan jenis tugas berikut:
Jelajahi kode yang tidak dikenal.
Pahami di mana dan bagaimana perubahan yang diusulkan dapat memengaruhi kode yang ada.
Temukan area kompleksitas, dependensi atau pola alami, atau area lain yang mungkin mendapat manfaat dari peningkatan.
Misalnya, Dinner Now harus memperkirakan biaya pembaruan komponen PaymentProcessing. Hal ini sebagian tergantung pada seberapa banyak perubahan ini akan memengaruhi bagian lain dari sistem. Untuk membantu mereka memahami hal ini, salah satu pengembang Dinner Now menghasilkan peta kode dari kode dan menyesuaikan fokus cakupan pada area yang mungkin terpengaruh oleh perubahan.
Peta berikut menunjukkan dependensi antara kelas PaymentProcessing dan bagian lain dari sistem Dinner Now, yang muncul dipilih:
Peta kode untuk sistem pembayaran Dinner Now
Pengembang menjelajahi peta dengan memperluas kelas PaymentProcessing dan memilih anggotanya untuk melihat area yang berpotensi terpengaruh:
Metode di dalam kelas PaymentProcessing dan dependensinya
Mereka menghasilkan peta berikut untuk Lucerne Payment System untuk memeriksa kelas, metode, dan dependensinya. Tim melihat bahwa sistem Lucerne mungkin juga memerlukan pekerjaan untuk berinteraksi dengan bagian lain dari Makan Malam Sekarang:
Peta kode untuk Sistem Pembayaran Lucerne
Kedua tim bekerja sama untuk menentukan perubahan yang diperlukan untuk mengintegrasikan kedua sistem. Mereka memutuskan untuk merefaktor beberapa kode sehingga akan lebih mudah diperbarui. Kelas PaymentApprover akan pindah ke namespace DinnerNow.Business dan akan memerlukan beberapa metode baru. Kelas Dinner Now yang menangani transaksi akan memiliki namespace sendiri. Tim membuat dan menggunakan item kerja untuk merencanakan, mengatur, dan melacak pekerjaan mereka. Mereka menautkan item kerja ke elemen model di mana item tersebut berguna.
Setelah mengatur ulang kode, tim menghasilkan peta kode baru untuk melihat struktur dan hubungan yang diperbarui:
Peta kode dengan kode yang diatur ulang
Peta ini menunjukkan bahwa kelas PaymentApprover sekarang berada di namespace DinnerNow.Business dan memiliki beberapa metode baru. Kelas transaksi Dinner Now sekarang memiliki namespace PaymentSystem mereka sendiri, yang membuatnya lebih mudah untuk menangani kode tersebut nanti.
Membuat Peta Kode
Untuk gambaran umum singkat kode sumber, ikuti langkah-langkah berikut untuk membuat peta kode:
Pada menu Arsitektur , klik Buat Peta Kode Untuk Solusi.
Untuk gambaran umum singkat kode yang dikompilasi, buat peta kode kosong, lalu seret file rakitan atau file biner ke permukaan peta.
Untuk menjelajahi item kode atau solusi tertentu, gunakan Penjelajah Solusi untuk memilih item dan hubungan yang ingin Anda visualisasikan. Anda kemudian dapat membuat peta baru atau menambahkan item yang dipilih ke peta yang sudah ada. Lihat Memetakan dependensi di seluruh solusi Anda.
Untuk membantu Anda menjelajahi peta, susun ulang tata letak sehingga sesuai dengan jenis tugas yang ingin Anda lakukan.
Misalnya, untuk memvisualisasikan lapisan dalam kode, pilih tata letak pohon. Lihat Menelusuri dan menyusun ulang peta kode.
Ringkasan: Kekuatan Peta Kode
Peta kode membantu Anda:
Pelajari tentang organisasi dan hubungan dalam kode yang ada.
Identifikasi area yang mungkin terpengaruh oleh perubahan yang diusulkan.
Temukan area kompleksitas, pola, lapisan, atau area lain yang dapat Anda tingkatkan untuk membuat kode lebih mudah dipertahankan, diubah, dan digunakan kembali.
Hubungan dengan Diagram Lain
| Diagram | Menjelaskan |
|---|---|
| Diagram dependensi | Arsitektur logis sistem. Gunakan validasi dependensi untuk memastikan bahwa kode tetap konsisten dengan desain. Untuk membantu Anda mengidentifikasi dependensi yang ada atau dependensi yang dimaksudkan, buat peta kode dan item terkait grup. Untuk membuat diagram dependensi, lihat: - Membuat diagram dependensi dari kode Anda - Diagram Dependensi: Panduan |
| Diagram kelas (berbasis kode) | Kelas yang ada dalam kode untuk proyek tertentu. Untuk memvisualisasikan dan memodifikasi kelas yang ada dalam kode, gunakan Perancang Kelas. Lihat Cara: Menambahkan Diagram Kelas ke Proyek (Perancang Kelas). |
Menentukan Glosarium Jenis: Diagram Kelas
Diagram kelas menentukan entitas, istilah, atau konsep yang berpartisipasi dalam sistem dan hubungannya satu sama lain. Misalnya, Anda dapat menggunakan diagram ini selama pengembangan untuk menjelaskan atribut dan operasi untuk setiap kelas, terlepas dari bahasa atau gaya implementasinya.
Untuk membantu Lucerne menjelaskan dan mendiskusikan entitas yang berpartisipasi dalam kasus penggunaan Pembayaran Proses, mereka menggambar diagram kelas berikut:
Memproses entitas Pembayaran pada diagram kelas
Diagram ini menunjukkan bahwa Pelanggan dapat memiliki banyak pesanan dan berbagai cara untuk membayar pesanan. BankAccount dan CreditCard sama-sama mewarisi dari Pembayaran.
Selama pengembangan, Lucerne menggunakan diagram kelas berikut untuk menjelaskan dan membahas detail setiap kelas:
Detail Pembayaran Proses pada diagram kelas
Menggambar Diagram Kelas
Diagram kelas memiliki fitur utama berikut:
Jenis seperti kelas, antarmuka, dan enumerasi:
Kelas adalah definisi objek yang berbagi karakteristik struktural atau perilaku tertentu.
Antarmuka mendefinisikan bagian dari perilaku objek yang terlihat secara eksternal.
Enumerasi adalah pengklasifikasi yang berisi daftar nilai harfiah.
Atribut adalah nilai dari jenis tertentu yang menjelaskan setiap instans pengklasifikasi. Pengklasifikasi adalah nama umum untuk jenis, komponen, kasus penggunaan, dan bahkan aktor.
Operasi adalah metode atau fungsi yang dapat dilakukan instans pengklasifikasi.
Asosiasi menunjukkan semacam hubungan antara dua pengklasifikasi.
Agregasi adalah asosiasi yang menunjukkan kepemilikan bersama antara pengklasifikasi.
Komposisi adalah asosiasi yang menunjukkan hubungan seluruh bagian antara pengklasifikasi.
Untuk menampilkan agregasi atau komposisi, atur properti Agregasi pada asosiasi . Bersama menunjukkan agregasi dan Komposit menunjukkan komposisi.
Dependensi menunjukkan bahwa mengubah definisi satu pengklasifikasi dapat mengubah definisi pengklasifikasi lain.
Generalisasi menunjukkan bahwa pengklasifikasi tertentu mewarisi bagian dari definisinya dari pengklasifikasi umum. Realisasi menunjukkan bahwa kelas mengimplementasikan operasi dan atribut yang ditawarkan oleh antarmuka.
Untuk membuat hubungan ini, gunakan alat Warisan . Atau, realisasi dapat direpresentasikan sebagai perulangan.
Paket adalah grup pengklasifikasi, asosiasi, garis hidup, komponen, dan paket lainnya. Hubungan impor menunjukkan bahwa satu paket menyertakan semua definisi paket lain.
Sebagai titik awal untuk menjelajahi dan mendiskusikan kelas yang ada, Anda dapat menggunakan Perancang Kelas untuk membuat diagram kelas dari kode.
Ringkasan: Kekuatan Diagram Kelas
Diagram kelas membantu Anda menentukan:
Glosarium umum istilah yang digunakan saat mendiskusikan kebutuhan pengguna dan entitas yang berpartisipasi dalam sistem. Lihat Persyaratan pengguna model.
Jenis yang digunakan oleh bagian sistem, seperti komponen, terlepas dari implementasinya. Lihat Memodelkan arsitektur aplikasi Anda.
Hubungan, seperti dependensi, di antara jenis. Misalnya, Anda dapat menunjukkan bahwa satu jenis dapat dikaitkan dengan beberapa instans dari jenis lain.
Hubungan dengan Diagram Lain
| Diagram | Keterangan |
|---|---|
| Diagram dependensi | Tentukan arsitektur logis sistem karena berkaitan dengan kelas. Gunakan validasi dependensi untuk memastikan bahwa kode tetap konsisten dengan desain. Lihat: - Membuat diagram dependensi dari kode Anda - Diagram Dependensi: Referensi - Diagram Dependensi: Panduan - Memvalidasi kode dengan diagram dependensi |
| Peta kode | Visualisasikan organisasi dan hubungan dalam kode yang ada. Untuk mengidentifikasi kelas, hubungannya, dan metodenya, buat peta kode yang menunjukkan elemen tersebut. Lihat: - Memetakan dependensi di seluruh solusi Anda |
Menjelaskan Arsitektur Logis: Diagram dependensi
Diagram dependensi menjelaskan arsitektur logis sistem dengan mengatur artefak dalam solusi Anda ke dalam grup abstrak, atau lapisan. Artefak dapat berupa banyak hal, seperti namespace, proyek, kelas, metode, dan sebagainya. Lapisan mewakili dan menggambarkan peran atau tugas yang dilakukan artefak dalam sistem. Anda juga dapat menyertakan validasi lapisan dalam operasi build dan check-in Anda untuk memastikan bahwa kode tetap konsisten dengan desainnya.
Agar kode tetap konsisten dengan desain, Dinner Now dan Lucerne menggunakan diagram dependensi berikut untuk memvalidasi kode mereka saat berevolusi:
Diagram dependensi untuk Makan Malam Sekarang terintegrasi dengan Lucerne
Lapisan pada diagram ini terhubung ke artefak solusi Dinner Now dan Lucerne yang sesuai. Misalnya, lapisan Bisnis ditautkan ke namespace DinnerNow.Business dan anggotanya, yang sekarang menyertakan kelas PaymentApprover. Lapisan Akses Sumber Daya menautkan ke namespace DinnerNow.Data. Panah, atau dependensi, menentukan bahwa hanya lapisan Bisnis yang dapat menggunakan fungsionalitas di lapisan Akses Sumber Daya. Saat tim memperbarui kode mereka, validasi lapisan dilakukan secara teratur untuk menangkap konflik saat terjadi dan untuk membantu tim menyelesaikannya segera.
Tim bekerja sama untuk mengintegrasikan dan menguji dua sistem secara bertahap. Mereka pertama-tama memastikan bahwa PaymentApprover dan sisa Makan Malam Sekarang bekerja dengan satu sama lain dengan sukses sebelum mereka berurusan dengan PaymentProcessing.
Peta kode berikut menunjukkan panggilan baru antara Makan Malam Sekarang dan PaymentApprover:
Peta kode dengan panggilan metode yang diperbarui
Setelah mereka mengonfirmasi bahwa sistem berfungsi seperti yang diharapkan, Dinner Now mengomentari kode PaymentProcessing. Laporan validasi lapisan bersih, dan peta kode yang dihasilkan menunjukkan bahwa tidak ada lagi dependensi PaymentProcessing:
Peta kode tanpa PaymentProcessing
Menggambar Diagram Dependensi
Diagram dependensi memiliki fitur utama berikut:
Lapisan menjelaskan kelompok artefak logis.
Tautan adalah hubungan antara lapisan dan artefak.
Untuk membuat lapisan dari artefak, seret item dari Penjelajah Solusi, peta kode, Tampilan Kelas, atau Browser Objek. Untuk menggambar lapisan baru lalu menautkannya ke artefak, gunakan kotak alat atau klik kanan permukaan diagram untuk membuat lapisan, lalu seret item ke lapisan tersebut.
Angka pada lapisan menunjukkan jumlah artefak yang ditautkan ke lapisan. Artefak ini dapat berupa namespace layanan, proyek, kelas, metode, dan sebagainya. Saat Anda menginterpretasikan jumlah artefak pada lapisan, ingatlah hal berikut:
Jika lapisan terhubung ke artefak yang berisi artefak lain, tetapi lapisan tidak terhubung langsung ke artefak lain, maka angka tersebut hanya menyertakan artefak yang ditautkan. Namun, artefak lainnya disertakan untuk analisis selama validasi lapisan.
Misalnya, jika lapisan ditautkan ke satu namespace layanan, maka jumlah artefak tertaut adalah 1, bahkan jika namespace layanan berisi kelas. Jika lapisan juga memiliki tautan ke setiap kelas di namespace layanan, maka angka tersebut akan menyertakan kelas yang ditautkan.
Jika lapisan berisi lapisan lain yang ditautkan ke artefak, maka lapisan kontainer juga ditautkan ke artefak tersebut, meskipun angka pada lapisan kontainer tidak menyertakan artefak tersebut.
Untuk melihat artefak yang ditautkan ke lapisan, klik kanan dependensi, lalu klik Tampilkan Tautan untuk membuka Layer Explorer.
Dependensi menunjukkan bahwa satu lapisan dapat menggunakan fungsionalitas di lapisan lain, tetapi bukan sebaliknya. Dependensi dua arah menunjukkan bahwa satu lapisan dapat menggunakan fungsionalitas di lapisan lain, dan sebaliknya.
Untuk menampilkan dependensi yang ada pada diagram dependensi, klik kanan permukaan diagram, lalu klik Hasilkan Dependensi. Untuk menjelaskan dependensi yang dimaksudkan, gambar dependensi baru.
Lihat:
Ringkasan: Kekuatan Diagram Dependensi
Diagram dependensi membantu Anda:
Menjelaskan arsitektur logis sistem sesuai dengan fungsionalitas artefaknya.
Pastikan bahwa kode dalam pengembangan sesuai dengan desain yang ditentukan.
Hubungan dengan Diagram Lain
| Diagram | Keterangan |
|---|---|
| Peta kode | Visualisasikan organisasi dan hubungan dalam kode yang ada. Untuk membuat lapisan, buat peta kode, lalu kelompokkan item di peta sebagai lapisan potensial. Seret grup dari peta ke diagram dependensi. Lihat: - Memetakan dependensi di seluruh solusi Anda - Menjelajah dan mengatur ulang peta kode |
Sumber Daya Eksternal
| Golongan | Tautan |
|---|---|
| Forum | - Visualisasi Visualisasi & Alat Pemodelan Visual Studio - Visualisasi Visualisasi & Pemodelan SDK (Alat DSL) |