Bagikan melalui

Arsitektur Klien

  • Artikel

Aplikasi menggunakan objek klien Windows Communication Foundation (WCF) untuk memanggil operasi layanan. Topik ini membahas objek klien WCF, saluran klien WCF, dan hubungannya dengan arsitektur saluran yang mendasar. Untuk gambaran umum dasar objek klien WCF, lihat Gambaran Umum Klien WCF. Untuk mengetahui informasi selengkapnya tentang lapisan saluran, lihat Memperluas Lapisan Saluran.

Gambaran Umum

Run time model layanan membuat klien WCF, yang terdiri dari yang berikut:

  • Implementasi klien yang dibuat secara otomatis dari kontrak layanan, yang mengubah panggilan dari kode aplikasi Anda menjadi pesan keluar, dan mengubah pesan respons menjadi parameter output dan mengembalikan nilai yang dapat diambil aplikasi Anda.

  • Implementasi antarmuka kontrol (System.ServiceModel.IClientChannel) yang mengelompokkan berbagai antarmuka dan menyediakan akses ke fungsionalitas kontrol, terutama kemampuan untuk menutup sesi klien dan membuang saluran.

  • Saluran klien yang dibuat berdasarkan pengaturan konfigurasi yang ditentukan oleh pengikatan yang digunakan.

Aplikasi dapat membuat klien tersebut sesuai permintaan, baik melalui System.ServiceModel.ChannelFactory atau dengan membuat instans kelas turunan ClientBase<TChannel> karena dihasilkan oleh Alat Utilitas Metadata ServiceModel (Svcutil.exe). Kelas klien siap pakai ini merangkum dan mendelegasikan ke implementasi saluran klien yang dibuat secara dinamis oleh ChannelFactory. Oleh karena itu, saluran klien dan pabrik saluran yang menghasilkannya adalah titik fokus yang menarik untuk diskusi ini.

Objek Klien dan Saluran Klien

Antarmuka dasar klien WCF adalah antarmuka System.ServiceModel.IClientChannel, yang mengekspos fungsionalitas klien inti serta fungsionalitas System.ServiceModel.ICommunicationObject objek komunikasi dasar, fungsionalitas System.ServiceModel.IContextChannel konteks, dan perilaku System.ServiceModel.IExtensibleObject<T> yang dapat diperluas.

Antarmuka IClientChannel, bagaimanapun, tidak menentukan kontrak layanan itu sendiri. Ini dinyatakan oleh antarmuka kontrak layanan (biasanya dihasilkan dari metadata layanan menggunakan alat seperti Alat Utilitas Metadata ServiceModel (Svcutil.exe)). Jenis klien WCF memperluas antarmuka IClientChannel dan kontrak layanan target untuk memungkinkan aplikasi memanggil operasi secara langsung dan juga memiliki akses ke fungsi run-time sisi klien. Membuat klien WCF menyediakan objek WCFSystem.ServiceModel.ChannelFactory dengan informasi yang diperlukan untuk membuat run time yang dapat terhubung dan berinteraksi dengan titik akhir layanan yang dikonfigurasi.

Seperti disebutkan sebelumnya, dua jenis klien WCF harus dikonfigurasi sebelum Anda dapat menggunakannya. Jenis klien WCF paling sederhana adalah objek yang berasal dari ClientBase<TChannel> (atau DuplexClientBase<TChannel> jika kontrak layanan adalah kontrak dupleks). Anda dapat membuat jenis ini dengan menggunakan konstruktor, dikonfigurasi secara terprogram, atau dengan menggunakan file konfigurasi, lalu dipanggil langsung untuk memanggil operasi layanan. Untuk gambaran umum dasar objek ClientBase<TChannel>, lihat Gambaran Umum Klien WCF.

Jenis kedua dihasilkan pada durasi dari panggilan ke metode CreateChannel. Aplikasi yang berkaitan dengan kontrol ketat atas spesifikasi komunikasi biasanya menggunakan jenis klien ini, yang disebut objek saluran klien, karena memungkinkan interaksi yang lebih langsung daripada run-time klien dan sistem saluran yang mendasarinya.

Pabrik Saluran

Kelas yang bertanggung jawab untuk membuat run time yang mendasarinya yang mendukung pemanggilan klien adalah kelas System.ServiceModel.ChannelFactory<TChannel>. Baik objek klien WCF maupun objek saluran klien WCF menggunakan objek ChannelFactory<TChannel> untuk membuat instans; objek klien turunan ClientBase<TChannel> merangkum penanganan pabrik saluran, tetapi untuk sejumlah skenario, sangat masuk akal untuk menggunakan pabrik saluran secara langsung. Skenario umum untuk ini adalah jika Anda ingin berulang kali membuat saluran klien baru dari pabrik yang ada. Jika menggunakan objek klien, Anda dapat memperoleh pabrik saluran yang mendasar dari objek klien WCF dengan memanggil properti ClientBase<TChannel>.ChannelFactory.

