Tutorial: Mengekspos layanan WCF REST lokal ke klien eksternal dengan menggunakan Azure WCF Relay

Artikel
08/11/2023

Tutorial ini menjelaskan cara membangun aplikasi klien WCF Relay dan layanan menggunakan Azure Relay. Seperti rekan-rekan WCF aslinya, layanan adalah konstruksi yang mengekspos satu atau beberapa titik akhir. Setiap titik akhir mengekspos satu atau beberapa operasi layanan. Titik akhir layanan menentukan alamat tempat layanan dapat ditemukan, pengikatan yang berisi informasi yang harus dikomunikasikan klien dengan layanan, dan kontrak yang menentukan fungsionalitas yang disediakan oleh layanan kepada kliennya. Perbedaan utama antara WCF dan WCF Relay adalah bahwa titik akhir terekspos di cloud, alih-alih secara lokal di komputer Anda.

Setelah mengerjakan urutan bagian dalam tutorial ini, Anda akan memiliki layanan yang berjalan. Anda juga akan memiliki klien yang dapat memanggil operasi layanan.

Anda melakukan tugas-tugas berikut dalam tutorial ini:

Instal prasyarat untuk tutorial ini adalah.
Membuat namespace layanan Relay.
Membuat kontrak layanan WCF.
Menerapkan kontrak WCF.
Menghosting dan menjalankan layanan WCF untuk mendaftar dengan layanan Relay.
Membuat klien WCF untuk kontrak layanan.
Mengonfigurasi klien WCF.
Menerapkan klien WCF.
Menjalankan aplikasi.

Prasyarat

Untuk menyelesaikan tutorial ini, Anda memerlukan prasyarat berikut:

Langganan Azure. Jika Anda tidak memilikinya, buat akun gratis sebelum Anda mulai.
Visual Studio 2015 atau versi yang lebih baru. Contoh dalam tutorial ini menggunakan Visual Studio 2019.
Azure SDK untuk .NET. Instal dari halaman unduhan SDK.

Membuat namespace layanan Relay

Langkah pertama adalah membuat namespace layanan, dan untuk mendapatkan kunci Tanda Tangan Akses Bersama (SAS). Namespace menyediakan pembatasan aplikasi untuk setiap aplikasi yang diekspos melalui layanan relai. Kunci SAS dibuat secara otomatis oleh sistem saat namespace layanan dibuat. Kombinasi nama namespace layanan dan kunci SAS menyediakan info masuk bagi Microsoft Azure untuk mengautentikasi akses ke aplikasi.

Masuk ke portal Azure.
Pilih Semua layanan di menu sebelah kiri. Pilih Integrasi, cari Relay, gerakkan mouse di atas Relay, lalu pilih Buat.
Pada halaman Buat namespace layanan, ikuti langkah-langkah berikut ini:
1. Pilih langganan Azure untuk membuat namespace.
2. Untuk Grup sumber daya, pilih grup sumber daya yang ada tempat namespace akan aktif, atau buat grup baru.
3. Masukkan nama untuk namespace layanan Relay.
4. Pilih wilayah tempat namespace Anda harus dihosting.
5. Pilih Tinjau + buat di bagian bawah halaman.
6. Pada halaman Tinjau + Buat, pilih Buat.
7. Setelah beberapa menit, Anda akan melihat halaman Relay untuk namespace.

Mendapatkan info masuk manajemen