Hal penting yang perlu diingat tentang pabrik saluran adalah pabrik saluran membuat instans baru saluran klien untuk konfigurasi yang disediakan kepada pabrik saluran sebelum memanggil ChannelFactory<TChannel>.CreateChannel. Setelah memanggil CreateChannel (atau ClientBase<TChannel>.Open, ClientBase<TChannel>.CreateChannel, atau operasi apa pun pada objek klien WCF), Anda tidak dapat memodifikasi pabrik saluran dan berharap untuk mendapatkan saluran ke instans layanan yang berbeda, meskipun Anda hanya mengubah alamat titik akhir target. Jika ingin membuat objek klien atau saluran klien dengan konfigurasi yang berbeda, Anda harus membuat pabrik saluran baru terlebih dahulu.

Untuk mengetahui informasi selengkapnya tentang berbagai masalah menggunakan objek klien WCF dan saluran klien WCF, lihat Mengakses Layanan Menggunakan Klien WCF.

Dua bagian berikut menjelaskan pembuatan dan penggunaan objek saluran klien WCF.

Membuat Objek Saluran Klien WCF Baru

Untuk mengilustrasikan penggunaan saluran klien, asumsikan kontrak layanan berikut telah dibuat.

[System.ServiceModel.ServiceContractAttribute(
  Namespace = "http://microsoft.wcf.documentation"
)]
public interface ISampleService
{
    [System.ServiceModel.OperationContractAttribute(
      Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethod",
      ReplyAction = "http://microsoft.wcf.documentation/ISampleService/SampleMethodResponse"
    )]
    [System.ServiceModel.FaultContractAttribute(
      typeof(microsoft.wcf.documentation.SampleFault),
      Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethodSampleFaultFault"
    )]
    string SampleMethod(string msg);
}

Untuk menyambungkan ke layanan ISampleService, gunakan antarmuka kontrak yang dibuat langsung dengan pabrik saluran (ChannelFactory<TChannel>). Setelah membuat dan mengonfigurasi pabrik saluran untuk kontrak tertentu, Anda dapat memanggil metode CreateChannel untuk mengembalikan objek saluran klien yang dapat digunakan untuk berkomunikasi dengan layanan ISampleService.

Saat menggunakan kelas ChannelFactory<TChannel> dengan antarmuka kontrak layanan, Anda harus mentransmisikan ke antarmuka IClientChannel untuk membuka, menutup, atau membatalkan saluran secara eksplisit. Untuk memudahkan penggunaannya, alat Svcutil.exe juga menghasilkan antarmuka pembantu yang mengimplementasikan antarmuka kontrak layanan dan IClientChannel untuk memungkinkan Anda berinteraksi dengan infrastruktur saluran klien tanpa harus mentransmisikan. Kode berikut menunjukkan definisi saluran klien pembantu yang mengimplementasikan kontrak layanan sebelumnya.

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public interface ISampleServiceChannel : ISampleService, System.ServiceModel.IClientChannel
{
}

Membuat Objek Saluran Klien WCF Baru

Untuk menggunakan saluran klien untuk terhubung ke layanan ISampleService, gunakan antarmuka kontrak yang dihasilkan (atau versi pembantu) langsung dengan pabrik saluran, meneruskan jenis antarmuka kontrak sebagai parameter jenis. Setelah pabrik saluran untuk kontrak tertentu dibuat dan dikonfigurasi, Anda dapat memanggil metode ChannelFactory<TChannel>.CreateChannel untuk mengembalikan objek saluran klien yang dapat digunakan untuk berkomunikasi dengan layanan ISampleService.

Saat dibuat, objek saluran klien mengimplementasikan IClientChannel dan antarmuka kontrak. Oleh karena itu, Anda dapat menggunakannya secara langsung untuk memanggil operasi yang berinteraksi dengan layanan yang mendukung kontrak tersebut.

Perbedaan antara menggunakan objek klien dan objek saluran klien hanyalah salah satu kontrol dan kemudahan penggunaan bagi pengembang. Banyak pengembang yang nyaman bekerja dengan kelas dan objek akan lebih suka menggunakan objek klien WCF alih-alih saluran klien WCF.

Misalnya, lihat Cara: Menggunakan ChannelFactory.