Pada halaman Relay , pilih Kebijakan akses bersama di menu sebelah kiri. `
Pada halaman Kebijakan akses bersama, pilih RootManageSharedAccessKey.
Di bawah Kebijakan SAS: RootManageSharedAccessKey, pilih tombol Salin di sebelah String Koneksi Primer. Tindakan ini menyalin string koneksi ke clipboard untuk digunakan nanti. Tempelkan nilai ini ke Notepad atau beberapa lokasi sementara lainnya.
Ulangi langkah sebelumnya untuk menyalin dan menempelkan nilai Kunci primer ke lokasi sementara untuk digunakan nanti.

Menentukan kontrak layanan WCF

Kontrak layanan menentukan operasi apa yang didukung layanan. Operasi merupakan metode atau fungsi layanan web. Kontrak dibuat dengan menentukan antarmuka C++, C#, atau Visual Basic. Setiap metode di antarmuka sesuai dengan operasi layanan tertentu. Setiap antarmuka harus memiliki menerapkan atribut ServiceContractAttribute ke antarmuka, dan setiap operasi harus menerapkan atribut OperationContractAttribute ke operasi. Jika metode dalam antarmuka yang memiliki atribut ServiceContractAttribute tidak memiliki atribut OperationContractAttribute, metode tersebut tidak terekspos. Kode untuk tugas-tugas ini disediakan dalam contoh mengikuti prosedur. Untuk diskusi kontrak dan layanan yang lebih besar, lihat Merancang dan Menerapkan Layanan.

Membuat kontrak relai dengan antarmuka

Mulai Microsoft Visual Studio sebagai administrator. Untuk melakukannya, klik kanan ikon program Visual Studio, lalu pilih Jalankan sebagai administrator.
Di Visual Studio, pilih Buat proyek baru.
Di Buat proyek baru, pilih Aplikasi Konsol (.NET Framework) untuk C#, lalu pilih Berikutnya.
Beri nama proyek EchoService, lalu pilih Buat.
Di Penjelajah Solusi, klik kanan proyek, lalu pilih Kelola Paket NuGet. Di Manajer Paket NuGet, pilih Telusuri, lalu cari dan pilih WindowsAzure.ServiceBus. Klik Instal, lalu terima ketentuan penggunaan.

Paket ini otomatis menambahkan referensi ke pustaka Service Bus dan WCF System.ServiceModel. System.ServiceModel adalah namespace layanan yang memungkinkan akses terprogram ke fitur dasar WCF. Service Bus menggunakan banyak objek dan atribut WCF untuk menentukan kontrak layanan.
Tambahkan pernyataan using berikut ke bagian atas Program.cs:
```
using System.ServiceModel;
using Microsoft.ServiceBus;
```
Ubah nama untuk namespace layanan dari nama defaultnya EchoService menjadi Microsoft.ServiceBus.Samples.

Penting

Tutorial ini menggunakan namespace layanan C# Microsoft.ServiceBus.Samples yang merupakan namespace layanan jenis terkelola berbasis kontrak yang digunakan dalam file konfigurasi di bagian Konfigurasikan klien WCF. Anda dapat menentukan namespace layanan apa pun yang Anda inginkan saat membuat sampel ini. Namun, tutorial tidak akan berfungsi kecuali Anda kemudian memodifikasi namespace layanan kontrak dan layanan yang sesuai, dalam file konfigurasi aplikasi. Namespace layanan yang ditentukan dalam file App.config harus sama dengan namespace layanan yang ditentukan dalam file C# Anda.
Langsung setelah deklarasi namespace layanan Microsoft.ServiceBus.Samples, tetapi di dalam namespace layanan, tentukan antarmuka baru bernama IEchoContract dan terapkan atribut ServiceContractAttribute ke antarmuka dengan nilai namespace layanan https://samples.microsoft.com/ServiceModel/Relay/. Tempelkan kode berikut setelah deklarasi namespace layanan:
```
[ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
public interface IEchoContract
{
}
```
Nilai namespace layanan berbeda dari namespace layanan yang Anda gunakan di seluruh cakupan kode Anda. Sebagai gantinya, nilai namespace layanan digunakan sebagai pengidentifikasi unik untuk kontrak ini. Menentukan namespace layanan secara eksplisit mencegah nilai namespace layanan default ditambahkan ke nama kontrak.

Catatan

Biasanya, namespace layanan kontrak layanan berisi skema penamaan yang menyertakan informasi versi. Mencakup informasi versi di namespace layanan kontrak layanan memungkinkan layanan mengisolasi perubahan besar dengan menentukan kontrak layanan baru dengan namespace layanan baru dan mengeksposnya pada titik akhir baru. Dengan cara ini, klien dapat terus menggunakan kontrak layanan lama tanpa harus diperbarui. Informasi versi dapat terdiri dari tanggal atau nomor build. Untuk mengetahui informasi selengkapnya, lihat Penerapan Versi Layanan. Untuk tutorial ini, skema penamaan namespace layanan kontrak layanan tidak berisi informasi versi.
Di antarmuka IEchoContract, nyatakan metode untuk operasi tunggal yang diekspos kontrak IEchoContract di antarmuka dan terapkan atribut OperationContractAttribute ke metode yang ingin Anda ekspos sebagai bagian dari kontrak WCF Relay publik, sebagai berikut:
```
[OperationContract]
string Echo(string text);
```
Langsung setelah definisi antarmuka IEchoContract, nyatakan saluran yang mewarisi dari kedua IEchoContract dan juga ke antarmuka IClientChannel, seperti yang ditunjukkan di sini:
```
public interface IEchoChannel : IEchoContract, IClientChannel { }
```
Saluran adalah objek WCF tempat layanan dan klien meneruskan informasi satu sama lain. Nantinya, Anda akan menulis kode terhadap saluran untuk menggaungkan informasi di antara kedua aplikasi.
Pilih Build>Solusi Build atau pilih Ctrl+Shift+B untuk mengonfirmasi keakuratan pekerjaan Anda sejauh ini.

Contoh kontrak WCF

Kode berikut menunjukkan antarmuka dasar yang menentukan kontrak WCF Relay.

using System;
using System.ServiceModel;

namespace Microsoft.ServiceBus.Samples
{
    [ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        String Echo(string text);
    }

    public interface IEchoChannel : IEchoContract, IClientChannel { }

    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

Setelah antarmuka dibuat, Anda dapat menerapkan antarmuka.

Menerapkan kontrak WCF

Membuat relai Azure mengharuskan Anda terlebih dahulu membuat kontrak dengan menggunakan antarmuka. Untuk mengetahui informasi selengkapnya tentang membuat antarmuka, lihat bagian sebelumnya. Prosedur berikutnya menerapkan antarmuka. Tugas ini melibatkan pembuatan kelas bernama EchoService yang menerapkan antarmuka IEchoContract yang ditentukan oleh pengguna. Setelah menerapkan antarmuka, Anda kemudian mengonfigurasi antarmuka menggunakan file konfigurasi App.config. File konfigurasi berisi informasi yang diperlukan untuk aplikasi. Informasi ini mencakup nama layanan, nama kontrak, dan jenis protokol yang digunakan untuk berkomunikasi dengan layanan relai. Kode yang digunakan untuk tugas-tugas ini disediakan dalam contoh yang mengikuti prosedur. Untuk diskusi yang lebih umum tentang cara menerapkan kontrak layanan, lihat Menerapkan Kontrak Layanan.

Buat kelas baru bernama EchoService setelah definisi antarmuka IEchoContract. Kelas EchoService menerapkan antarmuka IEchoContract.
```
class EchoService : IEchoContract
{
}
```
Mirip dengan implementasi antarmuka lainnya, Anda dapat menerapkan definisi tersebut dalam file yang berbeda. Namun, untuk tutorial ini, implementasi berada dalam file yang sama dengan definisi antarmuka dan metode Main().
Terapkan atribut ServiceBehaviorAttribute ke antarmuka IEchoContract. Atribut ini menentukan nama layanan dan namespace layanan. Setelah melakukannya, kelas EchoService muncul sebagai berikut:
```
[ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
class EchoService : IEchoContract
{
}
```

Terapkan metode Echo yang ditentukan dalam antarmuka IEchoContract di kelas EchoService.

public string Echo(string text)
{
    Console.WriteLine("Echoing: {0}", text);
    return text;
}

Pilih Build>Solusi Build atau pilih Ctrl+Shift+B.

Menentukan konfigurasi untuk host layanan

File konfigurasi mirip dengan file konfigurasi WCF. Ini termasuk nama layanan, titik akhir, dan pengikatan data. Titik akhir adalah lokasi yang diekspos Azure Relay untuk klien dan dihosting untuk berkomunikasi satu sama lain. Pengikatan data adalah jenis protokol yang digunakan untuk berkomunikasi. Perbedaan utamanya adalah bahwa titik akhir layanan yang dikonfigurasi ini mengacu pada pengikatan data NetTcpRelayBinding, yang bukan merupakan bagian dari .NET Framework. NetTcpRelayBinding adalah salah satu pengikatan data yang ditentukan oleh layanan.

Di Penjelajah Solusi, klik dua kali App.config untuk membuka file di editor Visual Studio.
<appSettings> Di elemen , ganti tempat penampung dengan nama namespace Azure Relay Anda, dan kunci SAS yang Anda salin di langkah sebelumnya.
Di dalam tag <system.serviceModel>, tambahkan elemen <services>. Anda dapat menentukan beberapa aplikasi relai dalam satu file konfigurasi. Namun, tutorial ini menentukan satu saja.
```
<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <services>

    </services>
  </system.serviceModel>
</configuration>
```
Di dalam elemen <services>, tambahkan elemen <service> untuk menentukan nama layanan.
```
<service name="Microsoft.ServiceBus.Samples.EchoService">
</service>
```
Di dalam elemen <service>, tentukan lokasi kontrak titik akhir, dan juga jenis pengikatan data untuk titik akhir.
```
<endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding"/>
```
Titik akhir menentukan tempat klien akan mencari aplikasi host. Kemudian, tutorial menggunakan langkah ini untuk membuat URI yang sepenuhnya mengekspos host melalui Azure Relay. Pengikatan data menyatakan bahwa kami menggunakan TCP sebagai protokol untuk berkomunikasi dengan layanan relai.
Pilih Build>Solusi Build atau pilih Ctrl+Shift+B untuk mengonfirmasi keakuratan pekerjaan Anda sejauh ini.

Contoh penerapan kontrak layanan

Kode berikut menunjukkan penerapan kontrak layanan.

[ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]

    class EchoService : IEchoContract
    {
        public string Echo(string text)
        {
            Console.WriteLine("Echoing: {0}", text);
            return text;
        }
    }

Kode berikut menunjukkan format dasar file App.config yang terkait dengan host layanan.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="Microsoft.ServiceBus.Samples.EchoService">
        <endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding" />
      </service>
    </services>
    <extensions>
      <bindingExtensions>
        <add name="netTcpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
</configuration>

Menghosting dan menjalankan layanan WCF untuk mendaftar dengan layanan relai

Langkah ini menjelaskan cara menjalankan layanan Azure Relay.

Membuat info masuk relai

Di Main(), buat dua variabel untuk menyimpan namespace layanan dan kunci SAS yang dibaca dari jendela konsol.
```
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS key: ");
string sasKey = Console.ReadLine();
```
Kunci SAS akan digunakan nanti untuk mengakses proyek Anda. Namespace layanan diteruskan sebagai parameter ke CreateServiceUri untuk membuat URI layanan.

Dengan menggunakan objek TransportClientEndpointBehavior, nyatakan bahwa Anda akan menggunakan kunci SAS sebagai jenis info masuk. Tambahkan kode berikut langsung setelah kode ditambahkan di langkah terakhir.

TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);

Membuat alamat dasar bagi layanan

Setelah kode yang Anda tambahkan di bagian sebelumnya, buat instans Uri untuk alamat dasar layanan. URI ini menentukan skema Service Bus, namespace layanan, dan jalur antarmuka layanan.

Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");

Nilai "sb" adalah singkatan dari skema Service Bus. Ini menunjukkan bahwa kami menggunakan TCP sebagai protokol. Skema ini sebelumnya juga ditunjukkan dalam file konfigurasi, saat NetTcpRelayBinding ditentukan sebagai pengikatan data.

Untuk tutorial ini, URI adalah sb://putServiceNamespaceHere.windows.net/EchoService.

Membuat dan mengonfigurasi host layanan

Masih bekerja di Main(), atur mode konektivitas ke AutoDetect.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```
Mode konektivitas menjelaskan protokol yang digunakan layanan untuk berkomunikasi dengan layanan relai; baik HTTP atau TCP. Dengan menggunakan pengaturan AutoDetect default, layanan mencoba menyambungkan ke Azure Relay melalui TCP jika tersedia, dan HTTP jika TCP tidak tersedia. Hasil ini berbeda dari protokol yang ditentukan layanan untuk komunikasi klien. Protokol tersebut ditentukan oleh pengikatan data yang digunakan. Misalnya, layanan dapat menggunakan pengikatan data BasicHttpRelayBinding, yang menentukan bahwa titik akhirnya berkomunikasi dengan klien melalui HTTP. Layanan yang sama dapat menentukan ConnectivityMode.AutoDetect sehingga layanan berkomunikasi dengan Azure Relay melalui TCP.
Buat host layanan, menggunakan URI yang dibuat sebelumnya di bagian ini.
```
ServiceHost host = new ServiceHost(typeof(EchoService), address);
```
Host layanan adalah objek WCF yang membuat instans layanan. Di sini, Anda meneruskan jenis layanan yang ingin dibuat, jenis EchoService ke host layanan, dan juga ke alamat tempat Anda ingin mengekspos layanan.
Di bagian atas file Program.cs, tambahkan referensi ke System.ServiceModel.Description dan Microsoft.ServiceBus.Description.
```
using System.ServiceModel.Description;
using Microsoft.ServiceBus.Description;
```
Kembali ke Main(), konfigurasikan titik akhir untuk mengaktifkan akses publik.
```
IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
```
Langkah ini menginformasikan layanan relai bahwa aplikasi Anda dapat ditemukan secara publik dengan memeriksa umpan Atom untuk proyek Anda. Jika Anda mengatur DiscoveryType ke private, klien masih dapat mengakses layanan. Namun, layanan tidak akan muncul saat mencari namespace layanan Relay. Sebaliknya, klien harus tahu jalur titik akhir sebelumnya.
Menerapkan kredensial layanan ke titik akhir layanan yang ditentukan dalam file App.config:
```
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
    endpoint.Behaviors.Add(serviceRegistrySettings);
    endpoint.Behaviors.Add(sasCredential);
}
```
Seperti yang dinyatakan sebelumnya, Anda dapat mendeklarasikan beberapa layanan dan titik akhir dalam file konfigurasi. Jika Anda melakukannya, kode ini akan melintasi file konfigurasi dan mencari setiap titik akhir tempat info masuk Anda diterapkan. Untuk tutorial ini, file konfigurasi hanya memiliki satu titik akhir.

Membuka host layanan

Masih dalam Main(), tambahkan baris berikut untuk membuka layanan.
```
host.Open();
```

Beri tahu pengguna bahwa layanan sedang berjalan, dan jelaskan cara mematikan layanan.

Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();

Setelah selesai, tutup host layanan.
```
host.Close();
```
Pilih Ctrl+Shift+B untuk membuat proyek.

Contoh yang menghosting layanan di aplikasi konsol

Kode layanan yang telah selesai akan muncul sebagai berikut. Contoh berikut mencakup kontrak layanan dan penerapan dari langkah sebelumnya dalam tutorial, dan menghosting layanan dalam aplikasi konsol.

using System;
using System.ServiceModel;
using System.ServiceModel.Description;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Description;

namespace Microsoft.ServiceBus.Samples
{
    [ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        String Echo(string text);
    }

    public interface IEchoChannel : IEchoContract, IClientChannel { };

    [ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    class EchoService : IEchoContract
    {
        public string Echo(string text)
        {
            Console.WriteLine("Echoing: {0}", text);
            return text;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;         

            Console.Write("Your Service Namespace: ");
            string serviceNamespace = Console.ReadLine();
            Console.Write("Your SAS key: ");
            string sasKey = Console.ReadLine();

           // Create the credentials object for the endpoint.
            TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
            sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);

            // Create the service URI based on the service namespace.
            Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");

            // Create the service host reading the configuration.
            ServiceHost host = new ServiceHost(typeof(EchoService), address);

            // Create the ServiceRegistrySettings behavior for the endpoint.
            IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);

            // Add the Relay credentials to all endpoints specified in configuration.
            foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
            {
                endpoint.Behaviors.Add(serviceRegistrySettings);
                endpoint.Behaviors.Add(sasCredential);
            }

            // Open the service.
            host.Open();

            Console.WriteLine("Service address: " + address);
            Console.WriteLine("Press [Enter] to exit");
            Console.ReadLine();

            // Close the service.
            host.Close();
        }
    }
}

Membuat klien WCF untuk kontrak layanan

Tugas berikutnya adalah membuat aplikasi klien dan menentukan kontrak layanan yang akan Anda terapkan nanti. Langkah ini menyerupai langkah yang digunakan untuk membuat layanan: menentukan kontrak, mengedit file App.config, menggunakan info masuk untuk menyambungkan ke layanan relai, dan sebagainya. Kode yang digunakan untuk tugas-tugas ini disediakan dalam contoh yang mengikuti prosedur.

Buat proyek baru di solusi Visual Studio saat ini untuk klien:
1. Di Penjelajah Solusi, klik kanan solusi saat ini (bukan proyek), lalu pilih Tambahkan>Proyek Baru.
2. Di Tambahkan proyek baru, pilih Aplikasi Konsol (.NET Framework) untuk C#, lalu pilih Berikutnya.
3. Beri nama proyek EchoClient, lalu pilih Buat.
Di Penjelajah Solusi, di proyek EchoClient, klik dua kali Program.cs untuk membuka file di editor, jika belum dibuka.
Ubah nama untuk namespace layanan dari nama defaultnya EchoClient menjadi Microsoft.ServiceBus.Samples.
Instal paket Service Bus NuGet:
1. Di Penjelajah Solusi, klik kanan EchoClient lalu pilih Kelola Paket NuGet.
2. Pilih Telusuri, lalu cari dan pilih WindowsAzure.ServiceBus. Klik Instal, lalu terima ketentuan penggunaan.
Tambahkan pernyataan using untuk namespace layanan System.ServiceModel dalam file Program.cs.
```
using System.ServiceModel;
```

Tambahkan definisi kontrak layanan ke namespace layanan, seperti yang ditunjukkan dalam contoh berikut. Definisi ini identik dengan definisi yang digunakan dalam proyek Layanan. Tambahkan kode ini di bagian atas namespace layanan Microsoft.ServiceBus.Samples.

[ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
public interface IEchoContract
{
    [OperationContract]
    string Echo(string text);
}

public interface IEchoChannel : IEchoContract, IClientChannel { }

Pilih Ctrl+Shift+B untuk membuat klien.

Contoh proyek EchoClient

Kode berikut menunjukkan status saat ini file Program.cs dalam proyek EchoClient.

using System;
using Microsoft.ServiceBus;
using System.ServiceModel;

namespace Microsoft.ServiceBus.Samples
{

    [ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        string Echo(string text);
    }

    public interface IEchoChannel : IEchoContract, IClientChannel { }


    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

Mengonfigurasi klien WCF

Di langkah ini, Anda membuat file App.config untuk aplikasi klien dasar yang mengakses layanan yang dibuat sebelumnya di tutorial ini. File App.config ini menentukan kontrak, pengikatan data, dan nama titik akhir. Kode yang digunakan untuk tugas-tugas ini disediakan dalam contoh yang mengikuti prosedur.

Di Penjelajah Solusi, di proyek EchoClient, klik dua kali App.config untuk membuka file di editor Visual Studio.
Di elemen <appSettings>, ganti tempat penampung dengan nama untuk namespace layanan Anda, dan kunci SAS yang Anda salin di langkah sebelumnya.

Di dalam elemen system.serviceModel, tambahkan elemen <client>.

<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <client>
    </client>
  </system.serviceModel>
</configuration>

Kode ini menyatakan bahwa Anda menentukan aplikasi klien bergaya WCF.

Di dalam elemen client, tentukan nama, kontrak, dan jenis pengikatan data untuk titik akhir.
```
<endpoint name="RelayEndpoint"
                contract="Microsoft.ServiceBus.Samples.IEchoContract"
                binding="netTcpRelayBinding"/>
```
Kode ini menentukan nama titik akhir. Ini juga menentukan kontrak yang ditentukan dalam layanan dan fakta bahwa aplikasi klien menggunakan TCP untuk berkomunikasi dengan Azure Relay. Nama titik akhir digunakan di langkah berikutnya untuk menautkan konfigurasi titik akhir ini dengan URI layanan.
Pilih File>Simpan Semua.

Contoh file App.config

Kode berikut menunjukkan file App.config untuk klien Echo.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <client>
      <endpoint name="RelayEndpoint"
                      contract="Microsoft.ServiceBus.Samples.IEchoContract"
                      binding="netTcpRelayBinding"/>
    </client>
    <extensions>
      <bindingExtensions>
        <add name="netTcpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
</configuration>

Menerapkan klien WCF

Di bagian ini, Anda menerapkan aplikasi klien dasar yang mengakses layanan yang dibuat sebelumnya dalam tutorial ini. Mirip dengan layanan tersebut, klien melakukan banyak operasi yang sama untuk mengakses Azure Relay:

Mengatur mode konektivitas.
Membuat URI yang menemukan layanan host.
Menentukan info masuk keamanan.
Menerapkan info masuk ke koneksi.
Membuka koneksi.
Melakukan tugas khusus aplikasi.
Menutup koneksi.

Namun, salah satu perbedaan utama adalah bahwa aplikasi klien menggunakan saluran untuk tersambung ke layanan relai. Layanan ini menggunakan panggilan ke ServiceHost. Kode yang digunakan untuk tugas-tugas ini disediakan dalam contoh yang mengikuti prosedur.

Menerapkan aplikasi klien

Atur mode konektivitas ke AutoDetect. Tambahkan kode berikut di dalam metode Main() aplikasi EchoClient.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```

Tentukan variabel guna menyimpan nilai untuk namespace layanan, dan kunci SAS yang dibaca dari konsol.

Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS Key: ");
string sasKey = Console.ReadLine();

Buat URI yang menentukan lokasi host di proyek Relay Anda.

Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");

Buat objek info masuk untuk titik akhir namespace layanan Anda.

TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);

Buat pabrik saluran yang memuat konfigurasi yang dijelaskan dalam file App.config.
```
ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
```
Pabrik saluran adalah objek WCF yang membuat saluran tempat layanan dan aplikasi klien berkomunikasi.

Terapkan info masuk.

channelFactory.Endpoint.Behaviors.Add(sasCredential);

Buat dan buka saluran ke layanan.

IEchoChannel channel = channelFactory.CreateChannel();
channel.Open();

Tulis antarmuka pengguna dasar dan fungsionalitas untuk gema.

Console.WriteLine("Enter text to echo (or [Enter] to exit):");
string input = Console.ReadLine();
while (input != String.Empty)
{
    try
    {
        Console.WriteLine("Server echoed: {0}", channel.Echo(input));
    }
    catch (Exception e)
    {
        Console.WriteLine("Error: " + e.Message);
    }
    input = Console.ReadLine();
}

Kode menggunakan instans objek saluran sebagai proksi untuk layanan.

Tutup saluran, dan tutup pabrik.

channel.Close();
channelFactory.Close();

Contoh kode untuk tutorial ini

Kode layanan lengkap akan muncul sebagai berikut. Kode ini menunjukkan cara membuat aplikasi klien, cara memanggil operasi layanan, dan cara menutup klien setelah panggilan operasi selesai.

using System;
using Microsoft.ServiceBus;
using System.ServiceModel;

namespace Microsoft.ServiceBus.Samples
{
    [ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        String Echo(string text);
    }

    public interface IEchoChannel : IEchoContract, IClientChannel { }

    class Program
    {
        static void Main(string[] args)
        {
            ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;


            Console.Write("Your Service Namespace: ");
            string serviceNamespace = Console.ReadLine();
            Console.Write("Your SAS Key: ");
            string sasKey = Console.ReadLine();



            Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");

            TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
            sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);

            ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));

            channelFactory.Endpoint.Behaviors.Add(sasCredential);

            IEchoChannel channel = channelFactory.CreateChannel();
            channel.Open();

            Console.WriteLine("Enter text to echo (or [Enter] to exit):");
            string input = Console.ReadLine();
            while (input != String.Empty)
            {
                try
                {
                    Console.WriteLine("Server echoed: {0}", channel.Echo(input));
                }
                catch (Exception e)
                {
                    Console.WriteLine("Error: " + e.Message);
                }
                input = Console.ReadLine();
            }

            channel.Close();
            channelFactory.Close();

        }
    }
}

Menjalankan aplikasi

Tekan Ctrl+Shift+B untuk membuat solusi. Tindakan ini membuat proyek klien dan proyek layanan yang Anda buat di langkah-langkah sebelumnya.
Sebelum menjalankan aplikasi klien, Anda harus memastikan bahwa aplikasi layanan berjalan. Di Penjelajah Solusi, klik kanan solusi EchoService, lalu pilih Properti.
Di Halaman Properti, Properti Umum>Proyek Startup, lalu pilih Beberapa proyek startup. Pastikan EchoService muncul pertama kali dalam daftar.
Atur kotak Tindakan untuk proyek EchoService dan EchoClient ke Mulai.
Pilih Dependensi Proyek. Di Proyek, pilih EchoClient. Untuk Tergantung pada, pastikan EchoService dipilih.
Pilih OK untuk menutup Halaman Properti.
Pilih F5 untuk menjalankan kedua proyek.
Kedua jendela konsol terbuka dan meminta Anda untuk nama namespace layanan. Layanan harus berjalan terlebih dahulu, jadi di jendela konsol EchoService, masukkan namespace layanan lalu pilih Enter.
Selanjutnya, konsol meminta kunci SAS Anda. Masukkan tombol SAS, lalu pilih Enter.

Berikut adalah contoh output dari jendela konsol. Nilai di sini hanyalah contoh.

Your Service Namespace: myNamespace

Your SAS Key: <SAS key value>

Aplikasi layanan mencetakalamat tempat aplikasi mendengarkan ke jendela konsol, seperti yang terlihat dalam contoh berikut.

Service address: sb://mynamespace.servicebus.windows.net/EchoService/

Press [Enter] to exit
Di jendela konsol EchoClient, masukkan informasi yang sama dengan yang Anda masukkan sebelumnya untuk aplikasi layanan. Masukkan namespace layanan dan nilai kunci SAS yang sama untuk aplikasi klien.
Setelah memasukkan nilai-nilai ini, klien membuka saluran ke layanan dan meminta Anda memasukkan beberapa teks seperti yang terlihat dalam contoh output konsol berikut.

Enter text to echo (or [Enter] to exit):

Masukkan beberapa teks untuk dikirim ke aplikasi layanan, lalu pilih Enter. Teks ini dikirim ke layanan melalui operasi layanan Echo dan muncul di jendela konsol layanan seperti pada contoh output berikut.

Echoing: My sample text

Aplikasi klien menerima nilai pengembalian operasi Echo, yang merupakan teks asli, dan mencetaknya ke jendela konsolnya. Teks berikut adalah contoh output dari jendela konsol klien.

Server echoed: My sample text
Anda dapat terus mengirim pesan teks dari klien ke layanan dengan cara ini. Setelah selesai, pilih Enter di jendela konsol layanan dan klien untuk mengakhiri kedua aplikasi.

Langkah berikutnya

Lanjutkan ke tutorial berikut:

Mengekspos layanan WCF REST lokal ke klien di luar jaringan Anda

Bagikan melalui