WCF-概要

WCFはWindows Communication Foundationの略です。 WCFの基本的な機能は相互運用性です。これは、サービス指向アプリケーションの構築に使用されるマイクロソフトの最新技術の1つです。 HTTP要求が均一に表されるメッセージベースの通信の概念に基づいて、WCFでは、さまざまなトランスポートメカニズムに関係なく、統一されたAPIを使用できます。

WCFは2006年にWindows Vistaの.NETフレームワークの一部として初めてリリースされ、その後数回更新されました。 WCF 4.5は、現在広く使用されている最新バージョンです。

WCFアプリケーションは3つのコンポーネントで構成されています-

WCFサービス、
WCFサービスホスト、および
WCFサービスクライアント。

WCFプラットフォームは、サービスモデルとも呼ばれます。

WCFの基本概念

メッセージ

これは、身体から離れたいくつかの部分で構成される通信ユニットです。メッセージインスタンスは、クライアントとサービス間のすべてのタイプの通信で送受信されます。

終点

メッセージが送信または受信されるアドレスを定義します。また、メッセージのセットを定義するとともに、メッセージの送信方法を記述する通信メカニズムも指定します。エンドポイントの構造は、次の部分で構成されます-

住所

アドレスは、メッセージを受信する正確な場所を指定し、Uniform Resource Identifier（URI）として指定されます。 scheme：//domain [：port]/[path]で表されます。以下に記載されているアドレスを見てください-

net.tcp：//localhost：9000/ServiceA

ここで、「net.tcp」はTCPプロトコルのスキームです。ドメインは「localhost」であり、これはマシンまたはWebドメインの名前にすることができ、パスは「ServiceA」です。

製本

エンドポイントが通信する方法を定義します。通信のためのインフラストラクチャを作成するいくつかのバインディング要素で構成されます。たとえば、バインディングは、TCP、HTTPなどのトランスポートに使用されるプロトコル、メッセージエンコーディングの形式、およびセキュリティと信頼性に関連するプロトコルを示します。

契約

これは、エンドポイントがクライアントに公開する機能を指定する操作のコレクションです。通常、インターフェイス名で構成されます。

ホスティング

WCFの観点からのホスティングとは、セルフホスティング、IISホスティング、WASホスティングなど、利用可能な多くのオプションを通じて実行できるWCFサービスホスティングのことです。

メタデータ

これは、クライアントアプリケーションとWCFサービス間の簡単な相互作用を促進するため、WCFの重要な概念です。通常、WCFサービスのメタデータは有効にすると自動的に生成され、これはサービスとそのエンドポイントの検査によって行われます。

WCFクライアント

メソッドの形式でサービス操作を公開するために作成されるクライアントアプリケーションは、WCFクライアントと呼ばれます。これは、サービスホスティングを行うアプリケーションも含め、どのアプリケーションでもホストできます。

チャネル

チャネルは、クライアントがサービスと通信するための媒体です。さまざまなタイプのチャネルがスタックされ、チャネルスタックと呼ばれます。

SOAP

「シンプルオブジェクトアクセスプロトコル」と呼ばれていますが、SOAPはトランスポートプロトコルではありません。代わりに、ヘッダーと本文セクションで構成されるXMLドキュメントです。

WCFの利点

他のサービスとの相互運用が可能です。これは、クライアントとサービスの両方に.Netが必要な.NET Remotingとは対照的です。
WCFサービスは、ASMX（Active Server Methods）Webサービスと比較して、信頼性とセキュリティが強化されています。
セキュリティモデルの実装とWCFのバインディングの変更には、コーディングの大きな変更は必要ありません。制約を満たすには、わずかな構成の変更が必要です。
WCFにはログメカニズムが組み込まれていますが、他のテクノロジでは、必要なコーディングを行うことが不可欠です。
WCFは、AJAXとJSON（JavaScriptオブジェクト表記法）のサポートを統合しています。
スケーラビリティと、今後のWebサービス標準のサポートを提供します。
非常に堅牢なデフォルトのセキュリティメカニズムがあります。

WCF-対Webサービス

WCFとWebサービスの間に存在するいくつかの大きな違いがあります。以下にリストします。

属性-WCFサービスはServiceContractおよびOperationContract属性によって定義されますが、WebサービスはWebServiceおよびWebMethod属性によって定義されます。
プロトコル-WCFは、HTTP、名前付きパイプ、TCP、MSMQなどのさまざまなプロトコルをサポートしていますが、WebサービスはHTTPプロトコルのみをサポートしています。
ホスティングメカニズム-WCFホスティングにはさまざまなアクティベーションメカニズムがあります。つまり、IIS（インターネットインフォメーションサービス）、WAS（Windowsアクティベーションサービス）、セルフホスティング、およびWindowsサービスですが、WebサービスはIISによってのみホストされます。
サービス-WCFは堅牢なセキュリティ、信頼できるメッセージング、トランザクション、相互運用性をサポートしますが、Webサービスはセキュリティサービスのみをサポートします。
Serializer -WCFはSystem.Runtime.Serializationを使用してDataContractシリアライザーをサポートしますが、WebサービスはSystem.Xml.Serializationを使用してXMLシリアライザーをサポートします。
ツール-ServiceMetadataツール（svcutil.exe）はWCFサービスのクライアント生成に使用され、WSDL.EXEツールはWebサービスのクライアント生成に使用されます。
例外処理-WCFでは、FaultContractを使用することにより、未処理の例外がより適切に処理されます。 SOAPエラーとしてWebサービスのようにクライアントに返されません。
ハッシュテーブル-WCFでハッシュテーブルをシリアル化することは可能ですが、Webサービスではそうではありません。
バインディング-WCFは、BasicHttpBinding、WSDualHttpBinding、WSHttpBindingなどのいくつかのタイプのバインディングをサポートしますが、WebサービスはSOAPまたはXMLのみをサポートします。
マルチスレッド-WCFはServiceBehaviorクラスを使用してマルチスレッドをサポートしていますが、これはWebサービスではサポートされていません。
二重サービス操作-WCFは、一方向および要求応答サービス操作のサポートとは別に二重サービス操作をサポートしますが、Webサービスは二重サービス操作をサポートしません。

WCF-開発者ツール

WCFサービスアプリケーションの開発には、主に2つのツールがあります。MicrosoftVisual StudioとCodePlexです。 Microsoft Visual Studioは、ASP.NET Webアプリケーション、デスクトップアプリケーション、モバイルアプリケーションなど、多数の多様なアプリケーションの開発に必要な開発ツールの完全なパッケージです。

Microsoft Visual Studioは.NETフレームワーク機能を使用します。一方、CodePlexは、Microsoftのオープンソースプロジェクトホスティングサイトで、WCFサービスアプリケーション開発用のいくつかの無料ツールを提供しています。

マイクロソフトビジュアルスタジオ

Microsoft Visual Studioには多くのエディションがあり、最初はそれ（Visual Studio 2005）はWCF開発の熱烈なサポーターではありませんでした。現在、Visual Studio 2008は、WCFサービスアプリケーションの開発に使用できる唯一のMicrosoft IDEです。

現在、Microsoft Visual Studio 2010の最新バージョンは、WCFサービスアプリケーションを開発するための推奨ツールでもあります。 Visual Studioには、WCFサービスアプリケーションを開発するための既製のテンプレートもあります。

このようなテンプレートを選択すると、次の目的のためにファイルが追加されます-

サービス契約
サービス実装
サービス構成

必要な属性が自動的に追加され、コードを記述しなくても、Microsoft Visual Studioによって単純な「Hello World」サービスが作成されます。

CodePlex

CodePlexは、2006年6月にMicrosoftによって開始され、それ以来、世界中の多数の開発者が.NETプロジェクトを正常に作成するために使用しています。 WCFサービスアプリケーションを開発するためにCodePlexが提供するツールのいくつかは次のとおりです-

wscf.blue -これは、Microsoft Visual Studioアドインであり、WCFサービス操作の定義を容易にし、それに応じてコードスケルトンを生成する「契約優先」の開発ツールセットです。同じための重要なリンクは-https://wscfblue.codeplex.com/.[https://wscfblue.codeplex.com]です。
WCFProxyGenerator -これはMicrosoft Visual Studioアドインでもあります。このツールは、クライアント側の生成を拡張し、追加のエラー処理を提供するために使用されます。この特定の開発ツールに関する詳細については、https://wcfproxygenerator.codeplex.comにアクセスしてください。
WCFMock -WCFサービスのテストは複雑な作業になる可能性があり、この開発ツールは便利なクラスによるWCFサービスの単体テストに便利なソリューションを提供します。このツールの詳細については、https://wcfmock.codeplex.com/[https://wcfmock.codeplex.com]をご覧ください。

WCFStormは、WCFサービスアプリケーションを簡単に開発するためのもう1つの無料ツールです。 LITEバージョンは、WCFサービスの動的な呼び出しとテスト、サービスバインディングの編集、WCF URLエンドポイントの変更など、多くの優れた機能を提供します。

WCF-アーキテクチャ

WCFには、さまざまな分散アプリケーションの開発を十分にサポートする階層化アーキテクチャがあります。アーキテクチャについては、以下で詳しく説明します。

WCFアーキテクチャ

契約

コントラクトレイヤーは、アプリケーションレイヤーのすぐ隣にあり、サービスの操作と作成するアクセス可能な情報の種類を指定する実際のコントラクトの情報と同様の情報を含みます。契約は基本的に以下で簡単に説明する4つのタイプです-

サービス契約-この契約は、エンドポイントの提供、および通信プロセスで使用されるプロトコルに関する情報をクライアントだけでなく外部にも提供します。
データ契約-サービスによって交換されるデータは、データ契約によって定義されます。クライアントとサービスの両方がデータ契約に同意する必要があります。
メッセージコントラクト-データコントラクトはメッセージコントラクトによって制御されます。主に、SOAPメッセージパラメータの型フォーマットのカスタマイズを行います。ここで、WCFは通信を目的としてSOAP形式を採用していることに注意してください。 SOAPはSimple Object Access Protocolの略です。
ポリシーとバインディング-サービスとの通信には特定の前提条件があり、そのような条件はポリシーとバインディング契約によって定義されます。クライアントはこの契約に従う必要があります。

サービスランタイム

サービスランタイムレイヤーは、コントラクトレイヤーのすぐ下にあります。実行時に発生するさまざまなサービスの動作を指定します。構成を実行し、サービスランタイムの下で実行できる動作には多くの種類があります。

スロットル動作-処理されるメッセージの数を管理します。
エラー動作-内部サービスエラー発生の結果を定義します。
メタデータの動作-メタデータの外部への可用性を指定します。
インスタンスの動作-クライアントが使用できるようにするために作成する必要があるインスタンスの数を定義します。
トランザクション動作-障害が発生した場合のトランザクション状態の変更を有効にします。
ディスパッチ動作-メッセージがWCFのインフラストラクチャによって処理される方法を制御します。
同時動作-クライアント/サーバー通信中に並行して実行される機能を制御します。
Parameter Filtering -メソッドが呼び出される前にメソッドのパラメーターを検証するプロセスを特徴としています。

メッセージング

複数のチャネルで構成されるこのレイヤーは、主に2つのエンドポイント間で通信されるメッセージコンテンツを処理します。一連のチャネルはチャネルスタックを形成し、チャネルスタックを構成する2つの主要なチャネルは次のとおりです-

トランスポートチャネル-これらのチャネルはスタックの下部にあり、HTTP、TCP、ピアツーピア、名前付きパイプ、MSMQなどのトランスポートプロトコルを使用してメッセージを送受信する責任があります。
プロトコルチャネル-スタックの最上部に存在するこれらのチャネルは、階層化チャネルとも呼ばれ、メッセージを変更することでワイヤレベルのプロトコルを実装します。

アクティベーションとホスティング

WCFアーキテクチャの最後の層は、サービスが実際にホストされる場所、またはクライアントが簡単にアクセスできるように実行できる場所です。これは、以下で簡単に説明するさまざまなメカニズムによって行われます。

IIS -IISはインターネットインフォメーションサービスの略です。サービスによってHTTPプロトコルを使用することにより、無数の利点が提供されます。ここでは、サービスコードをアクティブにするためのホストコードは必要ありません。代わりに、サービスコードが自動的にアクティブになります。
Windows Activation Service -これは一般にWASとして知られており、IIS 7.0に付属しています。ここでは、TCPプロトコルまたはNamedpipeプロトコルを使用して、HTTPベースの通信と非HTTPベースの通信の両方が可能です。
セルフホスティング-これは、WCFサービスがコンソールアプリケーションとしてセルフホストされるメカニズムです。このメカニズムは、目的のプロトコルの選択と独自のアドレッシングスキームの設定に関して驚くべき柔軟性を提供します。
* Windowsサービス*-このメカニズムを使用してWCFサービスをホストすると、実行時のアクティブ化が行われないため、サービスがアクティブ化されたままで、クライアントからアクセスできるため、有利です。

WCF-WCFサービスの作成

WCFサービスの作成は、Microsoft Visual Studio 2012を使用した簡単なタスクです。以下に、概念をよりよく理解するために、必要なすべてのコーディングとともにWCFサービスを作成するための段階的な方法を示します。

Visual Studio 2012を起動します。 *新しいプロジェクトをクリックし、Visual C＃タブでWCFオプションを選択します。

WCF Creating Service1

加算、減算、乗算、除算などの基本的な算術演算を実行するWCFサービスが作成されます。メインコードは2つの異なるファイル（1つのインターフェイスと1つのクラス）にあります。

WCFには、1つ以上のインターフェイスとその実装クラスが含まれています。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;

namespace WcfServiceLibrary1 {
  //NOTE: You can use the "Rename" command on the "Refactor" menu to
  //change the interface name "IService1" in both code and config file
  //together.

   [ServiceContract]
   Public interface IService1 {
      [OperationContract]
      int sum(int num1, int num2);

      [OperationContract]
      int Subtract(int num1, int num2);

      [OperationContract]
      int Multiply(int num1, int num2);

      [OperationContract]
      int Divide(int num1, int num2);
   }

  //Use a data contract as illustrated in the sample below to add
  //composite types to service operations.

   [DataContract]
   Public class CompositeType {
      Bool boolValue = true;
      String stringValue = "Hello ";

      [DataMember]
      Public bool BoolValue {
         get { return boolValue; }
         set { boolValue = value; }
      }

      [DataMember]
      Public string StringValue {
         get { return stringValue; }
         set { stringValue = value; }
      }
   }
}

クラスの背後にあるコードを以下に示します。

using System;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Runtime.Serialization;
usingSystem.ServiceModel;
usingSystem.Text;

namespace WcfServiceLibrary1 {
  //NOTE: You can use the "Rename" command on the "Refactor" menu to
  //change the class name "Service1" in both code and config file
  //together.

   publicclassService1 :IService1 {
     //This Function Returns summation of two integer numbers

      publicint sum(int num1, int num2) {
         return num1 + num2;
      }

     //This function returns subtraction of two numbers.
     //If num1 is smaller than number two then this function returns 0

      publicint Subtract(int num1, int num2) {
         if (num1 > num2) {
            return num1 - num2;
         }
         else {
            return 0;
         }
      }

     //This function returns multiplication of two integer numbers.
      publicint Multiply(int num1, int num2) {
         return num1* num2;
      }

     //This function returns integer value of two integer number.
     //If num2 is 0 then this function returns 1.
      publicint Divide(int num1, int num2) {
         if (num2 != 0) {
            return (num1/num2);
         } else {
            return 1;
         }
      }
   }
}

このサービスを実行するには、Visual Studioの[スタート]ボタンをクリックします。

Wcf Creating Service4

このサービスを実行すると、次の画面が表示されます。

Wcf Creating Service5

sumメソッドをクリックすると、次のページが開きます。ここでは、任意の2つの整数を入力して、[呼び出し]ボタンをクリックできます。サービスは、これらの2つの数値の合計を返します。

Wcf Creating Service6 Wcf Creation Service7

合計と同様に、メニューにリストされている他のすべての算術演算を実行できます。そして、ここにそれらのスナップがあります。

Subtractメソッドをクリックすると、次のページが表示されます。整数を入力し、[呼び出し]ボタンをクリックして、ここに示すように出力を取得します-

Wcf Creating Service8

乗算メソッドをクリックすると、次のページが表示されます。整数を入力し、[呼び出し]ボタンをクリックして、ここに示すように出力を取得します-

Wcf Creating Service9

Divideメソッドをクリックすると、次のページが表示されます。整数を入力し、[呼び出し]ボタンをクリックして、ここに示すように出力を取得します-

Wcf Creating Service10

サービスが呼び出されると、ここから直接切り替えることができます。

Wcf Creating Service11

WCF-ホスティングWCFサービス

WCFサービスを作成したら、次のステップは、クライアントアプリケーションがそれを使用できるようにホストすることです。これは、WCFサービスホスティングとして知られています。 WCFサービスは、以下に示す4つの方法のいずれかを使用してホストできます-

* IISホスティング*-IISはインターネットインフォメーションサービスの略です。その動作モデルは、WCFサービスをホストしているASP.NETのモデルに似ています。 IISホスティングの最良の機能は、サービスのアクティブ化が自動的に処理されることです。 IISホスティングは、プロセスヘルスモニタリング、アイドルシャットダウン、プロセスリサイクル、およびWCFサービスホスティングを促進するための多くの機能も提供します。
セルフホスティング-WCFサービスが管理対象アプリケーションでホストされている場合、セルフホスティングと呼ばれます。開発者はServiceHostの初期化に必要なコーディングを記述する必要があります。セルフホスティングでは、コンソールアプリケーション、WindowsフォームなどのさまざまなアプリケーションでWCFサービスをホストできます。
* WASホスティング*-Windows Activation Service（WAS）でWCFサービスをホストすることは、プロセスリサイクル、アイドル時間管理、共通の構成システム、HTTP、TCPなどのサポートなどの機能により、最も有利です。
* Windowsサービスホスティング*-ローカルシステムクライアントの場合、WCFサービスをウィンドウサービスとしてホストすることをお勧めします。これはウィンドウサービスホスティングと呼ばれます。 Windowsのすべてのバージョンがこのタイプのホスティングをサポートしています。ここでは、サービスコントロールマネージャーがWCFサービスのプロセスライフサイクルを制御できます。

WCF-IISホスティング

IIS（インターネットインフォメーションサービス）でのWCFサービスのホストは、段階的なプロセスです。 IISホスティングは、目的のコーディングとプロセスを理解するためのスクリーンショットとともに以下に詳細に示されています。

ステップ1 *-Visual Studio 2012を起動し、[ファイル]→[新規]→[Webサイト]をクリックします。「WCFサービス」と「http」として場所を選択します。これにより、IISでサービスがホストされます。 OKをクリックしてください。

Wcf Hosting Services IIS 1

ステップ2 *-インターフェースの背後にあるコードを以下に示します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

//NOTE: You can use the "Rename" command on the "Refactor" menu to
//change the interface name "IService" in both code and config file
//together.

[ServiceContract]
Public interface IService {
   [OperationContract]
   String GetData(int value);

   [OperationContract]
   CompositeType GetDataUsingDataContract(CompositeType composite);

  //TODO: Add your service operations here
}

//Use a data contract as illustrated in the sample below to add
//composite types to service operations.

[DataContract]
Public class CompositeType {
   Bool boolValue = true;
   String stringValue = "Hello ";

   [DataMember]
   Public bool BoolValue {
      get { return boolValue; }
      set { boolValue = value; }
   }

   [DataMember]
   Public string StringValue {
      get { return stringValue; }
      set { stringValue = value; }
   }
}

ステップ3 *-クラスファイルの背後にあるコードを以下に示します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

//NOTE: You can use the "Rename" command on the "Refactor" menu to
//change the class name "Service" in code, svc and config file
//together.

Public class Service : IService {
   Public string GetData(int value) {
      Return string.Format("You entered: {0}", value);
   }

   Public CompositeType GetDataUsingDataContract(CompositeType composite) {
      if(composite == null) {
         thrownewArgumentNullException("composite");
      }

      if(composite.BoolValue) {
         composite.StringValue += "Suffix";
      }
      return composite;
   }
}

ステップ4 *-サービスファイル（.svc）には、サービスの名前とファイル名の背後にあるコードが含まれています。このファイルは、サービスについて知るために使用されます。

Wcf Hosting Services IIS 4

<%@ ServiceHost Language = "C#" Debug = "true" Service = "Service"
   CodeBehind = "~/App_Code/Service.cs" %>

ステップ5 *-サーバー側の構成は、構成ファイルに記載されています。ここでは、「wsHttpBinding」に設定された1つのエンドポイントのみに言及しています。異なるバインディングを持つ複数のエンドポイントを持つこともできます。 IISでホストするため、httpバインディングのみを使用する必要があります。

<?xml version = "1.0"?>
<configuration>
   <!--
      Note: As an alternative to hand editing this file you can use the
         web admin tool to configure settings for your application. Use
         the Website->Asp.Net Configuration option in Visual Studio.
         A full list of settings and comments can be found in
         machine.config.comments usually located in
         \Windows\Microsoft.Net\Framework\vx.x\Config
   -->
   <configSections>
      <sectionGroup name = "system.web.extensions"
         ype = "System.Web.Configuration.SystemWebExtensionsSectionGroup,
         System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
         PublicKeyToken = 31BF3856AD364E35">

         <sectionGroup name = "scripting"
            type = "System.Web.Configuration.ScriptingSectionGroup,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35">

            <section name = "scriptResourceHandler"
               type = "System.Web.Configuration.ScriptingScriptResourceHandlerSection,
               System.Web.Extensions, Version = 3.5.0.0,
               Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
               requirePermission = "false"
               allowDefinition = "MachineToApplication"/>

            <sectionGroup name = "webServices"
               type = "System.Web.Configuration.ScriptingWebServicesSectionGroup,
               System.Web.Extensions, Version = 3.5.0.0,
               Culture = neutral, PublicKeyToken = 31BF3856AD364E35">

               <section name = "jsonSerialization"
                  type = "System.Web.Configuration.ScriptingJsonSerializationSection,
                  System.Web.Extensions, Version = 3.5.0.0,
                  Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
                  requirePermission = "false" allowDefinition = "Everywhere"/>

               <section name = "profileService"
                  type = "System.Web.Configuration.ScriptingProfileServiceSection,
                  System.Web.Extensions, Version = 3.5.0.0,
                  Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
                  requirePermission = "false"
                  allowDefinition = "MachineToApplication"/>

               <section name = "authenticationService"
                  type = "System.Web.Configuration.ScriptingAuthenticationServiceSection,
                  System.Web.Extensions, Version = 3.5.0.0,
                  Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
                  requirePermission = "false"
                  allowDefinition = "MachineToApplication"/>

               <section name = "roleService"
                  type = "System.Web.Configuration.ScriptingRoleServiceSection,
                  System.Web.Extensions, Version = 3.5.0.0,
                  Culture = neutral, PublicKeyToken = 31BF3856AD364E35"
                  requirePermission = "false"
                  allowDefinition = "MachineToApplication"/>

            </sectionGroup>
         </sectionGroup>
      </sectionGroup>
   </configSections>

<appSettings/>
   <connectionStrings/>
   <system.web>
      <!--
         Set compilation debug="true" to insert debugging
         symbols into the compiled page. Because this
         affects performance, set this value to true only
         during development.
      -->

      <compilation debug = "true">
         <assemblies>

            <add assembly = "System.Core, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = B77A5C561934E089"/>

            <add assembly = "System.Web.Extensions, Version = 3.5.0.0,
               Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>

            <add assembly = "System.Data.DataSetExtensions, Version = 3.5.0.0,
               Culture = neutral, PublicKeyToken = B77A5C561934E089"/>

            <add assembly = "System.Web.Extensions, Version = 3.5.0.0,
               Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>

            <add assembly = "System.Xml.Linq, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = B77A5C561934E089"/>

         </assemblies>
      </compilation>

         <!--
            The <authentication> section enables configuration
            of the security authentication mode used by
            ASP.NET to identify an incoming user.
         -->

      <authentication mode="Windows"/>
         <!--
            The <customErrors> section enables configuration
            of what to do if/when an unhandled error occurs
            during the execution of a request. Specifically,
            it enables developers to configure html error pages
            to be displayed in place of a error stack trace.

            <customErrors mode = "RemoteOnly" defaultRedirect = "GenericErrorPage">
               <error statusCode = "403" redirect = "NoAccess"/>
               <error statusCode = "404" redirect = "FileNotFound"/>
            </customErrors>
         -->

         <pages>
            <controls>
               <add tagPrefix = "asp" namespace = "System.Web.UI"
                  assembly = "System.Web.Extensions, Version = 3.5.0.0,
                  Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>

               <add tagPrefix = "asp" namespace = "System.Web.UI.WebControls"
                  assembly = "System.Web.Extensions, Version = 3.5.0.0,
                  Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>

            </controls>
         </pages>

         <httpHandlers>
            <remove verb = "*" path = "*.asmx"/>

            <add verb = "*" path = "*.asmx" validate = "false"
               type = "System.Web.Script.Services.ScriptHandlerFactory,
               System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = 31BF3856AD364E35"/>

            <add verb = "*" path = "*_AppService.axd" validate = "false"
               type = "System.Web.Script.Services.ScriptHandlerFactory,
               System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = 31BF3856AD364E35"/>

            <add verb = "GET,HEAD" path = "ScriptResource.axd"
               type = "System.Web.Handlers.ScriptResourceHandler,
               System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = 31BF3856AD364E35" validate = "false"/>
         </httpHandlers>

         <httpModules>
            <add name = "ScriptModule"
               type = "System.Web.Handlers.ScriptModule,
               System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = 31BF3856AD364E35"/>
         </httpModules>
   </system.web>

   <system.codedom>
      <compilers>

         <compiler language = "c#;cs;csharp" extension = ".cs"
            warningLevel = "4" type = "Microsoft.CSharp.CSharpCodeProvider,
            System, Version = 2.0.0.0, Culture = neutral,
            PublicKeyToken = b77a5c561934e089">

            <providerOption name = "CompilerVersion" value = "v3.5"/>
            <providerOption name = "WarnAsError" value = "false"/>

         </compiler>

         <compiler language = "vb;vbs;visualbasic;vbscript" extension = ".vb"
            warningLevel = "4" type = "Microsoft.VisualBasic.VBCodeProvider,
            System, Version = 2.0.0.0, Culture = neutral,
            PublicKeyToken = b77a5c561934e089">

            <providerOption name = "CompilerVersion" value = "v3.5"/>
            <providerOption name = "OptionInfer" value = "true"/>
            <providerOption name = "WarnAsError" value = "false"/>

         </compiler>
      </compilers>

   </system.codedom>
   <!--
      The system.webServer section is required for running ASP.NET AJAX
      under Internet Information Services 7.0.
      It is not necessary for previous version of IIS.
   -->
   <system.webServer>
      <validation validateIntegratedModeConfiguration="false"/>

      <modules>
         <remove name = "ScriptModule"/>
         <add name = "ScriptModule" preCondition = "managedHandler"
            type = "System.Web.Handlers.ScriptModule,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>
      </modules>

      <handlers>
         <remove name = "WebServiceHandlerFactory-Integrated"/>
         <remove name = "ScriptHandlerFactory"/>
         <remove name = "ScriptHandlerFactoryAppServices"/>
         <remove name = "ScriptResource"/>

         <add name = "ScriptHandlerFactory" verb = "*" path = "*.asmx"
            preCondition = "integratedMode"
            type = "System.Web.Script.Services.ScriptHandlerFactory,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>

         <add name = "ScriptHandlerFactoryAppServices"
            verb = "*" path = "*_AppService.axd" preCondition = "integratedMode"
            type = "System.Web.Script.Services.ScriptHandlerFactory,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>

         <add name = "ScriptResource" preCondition = "integratedMode"
            verb = "GET,HEAD" path = "ScriptResource.axd"
            type = "System.Web.Handlers.ScriptResourceHandler,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>
      </handlers>

      <!--To browse web app root directory during debugging,
         set the value below to true. Set to false before deployment to
         avoid disclosing web app folder information.-->

      <directoryBrowse enabled = "true"/>
   </system.webServer>

   <runtime>
      <assemblyBinding appliesTo = "v2.0.05727" xmlns =" urn:schemas-microsoft-com:asm.v1">

         <dependentAssembly>
            <assemblyIdentity name = "System.Web.Extensions" publicKeyToken = "31bf3856ad364e35"/>
            <bindingRedirect oldVersion = "1.0.0.0-1.1.0.0" newVersion = "3.5.0.0"/>
         </dependentAssembly>

         <dependentAssembly>
            <assemblyIdentity name = "System.Web.Extensions.Design" publicKeyToken =" 31bf3856ad364e35"/>
            <bindingRedirect oldVersion = "1.0.0.0-1.1.0.0" newVersion = "3.5.0.0"/>
         </dependentAssembly>

      </assemblyBinding>
   </runtime>

   <system.serviceModel>
      <services>
         <service name = "Service" behaviorConfiguration = "ServiceBehavior">
         <!-- Service Endpoints -->
            <endpoint address = "" binding = "basicHttpBinding" contract = "IService">
               <!--
                  Upon deployment, the following identity element should be removed or replaced
                  to reflect the identity under which the deployed service runs. If removed,
                  WCF will infer an appropriate identity automatically.
               -->

               <identity>
                  <dns value="localhost"/>
               </identity>

            </endpoint>
            <endpoint address = "mex" binding = "mexHttpBinding" contract = "IMetadataExchange"/>

         </service>
      </services>

      <behaviors>
         <serviceBehaviors>
            <behavior name = "ServiceBehavior">
               <!-- To avoid disclosing metadata information, set the value below
                  to false before deployment -->

               <serviceMetadata httpGetEnabled = "true"/>

               <!-- To receive exception details in faults for debugging purposes,
                  set the value below to true.
                  Set to false before deployment to false avoid
                  disclosing exception information -->

               <serviceDebug includeExceptionDetailInFaults = "false"/>
            </behavior>
         </serviceBehaviors>
      </behaviors>

   </system.serviceModel>
</configuration>

ステップ6 *-設定ファイルに記載されているアドレスとともに、サービスファイル名を記載する必要があります。 IISのスクリーンショットはここにあります。

「スタート」→「実行」→「inetmgr」をクリックして、次のウィンドウを開きます。

Wcf Hosting Service IIS 6

ステップ7 *-次の画面を生成するアプリケーションを実行します。

Wcf Hosting Service IIS 7

WCF-セルフホスティング

ここでは、WCFサービスはコンソールアプリケーションでホストされています。以下に、プロセス全体を説明する適切な手順を順番に実行するプロセスを示します。

ステップ1 *-最初に、サービスコントラクトとその実装を作成しましょう。コンソールアプリケーションを作成し、MyCalculatorServiceという名前を付けます。これは、2つの数字の加算を返す簡単なサービスです。

Wcf Hosting Services Self 1

ステップ2 *-次に、ソリューションエクスプローラーで参照を右クリックし、[参照の追加]をクリックします。次のウィンドウが開きます。 System.ServiceModel参照をプロジェクトに追加します。

Wcf Hosting Services Self 2

ステップ3 *-ISimpleCalculatorインターフェースを作成し、以下に示すようにServiceContractおよびOperationContract属性をクラスおよび関数に追加します。これらの契約については、後のセッションで詳しく説明します。これらのコントラクトは、このサービスを使用するためにメソッドを外部に公開します。

ステップ4 *-このファイルの背後にあるコードは次のとおりです-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace MyCalculatorWCFService {
   [ServiceContract()]
   Public interface ISimpleCalculator {
      [OperationContract()]
      int Add(int num1, int num2);
   }
}

ステップ5 *-MyCalculatorServiceは、以下に示すIMyCalculatorServiceインターフェイスの実装クラスです。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyCalculatorWCFService {
   Class SimpleCalculator : ISimpleCalculator {
      Public int Add(int num1, int num2) {
         return num1 + num2;
      }
   }
}

ステップ6 *-これで、サービスの準備ができました。ホスティングプロセスを実装しましょう。新しいコンソールアプリケーションを作成し、「MyCalculatorWCFServiceHost」という名前を付けます。

Wcf Hosting Services Self 5

ステップ7 *-system.servicemodelおよびプロジェクトMyCalculatorWCFServiceの参照を追加します。

Wcf Hosting Services 6

この背後にあるコードは次のとおりです-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCalculatorWCFService;
using System.ServiceModel;
using System.ServiceModel.Description;

namespace MyCalculatorWCFServiceHost {
   class Program {
      static void Main(string[] args) {
        //Create a URI to serve as the base address
         UrihttpUrl = newUri("http://localhost:8090/MyCalculatorWCFService/SimpleCalculator");

        //Create ServiceHost
         ServiceHost host = newServiceHost(typeof(MyCalculatorWCFService.ISimpleCalculator), httpUrl);

        //Add a service endpoint
         host.AddServiceEndpoint(typeof(MyCalculatorWCFService.ISimpleCal culator), newWSHttpBinding(), "");

        //Enable metadata exchange
         ServiceMetadataBehaviorsmb = newServiceMetadataBehavior();
         smb.HttpGetEnabled = true;
         host.Description.Behaviors.Add(smb);

        //Start the Service
         host.Open();
         Console.WriteLine("Service is host at " + DateTime.Now.ToString());
         Console.WriteLine("Host is running... Press  key to stop");
         Console.ReadLine();
      }
   }
}

Wcf Hosting Services Self 8

WCF-WASホスティング

WASホスティングの概念を理解するには、システムの構成方法とサービスコントラクトの作成方法を理解し、ホストされたサービスへのさまざまなバインディングを有効にする必要があります。

まず、非プロトコルに対してWCFを有効にします。サービスの作成を開始する前に、WASをサポートするようにシステムを構成する必要があります。 WASを構成する手順は次のとおりです-

[スタート]メニュー→[コントロールパネル]→[プログラムと機能]をクリックし、左側のウィンドウで[Windowsコンポーネントの有効化または無効化]をクリックします。
「Microsoft .Net Framework 3.0」を展開し、「Windows Communication Foundation HTTPアクティベーション」と「Windows Communication Foundation非HTTPアクティベーション」を有効にします。
次に、BindingをデフォルトのWebサイトに追加する必要があります。例として、デフォルトのWebサイトをTCPプロトコルにバインドします。 [スタート]メニュー→[プログラム]→[アクセサリ]に移動します。 [コマンドプロンプト]を右クリックし、コンテキストメニューから[管理者として実行]を選択します。
次のコマンドを実行します-

C:\Windows\system32\inetsrv> appcmd.exe set site "Default Web Site" -+bindings.[protocol='net.tcp',bindingInformation='808:*']

このコマンドは、「C：\ Windows \ system32 \ inetsrv \ config」ディレクトリにあるapplicationHost.configファイルを変更することにより、デフォルトのWebサイトにnet.tcpサイトバインディングを追加します。同様に、デフォルトのWebサイトに異なるプロトコルを追加できます。

WASホストサービスを作成する

ステップ-1 *-Visual Studio 2008を開き、[新規]→[WebSite]をクリックし、テンプレートから[WCFサービス]を選択し、以下に示すようにHTTPとして[場所]を選択します-

Wcf Hosting Services WAS 1

ステップ-2 *-インターフェースIMathServiceを作成して契約を作成します。 ServiceContract属性をインターフェイスに追加し、OperationContract属性をメソッド宣言に追加します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;

//NOTE: You can use the "Rename" command on the "Refactor" menu to
//change the interface name "IService" in both code and config file
//together.

[ServiceContract]

Public interface IMathService {
   [OperationContract]
   int Add(int num1, int num2);

   [OperationContract]
   int Subtract(int num1, int num2);
}

ステップ-3 *-IMathServiceインターフェースの実装を以下に示します-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;

//NOTE: You can use the "Rename" command on the "Refactor" menu to
//change the class name "Service" in code, svc and config file
//together.

Public class MathService : IMathService {
   Public int Add(int num1, int num2) {
      return num1 + num2;
   }
   Public int Subtract(int num1, int num2) {
      return num1 - num2;
   }
}

ステップ-4 *-サービスファイルを以下に示します。

Wcf Hosting Services WAS 2

<%@ServiceHostLanguage="C#"Debug="true"Service="MathService"CodeBehind="~/App_Code/MathService.cs"%>

ステップ-5 *-web.Configファイルで、「netTcpBinding」バインディングを使用してエンドポイントを作成します。サービスメタデータは、メタデータ交換ポイントを使用して公開されます。そのため、アドレスを「mex」、バインディングを「mexTcpBinding」としてメタデータ交換エンドポイントを作成します。サービスのメタデータを公開しないと、たとえば、net.tcpアドレスを使用してプロキシを作成できません-

svcutil.exe net.tcp://localhost/WASHostedService/MathService.svc).

<?xml version = "1.0" ?>
<configuration>
   <!--
      Note: As an alternative to hand editing this file you can use the
         web admin tool to configure settings for your application. Use
         the Website->Asp.Net Configuration option in Visual Studio.
         A full list of settings and comments can be found in
         machine.config.comments usually located in
         \Windows\Microsoft.Net\Framework\vx.x\Config
   -->
   <configSections>
      <sectionGroup name = "system.web.extensions"
         type = "System.Web.Configuration.SystemWebExtensionsSectionGroup,
         System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
         PublicKeyToken = 31BF3856AD364E35">

         <sectionGroup name = "scripting"
            type = "System.Web.Configuration.ScriptingSectionGroup,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken =3 1BF3856AD364E35">

            <section name = "scriptResourceHandler"
               type = "System.Web.Configuration.ScriptingScriptResourceHandlerSection,
               System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = 31BF3856AD364E35"
               requirePermission = "false"
               allowDefinition = "MachineToApplication"/>

            <sectionGroup name = "webServices"
               type = "System.Web.Configuration.ScriptingWebServicesSectionGroup,
               System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = 31BF3856AD364E35">

               <section name = "jsonSerialization"
                  type = "System.Web.Configuration.ScriptingJsonSerializationSection,
                  System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
                  PublicKeyToken = 31BF3856AD364E35" requirePermission = "false"
                  allowDefinition = "Everywhere"/>

               <section name = "profileService"
                  type = "System.Web.Configuration.ScriptingProfileServiceSection,
                  System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
                  PublicKeyToken = 31BF3856AD364E35" requirePermission = "false"
                  allowDefinition = "MachineToApplication"/>

               <section name = "authenticationService"
                  type = "System.Web.Configuration.ScriptingAuthenticationServiceSection,
                  System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
                  PublicKeyToken = 31BF3856AD364E35" requirePermission = "false"
                  allowDefinition = "MachineToApplication"/>

               <section name = "roleService"
                  type = "System.Web.Configuration.ScriptingRoleServiceSection,
                  System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
                  PublicKeyToken = 31BF3856AD364E35" requirePermission = "false"
                  allowDefinition = "MachineToApplication"/>

            </sectionGroup>
         </sectionGroup>
      </sectionGroup>
   </configSections>

   <appSettings/>
   <connectionStrings/>

   <system.web>
      <!--
         Set compilation debug="true" to insert debugging
         symbols into the compiled page. Because this
         affects performance, set this value to true only
         during development.
      -->
      <compilation debug = "true">
         <assemblies>
            <add assembly = "System.Core, Version = 3.5.0.0,
               Culture = neutral, PublicKeyToken = B77A5C561934E089"/>

            <add assembly = "System.Web.Extensions, Version = 3.5.0.0,
               Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>

            <add assembly = "System.Data.DataSetExtensions,
               Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = B77A5C561934E089"/>

            <add assembly = "System.Web.Extensions, Version = 3.5.0.0,
               Culture = neutral, PublicKeyToken = 31BF3856AD364E35"/>

            <add assembly = "System.Xml.Linq,
               Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = B77A5C561934E089"/>
         </assemblies>
      </compilation>

      <!--
         The <authentication> section enables configuration
         of the security authentication mode used by
         ASP.NET to identify an incoming user.
      -->

      <authentication mode="Windows"/>

      <!--
         The <customErrors> section enables configuration
         of what to do if/when an unhandled error occurs
         during the execution of a request. Specifically,
         it enables developers to configure html error pages
         to be displayed in place of a error stack trace.
         <customErrors mode = "RemoteOnly" defaultRedirect = "GenericErrorPage">
         <error statusCode = "403" redirect = "NoAccess"/>
         <error statusCode = "404" redirect = "FileNotFound"/>
         </customErrors>
      -->

      <pages>
         <controls>
            <add tagPrefix = "asp" namespace = "System.Web.UI"
               assembly = "System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = 31BF3856AD364E35"/>

            <add tagPrefix = "asp" namespace = "System.Web.UI.WebControls"
               assembly = "System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
               PublicKeyToken = 31BF3856AD364E35"/>
         </controls>
      </pages>

      <httpHandlers>
         <remove verb = "*" path = "*.asmx"/>

         <add verb =" *" path =" *.asmx" validate="false"
            type = "System.Web.Script.Services.ScriptHandlerFactory,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>

         <add verb = "*" path = "*_AppService.axd" validate = "false"
            type = "System.Web.Script.Services.ScriptHandlerFactory,System.Web.Extensions,
            Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>

         <add verb = "GET,HEAD" path = "ScriptResource.axd"
            type = "System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions,
            Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35" validate = "false"/>
      </httpHandlers>

      <httpModules>
         <add name = "ScriptModule"
            type = "System.Web.Handlers.ScriptModule,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>
      </httpModules>

   </system.web>

   <system.codedom>
      <compilers>

         <compiler language = "c#;cs;csharp" extension = ".cs" warningLevel = "4"
            type = "Microsoft.CSharp.CSharpCodeProvider, System,
            Version = 2.0.0.0, Culture = neutral,
            PublicKeyToken = b77a5c561934e089">

            <providerOption name = "CompilerVersion" value = "v3.5"/>
            <providerOption name = "WarnAsError" value = "false"/>
         </compiler>

         <compiler language = "vb;vbs;visualbasic;vbscript"
            extension = ".vb" warningLevel = "4"
            type = "Microsoft.VisualBasic.VBCodeProvider, System,
            Version = 2.0.0.0, Culture = neutral,
            PublicKeyToken = b77a5c561934e089">

            <providerOption name = "CompilerVersion" value = "v3.5"/>
            <providerOption name = "OptionInfer" value = "true"/>
            <providerOption name = "WarnAsError" value = "false"/>
         </compiler>

      </compilers>
   </system.codedom>

   <!--
      The system.webServer section is required for running ASP.NET AJAX under
      Internet Information Services 7.0. It is not necessary for previous version of IIS.
   -->

   <system.webServer>
      <validation validateIntegratedModeConfiguration = "false"/>

      <modules>
         <remove name = "ScriptModule"/>
         <add name = "ScriptModule" preCondition = "managedHandler"
            type = "System.Web.Handlers.ScriptModule, System.Web.Extensions,
            Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>
      </modules>

      <handlers>
         <remove name = "WebServiceHandlerFactory-Integrated"/>
         <remove name = "ScriptHandlerFactory"/>
         <remove name = "ScriptHandlerFactoryAppServices"/>
         <remove name = "ScriptResource"/>

         <add name = "ScriptHandlerFactory"
            verb = "*" path = "*.asmx" preCondition = "integratedMode"
            type = "System.Web.Script.Services.ScriptHandlerFactory,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>

         <add name = "ScriptHandlerFactoryAppServices"
            verb = "*" path = "*_AppService.axd" preCondition = "integratedMode"
            type = "System.Web.Script.Services.ScriptHandlerFactory,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>

         <add name = "ScriptResource" preCondition = "integratedMode"
            verb = "GET,HEAD" path = "ScriptResource.axd"
            type = "System.Web.Handlers.ScriptResourceHandler,
            System.Web.Extensions, Version = 3.5.0.0, Culture = neutral,
            PublicKeyToken = 31BF3856AD364E35"/>

      </handlers>
      <!--
         To browse web app root directory during debugging, set the value below to true.
         Set to false before deployment to avoid disclosing web app folder information.
      -->
      <directoryBrowse enabled="true"/>
   </system.webServer>

   <runtime>
      <assemblyBinding appliesTo = "v2.0.05727" xmlns = "urn:schemas-microsoft-com:asm.v1">

         <dependentAssembly>
            <assemblyIdentity name = "System.Web.Extensions" publicKeyToken = "31bf3856ad364e35"/>
            <bindingRedirect oldVersion = "1.0.0.0-1.1.0.0" newVersion = "3.5.0.0"/>
         </dependentAssembly>

         <dependentAssembly>
            <assemblyIdentity name = "System.Web.Extensions.Design" publicKeyToken = "31bf3856ad364e35"/>
            <bindingRedirect oldVersion = "1.0.0.0-1.1.0.0" newVersion = "3.5.0.0"/>
         </dependentAssembly>

      </assemblyBinding>
   </runtime>

   <system.serviceModel>
      <services>
         <service behaviorConfiguration = "ServiceBehavior" name = "Service">
            <endpoint address = "" binding = "basicHttpBinding" contract = "IMathService">

            <identity>
               <dns value = "localhost"/>
            </identity>

            </endpoint>
            <endpoint address = "mex" binding = "mexHttpBinding" contract = "IMetadataExchange"/>
         </service>
      </services>

      <behaviors>
         <serviceBehaviors>
            <behavior name = "ServiceBehavior">
               <!--
                  To avoid disclosing metadata information, set the value below
                  to false before deployment.
               -->
               <serviceMetadata httpGetEnabled="true"/>

               <!--
                  To receive exception details in faults for debugging purposes,
                  set the value below to true. Set to false before deployment to avoid
                  disclosing exception information
               -->
               <serviceDebug includeExceptionDetailInFaults="false"/>
            </behavior>
         </serviceBehaviors>
      </behaviors>

   </system.serviceModel>
</configuration>

ホストされたサービスへの異なるバインディングを有効にする

[スタート]メニュー→[プログラム]→[アクセサリ]に移動します。 [コマンドプロンプト]を右クリックし、コンテキストメニューから[管理者として実行]を選択します。
次のコマンドを実行します-

C:\Windows\system32\inetsrv>appcmd set app "Default Web Site/WASHostedService"/enabledProtocols:http,net.tcp

それは次の出力を生成します-

Wcf Hosting Services WAS 6

WCF-Windowsサービスホスティング

Windowsサービスホスティングの操作は簡単です。以下に、プロセスを簡単に説明する必要なコーディングとスクリーンショットの手順を示します。

ステップ1 *-では、WCFサービスを作成しましょう。 Visual Studio 2008を開き、[新規]→[プロジェクト]をクリックして、テンプレートから[クラスライブラリ]を選択します。

WcfホスティングサービスWindowsサービス1

ステップ2 *-参照System.ServiceModelをプロジェクトに追加します。これは、WCFサービスの作成に使用されるコアアセンブリです。

ステップ3 *-次に、ISimpleCalulatorインターフェイスを作成できます。以下に示すように、サービスと操作の契約属性を追加します-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace WindowsServiceHostedService{
   [ServiceContract]
   public interfaceISimpleCalculator {
      [OperationContract]
      int Add(int num1, int num2);

      [OperationContract]
      int Subtract(int num1, int num2);

      [OperationContract]
      int Multiply(int num1, int num2);

      [OperationContract]
      double Divide(int num1, int num2);
   }
}

ステップ4 *-以下に示すようにISimpleCalculatorインターフェースを実装します-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WindowsServiceHostedService {
   Class SimpleCalulator : ISimpleCalculator {
      Public int Add(int num1, int num2) {
         return num1 + num2;
      }
      Public int Subtract(int num1, int num2) {
         return num1 - num2;
      }
      Public int Multiply(int num1, int num2) {
         return num1 * num2;
      }
      Public double Divide(int num1, int num2) {
         if (num2 != 0)
            return num1/num2;
         else
            return 0;
      }
   }
}

ステップ5 *-プロジェクトをビルドし、dllを取得します。これで、WCFサービスの準備が整いました。 WindowsサービスでWCFサービスをホストする方法を確認します。

注-このプロジェクトでは、同じプロジェクトでコントラクトとサービス（実装）の両方を作成していることに言及しています。ただし、両方が異なるプロジェクトにある場合は、常に良い習慣です。

ステップ6 *-Visual Studio 2008を開き、[新規]→[プロジェクト]をクリックして、[Windowsサービス]を選択します。

WcfホスティングサービスWindowsサービス1

ステップ7 *-プロジェクトへの参照として「WindowsServiceHostedService.dll」を追加します。このアセンブリはサービスとして機能します。

WcfホスティングサービスWindowsサービス4

ステップ8 *-サービスのOnStartメソッドを使用して、WCFのホスティングコードを記述できます。 1つのサービスホストオブジェクトのみを使用していることを確認する必要があります。 OnStopメソッドは、サービスホストを閉じるために使用されます。次のコードは、WindowsサービスでWCFサービスをホストする方法を示しています。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;

namespace WCFHostedWindowsService {
   Partial class WCFHostedWindowsService : ServiceBase {
      ServiceHostm_Host;

      Public WCFHostedWindowsService() {
         InitializeComponent();
      }
      Private void InitializeComponent() {
         thrownewNotImplementedException();
      }
      protectedoverridevoidOnStart(string[] args) {
         if (m_Host != null) {
            m_Host.Close();
         }

        //Create a URI to serve as the base address
         UrihttpUrl = newUri("http://localhost:8090/WindowsServiceHostedService/SimpleCalculator");

        //Create ServiceHost
         m_Host = newServiceHost typeof(WindowsServiceHostedService.SimpleCalulator), httpUrl);

        //Add a service endpoint
         m_Host.AddServiceEndpoint (typeof(WindowsServiceHostedService.ISimpleCalculator), newWSHttpBinding(), "");

        //Enable metadata exchange
         ServiceMetadataBehaviorsmb = newServiceMetadataBehavior();
         smb.HttpGetEnabled = true;
         m_Host.Description.Behaviors.Add(smb);

        //Start the Service
         m_Host.Open();
      }
      protectedoverridevoidOnStop() {
         if (m_Host != null) {
            m_Host.Close();
            m_Host = null;
         }
      }
      staticvoid Main() {
         ServiceBase[] ServicesToRun;
         ServicesToRun = newServiceBase[] {
            newWCFHostedWindowsService();
         }
         ServiceBase.Run(ServicesToRun);
      }
   }
}

ステップ9 *-サービスをインストールするには、Windowsサービスのインストーラークラスが必要です。そのため、新しいインストーラークラスをプロジェクトに追加します。これは、インストーラークラスから継承されます。以下に、サービス名、スタートアップの種類などを示すコードを示します。サービスの。

using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceProcess;
using System.Configuration.Install;
using System.ComponentModel;
using System.Configuration;

namespace WCFHostedWindowsService {
   [RunInstaller(true)]
   Public class WinServiceInstaller : Installer {
      Private ServiceProcessInstaller process;
      Private ServiceInstaller service;

      Public WinServiceInstaller() {
         process = newServiceProcessInstaller();
         process.Account = ServiceAccount.NetworkService;
         service = newServiceInstaller();

         service.ServiceName = "WCFHostedWindowsService";
         service.DisplayName = "WCFHostedWindowsService";
         service.Description = "WCF Service Hosted";
         service.StartType = ServiceStartMode.Automatic;

         Installers.Add(process);
         Installers.Add(service);
      }
   }
}

ステップ10 *-プロジェクトをビルドして、実行可能ファイルWCFHostedWindowsService.exeを取得します。次に、Visual Studioコマンドプロンプトを使用してサービスをインストールする必要があります。そのため、[スタート]→[すべてのプログラム]→[Microsoft Visual Studio 2008]→[Visual Studio Tools]→[Visual Studio Command Prompt]をクリックしてコマンドプロンプトを開きます。 install utilユーティリティアプリケーションを使用して、以下に示すようにサービスをインストールできます。

Wcf Hosting Services Windows Service 7

WCF-WCFサービスの利用

WCFサービスにより、他のアプリケーションがそれらにアクセスしたり消費したりできます。 WCFサービスは、ホスティングの種類に応じてさまざまな方法で利用できます。ここでは、次の一般的なホスティングオプションごとにWCFサービスを使用するための段階的な方法を説明しています-

IIS 5/6でホストされるWCFサービスを利用する
自己ホスト型のWCFサービスを使用する
Windows Activation ServiceでホストされているWCFサービスの使用
WindowsサービスでホストされるWCFサービスを使用する

IIS 5/6でホストされているWCFサービスの使用

IIS 5/6でホストされているWCFサービスの消費プロセスについては、以下で詳しく説明します。さらに、議論には、プロキシおよびコンソールアプリケーションの作成方法が含まれます。

ステップ1 *-IISでサービスをホストしたら、クライアントアプリケーションで使用する必要があります。クライアントアプリケーションを作成する前に、サービスのプロキシを作成する必要があります。このプロキシは、クライアントアプリケーションがサービスと対話するために使用されます。プロキシを作成するには、Visual Studio 2008コマンドプロンプトを実行します。サービスユーティリティを使用して、プロキシクラスとその構成情報を作成できます。

svcutilhttp：//localhost/IISHostedService/Service.svc

Wcf Consuming Services IIS 1

このコマンドを実行すると、2つのファイルがデフォルトの場所に生成されます。

MyService.cs -WCFサービスのプロキシクラス
output.config -サービスに関する構成情報

ステップ2 *-次に、Visual Studio 2008（クライアントアプリケーション）を使用してコンソールアプリケーションの作成を開始します。

Wcf Consuming Services IIS 2

ステップ3 *-参照「System.ServiceModel」を追加します。これは、WCFのコアdllです。

ステップ4 *-プロキシクラスを作成します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyServiceClient {
   Class Program {
      Static void Main(string[] args) {
        //Creating Proxy for the MyService
         ServiceClient Client = newServiceClient();
         Console.WriteLine("Client calling the service...");
         Console.WriteLine("Hello Ram");
         Console.Read();
      }
   }
}

出力は次のように表示されます-

Wcf Consuming Services IIS 4

セルフホストWCFサービスの使用

ここでは、自己ホスト型のWCFサービスを利用するプロセス全体を、必要に応じて十分なコーディングとスクリーンショットとともに段階的に説明します。

ステップ1 *-サービスがホストされています。クライアントのプロキシクラスを実装する必要があります。プロキシを作成する方法はいくつかあります。

SvcUtil.exeを使用して、エンドポイントを持つプロキシクラスとその構成ファイルを作成できます。
クライアントアプリケーションにサービス参照を追加します。
ClientBase <T>クラスの実装

これら3つの方法のうち、ClientBase <T>を実装することがベストプラクティスです。他の2つのメソッドを使用している場合、サービス実装に変更を加えるたびにプロキシクラスを作成する必要があります。しかし、これはClientBase <T>の場合ではありません。実行時にのみプロキシを作成するため、すべてを処理します。

この目的のために、System.ServiceModelおよびMyCalculatorServiceの参照を含む1つのプロキシクラスを作成します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using MyCalculatorService;

namespace MyCalculatorServiceProxy {
  //WCF create proxy for ISimpleCalculator using ClientBase
   Public class MyCalculatorServiceProxy :
   ClientBase<ISimpleCalculator>,

   ISimpleCalculator {
      Public int Add(int num1, int num2) {
        //Call base to do funtion
         returnbase.Channel.Add(num1, num2);
      }
   }
}

次に、System.ServiceModelとMyCalculatorServiceProxyの参照を含む1つのコンソールアプリケーションを作成します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using MyCalculatorServiceProxy;

namespace MyCalculatorServiceClient {
   classProgram {
      Static void Main(string[] args) {
         MyCalculatorServiceProxy.MyCalculatorServiceProxy proxy = newMyCalculatorServiceProxy.MyCalculatorServiceProxy();

         Console.WriteLine("Client is running at " + DateTime.Now.ToString());
         Console.WriteLine("Sum of two numbers. 5 + 5 =" + proxy.Add(5,5));
         Console.ReadLine();
      }
   }
}

ステップ2 *-エンドポイント（サービスと同じ）情報をクライアントアプリケーションの構成ファイルに追加する必要があります。

<?xmlversion = "1.0"encoding = "utf-8" ?>
<configuration>
   <system.serviceModel>
      <client>
         <endpoint address
            ="http://localhost:8090/MyCalculatorServiceProxy/ISimpleCalculator"
            binding = "wsHttpBinding" contract "MyCalculatorServiceProxy.ISimpleCalculator">
            </endpoint>
      </client>
   </system.serviceModel>
</configuration>

ステップ3 *-クライアントアプリケーションを実行する前に、サービスを実行する必要があります。以下に、クライアントアプリケーションの出力を示します。

Wcf Consuming Services Self 3

WASでホストされているWCFサービスの使用

WASでホストされているWCFサービスを利用することは、わずかな手順を含む簡単なプロセスです。手順は次のとおりです-

クライアントアプリケーションにプロキシクラスと構成ファイルを追加します。
MathServiceClientのオブジェクトを作成し、メソッドを呼び出します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespaceWASHostedClient {
   classProgram {
      staticvoid Main(string[] args) {
         MathServiceClient client = newMathServiceClient();
         Console.WriteLine("Sum of two number 5,6");
         Console.WriteLine(client.Add(5, 6));
         Console.ReadLine();
      }
   }
}

出力は次のように表示されます。

Wcf Consuming Services WAS 2

WindowsサービスでホストされているWCFサービスの使用

WindowsサービスでホストされているWCFサービスを使用する方法の段階的なプロセスを、コーディングと手順とともに詳細に説明します。

正常にホストされると、サービスのプロキシクラスを作成し、クライアントアプリケーションで使用を開始できます。ここでは、IISホスティングタイプを使用する場合を示しています。

Wcf Consuming Services Windows Service 1

ServiceModelの参照を追加します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespaceWindowServiceClient {
   classProgram {
      staticvoid Main(string[] args) {
        //Creating Proxy for the MyService
         MyServiceClient client = newMyServiceClient();
         Console.WriteLine("Client calling the service...");
         Console.WriteLine("Sum of two numbers 5,6");
         Console.WriteLine(client.Add(5, 6));

         Console.WriteLine("Subtraction of two numbers 6,5");
         Console.WriteLine(client.Sub(6, 5));

         Console.WriteLine("Multiplication of two numbers 6,5");
         Console.WriteLine(client.Mul(6, 5));

         Console.WriteLine("Division of two numbers 6,3");
         Console.WriteLine(client.Div(6, 3));
         Console.Read();
      }
   }
}

出力は次のように表示されます-

Wcf Consuming Services Windows Service 3

WCF-サービスバインディング

WCFサービスバインディングはいくつかの要素のセットで、各要素はサービスがクライアントと通信する方法を定義します。トランスポート要素とメッセージエンコーディング要素は、各バインディングの最も重要な2つのコンポーネントです。この章では、一般的に使用されるさまざまなWCFサービスバインディングについて説明します。

基本的なバインド

基本バインディングは、BasicHttpBindingクラスによって提供されます。 HTTPプロトコルを使用して、ASP.NET Webサービス（ASMX Webサービス）としてWCFサービスを転送および表現するため、ASMX Webサービスを使用する古いクライアントが新しいサービスを便利に利用できます。

基本バインディングは、Silverlightによって有効化されるWCF Webサービスのデフォルトバインディングとして設定され、Webサービススタイルの通信用の標準バインディングです。信頼できるメッセージングはサポートしていません。

以下は、基本的なバインディングのデフォルト設定を示すコードスニペットです。

<basicHttpBinding>
   <binding name = "basicHttpBindingDefaults" allowCookies = "false"
      bypassProxyOnLocal = "false" hostNameComparisonMode = "StrongWildcard"
      maxBufferPoolSize = "524288" maxBufferSize = "65536"
      maxReceivedMessageSize = "65536" messageEncoding = "Text" proxyAddress = ""
      textEncoding = "utf-8" transferMode = "Buffer" useDefaultWebProxy = "true"
      closeTimeout = "00:01:00" openTimeout = "00:01:00" receiveTimeout = "00:10:00"
      sendTimeout = "00:01:00">

      <readerQuotas maxArrayLength = "16384" maxBytesPerRead = "4096"
         maxDepth = "32"
         maxNameTableCharCount = "16384" maxStringContentLength = "8192"/>

      <security mode = "None">
         <transport clientCredentialType = "None" proxyCredentialType = "None" realm = ""/>
         <message algorithmSuite = "Basic256" clientCredentialType = "UserName"/>
      </security>
   </binding>

</basicHttpBinding>

上記のデフォルト設定には、メッセージサイズが制限されており、セキュリティモードがないため、明らかな制限があります。ただし、基本的なバインディングをカスタマイズすると、次のようなこの問題を解決できます。

<basicHttpBinding>
   <binding name = "basicHttpSecure" maxBufferSize = "100000" maxReceivedMessageSize = "100000">

      <readerQuotas maxArrayLength = "100000" maxStringContentLength = "100000"/>
      <security mode = "TransportWithMessageCredential"/>

   </binding>
</basicHttpBinding>

Webサービスバインディング

Webサービス（WS）バインディングは、WSHttpBindingクラスによって提供されます。基本的なバインディングと非常によく似ており、トランスポートに同じプロトコルを使用しますが、WS–Reliable Messaging、WS–Transactions、WS–Securityなど、いくつかのWS– *仕様を提供します。簡単に言うと、WSHttpBindingは、basicHttpBindingとWS– *の仕様の合計に等しくなります。以下は、WSバインディングのデフォルト設定を示すコードスニペットです-

<wsHttpBinding>
   <binding name = "wsHttpBindingDefaults" allowCookies = "false"
      bypassProxyOnLocal = "false" closeTimeout = "00:01:00"
      hostNameComparisonMode = "StrongWildcard"
      maxBufferPoolSize = "524288" maxReceivedMessageSize = "65536"
      messageEncoding = "Text" openTimeout = "00:01:00"
      receiveTimeout = "00:10:00" proxyAddress = "" sendTimeout = "00:01:00"
      textEncoding = "utf-8" transactionFlow = "false"
      useDefaultWebProxy = "true" >

      <readerQuotas maxArrayLength = "16384" maxBytesPerRead = ."4096"
         maxDepth = "32" maxNameTableCharCount = "16384"
         maxStringContentLength = "8192"/>

      <reliableSession enabled = "false" ordered = "true"
         inactivityTimeout = "oo:10:00"/>

      <security mode = "Message">
         <message algorithmSuite = "Basic256" clientCredentialType = "Windows"
            esatalishSecurityContext = "true"
            negotiateServiceCredential = "true"/>

         <transport clientCredentialType = "Windows"
            proxyCredentialType = "None" realm = ""/>
      </security>

   </binding>
</wsHttpBinding>

IPCバインディング

IPCバインディングは名前付きパイプを使用し、netNamedPipeBindingクラスによって提供されます。これは、利用可能なすべてのバインディングの中で最も高速で最も安全なバインディングです。ここではメッセージレベルのセキュリティはサポートされていませんが、堅牢なトランスポートセキュリティのため、メッセージはデフォルトで安全です。 IPCバインディングのデフォルト設定を示すコードスニペットを以下に示します-

<netNamedPipeBinding>

   <binding name = "netPipeDefaults" closeTimeout = "00:01:00"
      hostNameComparisonMode = "StrongWildcard" maxBufferPoolSize = "524288"
      maxBufferSize = "65536" maxConnections = "10"
      maxReceivedMessageSize = "65536" openTimeout = "00:01:00"
      receiveTimeout = "00:10:00" sendTimeout = "00:01:00" transactionFlow = "false"
      transactionProtocol = "OleTransactions" transferMode = "Buffered">

      <readerQuotas maxArrayLength = "16384" maxBytesPerRead = "4096"
         maxDepth = "32" maxNameTableCharCount = "16384"
         maxStringContentLength = "8192"/>

      <security mode = "Transport">
      </security>

   </binding>
</netNamedPipeBinding>

他のタイプのサービスバインディング

* TCPバインディング*-NetTCPBindingクラスによって提供されるこのバインディングは、同じネットワーク内での通信にTCPプロトコルを使用し、バイナリ形式でメッセージをエンコードします。このバインディングは、他のバインディングとは対照的に最も信頼できるものと見なされます。
WS Dual Binding -このタイプのバインディングは、双方向通信を促進する唯一の例外を除いて、WSHttpBindingに似ています。つまり、クライアントとサービスの両方でメッセージを送受信できます。 WSDualHttpBindingクラスによって提供されます。
* Webバインディング*-Webバインディングは、HTTP-GET、HTTP-POSTなどを使用して、HTTP要求の形式でWCFサービスを表すように設計されています。 WebHttpBindingクラスによって提供され、ソーシャルネットワークで一般的に使用されます。
MSMQ Binding -NetMsmqBindingクラスによって提供され、クライアントが送信した時間とは異なる時間にサービスがメッセージを処理する場合にソリューションを提供するために使用されます。 MSMQバインディングは、転送にMSMQを使用し、キューに入れられた分離メッセージをサポートします。 MSMQは、Microsoftが提供するメッセージキューの実装です。
フェデレーションWSバインディング-WSバインディングの特定の形式であり、フェデレーションセキュリティのサポートを提供します。 WSFederationHttpBindingクラスによって提供されます。
Peer Network Binding -NetPeerTCPBindingクラスによって提供され、主にファイル共有システムで使用されます。 TCPプロトコルを使用しますが、トランスポートとしてピアネットワーキングを使用します。このネットワークでは、各マシン（ノード）は他のノードに対するクライアントおよびサーバーとして機能します。ピアネットワークバインディングは、torrentのようなファイル共有システムで使用されます。
* MSMQ統合バインディング*-MsmqIntegrationBindingクラスによって提供され、MSMQ（Microsoft Message Queuing）を介して通信する既存のシステムとの通信に役立ちます。

これらとは別に、カスタムバインディングを作成することもできます。ただし、各WCFバインディングの構成プロパティを調整することは可能であるため、カスタムバインディングを作成する必要はほとんどありません。

WCF-インスタンス管理

WCFが一連のメッセージ（クライアント要求）をサービスインスタンスにバインドするために使用する一連の手法は、インスタンス管理と呼ばれます。 WCFは3種類のインスタンスのアクティブ化をサポートしています。これらについては、この章で説明します。

コールごとのサービス

呼び出しごとのサービスは、WCFの既定のインスタンスアクティブ化モードです。 WCFサービスがコールごとのサービス用に構成されている場合、CLRオブジェクトは、クライアントの呼び出しまたは要求が進行中のタイムスパンに対して作成されます。 CLRはCommon Language Runtimeの略で、WCFのサービスインスタンスが含まれています。

コールごとのサービスでは、すべてのクライアントリクエストが新しい専用サービスインスタンスを達成し、そのメモリ消費は他のタイプのインスタンスアクティベーションと比較して少なくなります。

WCFサービスが呼び出しごとのサービスとして機能することを示すには、InstanceContextModeプロパティをInstanceContextMode.PerCallに設定する必要があります。 InstanceContextModeプロパティはServiceBehavior属性に属します。したがって、コールごとのサービスは次のように構成できます-

[ServiceContract]
interface IMyContract
{...}
[ServiceBehavior (InstanceContextMode = InstanceContextMode.PerCall)]
class MyService : IMyContract
{...}

ここでは、サービスはIMyContractとして表されます。次の図は、コールごとのサービスインスタンスのアクティブ化のプロセスを示しています。

コールサービスごとのWcfインスタンス管理

コールごとのサービスの実装

[DataContract]
class Param {....}

[ServiceContract]
interface IMyContract {
   [OperationContract]
   void MyMethod(Param objectIdentifier);
}
class MyPerCallService : IMyContract, IDisposable {
   public void MyMethod(Param objectIdentifier) {
      GetState(objectIdentifier);
      DoWork();
      SaveState(objectIdentifier);
   }

   void GetState(Param objectIdentifier) {....}
   void DoWork() {....}
   void SaveState(Param objectIdentifier) {....}
   public void Dispose() {....}
}

ここで、Paramは上記の例のために考案された擬似型パラメーターです。

セッションごとのサービス

このWCFのアクティブ化モードでは、プライベートセッションまたは2つのエンティティ、つまりクライアントと特定のサービスインスタンスの間で機密セッションが維持されます。プライベートセッションサービスとも呼ばれるセッションごとのサービスは、各クライアントリクエスト専用であり、そのセッション対応サービスに関連する他のすべてのインスタンスから独立した新しいサービスインスタンスを提供します。

セッションごとのサービスを開始するには、InstanceContextModeプロパティをPerSessionに設定する必要があります。この場合、サービスインスタンスはセッション期間中ずっとメモリに残ります。

アクティベーションモードは、この専用サービスインスタンスのそれぞれにかかるコストのために、構成済みのサービスが少数（または最大で数百）以外の追加の未処理のクライアントをサポートできないため、スケーラビリティが低下します。

セッションごとのサービスは次のように構成できます-

[ServiceBehavior (InstanceContextMode = InstanceContextMode.PerSession)]
class MyService : IMyContract
{...}

セッションごとのサービスのプロセスは、次の図に示すように説明することができます-

セッションサービスごとのWcfインスタンス管理

次のコードは、プライベートセッションの使用のために構成されたコントラクトとサービスを示しています。出力は、クライアントが実際に専用のサービスインスタンスを取得したことを示しています。

サービスコード

[ServiceContract(Session = true)]
interface IMyContract {
   [OperationContract]
   void MyMethod();
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
class MyService : IMyContract, IDisposable {
   int m_Counter = 0; MyService() {Console.WriteLine("MyService.MyService()"); }

   public void MyMethod() {
      m_Counter++;
      Console.WriteLine("Counter = " + m_Counter);
   }
   public void Dispose() {
      Console.WriteLine("MyService.Dispose()");
   }
}

クライアントコード

MyContractProxy proxy = new MyContractProxy(); proxy.MyMethod(); proxy.MyMethod();
proxy.Close();

出力

MyService.MyService() Counter = 1 Counter = 2 MyService.Dispose()

シングルトンサービス

このWCFのアクティブ化モードでは、相互に独立したすべてのクライアント要求は、サービスエンドポイントへの接続に関係なく、同じ既知の単一インスタンスに接続されます。シングルトンサービスは、ホストが閉じられたときにのみ破棄されます。

このサービスは、ホストの作成時に一度だけ作成されます。ホストにシングルトンインスタンスが提供されない場合、サービスはNULLを返します。アクティブ化モードは、各メソッド呼び出しの作業量が少なく、バックグラウンドで保留中の操作がない場合に最適です。

このシングルトンサービスを開始するには、InstanceContextModeプロパティをInstanceContextMode.Singleに設定する必要があります。

したがって、シングルトンサービスは次のように構成できます-

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
class MySingleton : ...
{...}

シングルトンサービスのプロセスは、次の図に示されています-

Wcfインスタンス管理シングルトンサービス

次のコードは、シングルトンインスタンスの初期化とホストに使用されます。

サービスコード

[ServiceContract]
interface IMyContract {
   [OperationContract]
   void MyMethod( );
}
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
class MySingleton : IMyContract {
   int m_Counter = 0;

   public int Counter {
      get {
         return m_Counter;
      }
      set {
         m_Counter = value;
      }
   }
   public void MyMethod( ) {
      m_Counter++;
      Trace.WriteLine("Counter = " + Counter);
   }
}

ホストコード

MySingleton singleton = new MySingleton( );
singleton.Counter = 42;
ServiceHost host = new ServiceHost(singleton);
host.Open( );

//Do some blocking calls then
host.Close( );

クライアントコード

MyContractClient proxy = new MyContractClient( );
proxy.MyMethod( );
proxy.Close( );

出力

Counter = 43

WCF-トランザクション

WCFのトランザクションは、ACIDと総称されるいくつかのプロパティに従う一連の操作です。ここで、1つの操作が失敗すると、システム全体が自動的に失敗します。注文がオンラインになると、トランザクションが発生します。次の例は、トランザクションのプロセスをより簡単に理解するのに役立ちます。

例

オンラインストアで液晶テレビを注文し、クレジットカードで金額を支払うとします。注文するために必要な情報を入力すると、2つの操作が同時に発生します。

1つ目は、指定された金額が銀行口座から引き落とされ、2つ目はベンダー口座に同じ金額が入金されることです。トランザクションを成功させるには、両方の操作を正常に実行する必要があります。

WCFトランザクションプロパティ

WCFトランザクションが続く4つのプロパティは次のとおりです-

アトミック-すべての操作は、トランザクションの完了時に単一の分割できない操作として機能する必要があります。
一貫性-操作セットが何であっても、システムは常に一貫性のある状態にあります。つまり、トランザクションの結果は常に期待どおりです。
分離-システムの中間状態は、トランザクションが完了するまで外界のどのエンティティにも見えません。
耐久性-障害の種類（ハードウェア、停電など）に関係なく、コミットされた状態が維持されます。

WCFトランザクションを構成する際には、考慮が必要ないくつかの要因があります。これらはバインディングと操作の動作です。

バインディング-WCFでトランザクションをサポートするバインディングは少数であり、デフォルトで無効になっているこれらのバインディングのみから選択することが重要です。これらのバインディングは次のとおりです-

NetTcpBinding
NetNamedPipeBinding
WSHttpBinding
WSDualHttpBinding
WSFederationHttpBinding

操作の動作-バインディングはトランザクションの伝播のパスを容易にしますが、操作はトランザクションの処理と操作の構成を処理します。操作の動作では、主にTransactionFlowとTransactionScopeRequiredの2つの属性を使用します。ここで、TransactionFlowには主に3つの値があり、これらはAllowed、Mandatory、NotAllowedであることに注意してください。

次のコードは、バインディングおよび操作コントラクトの構成を変更すると、クライアントの伝播が促進されるかどうかを示しています。

<bindings>
   <wsHttpBinding>
      <binding name = "MandatoryTransBinding" transactionFlow = "true">
         <reliableSession enabled ="true"/>
      </binding>
   </wsHttpBinding>
</bindings>

トランザクションプロトコル

WCFは、トランザクションに3種類のプロトコルを使用します-

軽量
オレ取引
WS-Atomic Transaction（WS-AT）

3つすべてのうち、WS-ATは相互運用可能なプロトコルであり、ファイアウォールを越えた分散トランザクションのフローを可能にします。ただし、トランザクションがMicrosoftテクノロジーに厳密に基づいている場合は、このプロトコルを使用しないでください。

WCFトランザクションのフェーズ

次の図に示すように、WCFトランザクションには2つのフェーズがあります。

Wcfトランザクションフェーズ1

準備フェーズ-このフェーズでは、トランザクションマネージャは、すべてのエンティティがトランザクションにコミットする準備ができているかどうかをチェックします。
コミットフェーズ-このフェーズでは、エンティティのコミットメントが実際に開始されます。

次の図は、WCFトランザクションの両方のフェーズの機能を示しています。

Wcfトランザクションフェーズ2

WCFトランザクションを有効にする

WCFトランザクションを正常に有効にするには、一連の6つの手順を順番に実行する必要があります。必要な手順を以下に説明します。

ステップ1-2つのWCFサービスの作成

これに関する最初のステップは、単一のトランザクションに参加するために、WCFで2つのサービスプロジェクトを構築することです。データベーストランザクションはこれらの両方のサービスで実行され、WCFトランザクションによってどのように統合されるかが理解されます。 WCFTransactionsのWebアプリケーションも作成され、単一のトランザクションスコープで作成された2つのサービスを使用します。

Wcf Transaction Enable 1

ステップ2-メソッドの作成とTransactionFlow属性によるその属性

ここでは、OperationContract属性を使用してデータベースに挿入するために、両方のWCFサービスに対してUpdateDataメソッドが作成されます。このタスクを実行するには、最初にServiceContract属性を使用してインターフェイスクラスを作成します。新しく作成されたメソッドでトランザクションを有効にするには、TransactionFlowに関連付けられ、Allowed値を使用してトランザクションが許可されます。

[ServiceContract]
public interface IService1 {
   [OperationContract]
   [TransactionFlow(TransactionFlowOption.Allowed)]
   void UpdateData();
}

ステップ3-TransactionScopeRequired属性を使用したWCFサービスの実装

それは以下に示すコードを使用して行われます-

[OperationBehavior(TransactionScopeRequired = true)]
public void UpdateData() {
   try {
      SqlConnection objConnection = new SqlConnection(strConnection);
      objConnection.Open();

      using(SqlTransaction transaction = Program.dbConnection.BeginTransaction()) {
           Boolean doRollback = false;
           using(SqlCommand cmd = new SqlCommand(
            "insert into Customer (Customer name, Customer code) values ('sss', 'sss')"objConnection))

           try {
            cmd.ExecuteNonQuery();
           } catch(SqlException) {
            doRollback = true;
            break;
           }
      }

      if(doRollback)
         transaction.Rollback();
      else
         transaction.Commit();
   }
   finally {
      objConection.Close();
   }
}

ステップ4-WCFサービス構成ファイルによるトランザクションフローの有効化

そのコーディングは次のように行われます-

<bindings>
   <wsHttpBinding>
      <binding name = "TransactionalBind" transactionFlow = "true"/>
   </wsHttpBinding>
</bindings>

WCFサービスを公開するには、トランザクション許容バインディングをエンドポイントにアタッチすることが重要です。

<endpoint address = "" binding = "wsHttpBinding" bindingConfiguration = "TransactionalBind" contract = "WcfService1.IService1">

ステップ5-単一のトランザクションで両方のサービスを呼び出す

ここでは、上記の2つのサービスが1つのトランザクションで呼び出され、この目的のために、TransactionScopeオブジェクトを使用して両方のサービスをグループ化します。上記のオブジェクトのCompleteメソッドは、WCFトランザクションをコミットするために呼び出されます。ロールバックするには、Disposeメソッドを呼び出します。

using (TransactionScope ts = new TransactionScope(TransactionScopeOption.RequiresNew)) {
   try {
     //Call your webservice transactions here
      ts.Complete();
   } catch (Exception ex) {
      ts.Dispose();
   }
}

WCFトランザクションが1つのスコープにグループ化されている完全なコードの小さな部分を以下に示します-

using (TransactionScope ts = new TransactionScope(TransactionScopeOption.RequiresNew)) {
   try {
      ServiceReference1.Service1Client obj = newServiceReference1.Service1Client();
      obj.UpdateData();
      ServiceReference2.Service1Client obj1 = new ServiceReference2.Service1Client();
      obj1.UpdateData();
      ts.Complete();
   } catch (Exception ex) {
      ts.Dispose();
   }
}

ステップ6-WCFトランザクションのテスト

テストは6番目の最終ステップで行われ、最初のWCFサービスを呼び出した後、例外が強制されます。

Wcf Transaction Enable 2

WCF-Riaサービス

WCF RIAサービスは、クライアントサイドの検証を提供することにより、Silverlightで複雑なビジネスアプリケーションを構築する手順を容易にする、高レベルのフレームワークであり、.NET 4やSilverlight 4などのフレームワークの新しいコンポーネントです。 RIAは、リッチインターネットアプリケーションの略です。

ここで、SilverlightはMicrosoftが提供するフレームワークであり、リッチインターネットアプリケーションに最適であり、Adobe Flashと同様にブラウザープラグインとして使用できることに注意する必要があります。

WCF RIAサービスは、主にWCFサービスの標準バージョンに基づいています。次の図は、WCF RIAサービスが一般的に焦点を当てているWCFアーキテクチャの一部を示しています。

Wcf RIAサービス1

WCF RIAサービスの作成は、概念をよりよく理解するための次のステップです。段階的な手順を以下に示します。

ステップ1 *-Silverlight 5を使用してSLWCFRiaServices.Webという名前の新しいWebプロジェクトを作成し、ADO.NET Entity Data Modelを選択して新しいアイテムを追加します。

Wcf RIA Services 2 Wcf RIA Services 3

ステップ2 *-データベースからモデルを生成して、エンティティデータモデルウィザードからモデルの内容を選択します。

Wcf RIAサービス4

ステップ3 *-同じウィザードから、データ接続とデータベースオブジェクトを選択します。

Wcf RIA Services 5 Wcf RIA Services 6

ステップ4 *-将来、データモデルの認識が作成するドメインサービスにとって問題にならないようにソリューションを構築します。

Wcf RIA Services 7

ステップ5 *-新しいアイテムを追加してWebプロジェクトにドメインサービスを作成し、クライアントアクセスを有効にします。

Wcf RIA Services 8 Wcf RIA Services 9

ステップ6 *-次のステップでは、いくつかのクラスが生成され、それらを再度ビルドすることが不可欠です。

Wcf RIA Services 10 Wcf RIA Services 11

ステップ7 *-このステップでは、DataDomainContextがデータソースパネルに表示されます。

Wcf RIA Services 12

ステップ8 *-このステップでは、DataDomainContextの下の記事を選択してカスタマイズする必要があります。

Wcf RIA Services 13

ステップ9 *-DataGridコントロールとデータソースの接続は、テーマの選択とともにここでコミットされるステップです。ここではBureauBlueテーマが選択されています。

Wcf RIA Services 14 Wcf RIA Services 15

ステップ10 *-最後と最後のステップは、デザイン画面に移動し、単純なドラッグアンドドロップでMainPageのレイアウトエリアにエンティティを追加することです。 AutoGenerateColumns = "True"を確認し、それを実行して出力を表示することも重要です。

Wcf RIA Services 16 Wcf RIA Services 17

前提条件

WCF RIAサービスの可能性を最大限に活用するには、いくつかの前提条件があります-

Visual Studio 2010/Visual Studio 2012
Silverlight開発者ランタイム
RIA Services Toolkitの最新バージョン
SDK（ソフトウェア開発キット）

WCF RIAドメインサービス

ドメインサービスは、ビジネスに関連する一連のデータ操作で構成されます。 WCF RIAサービスアプリケーションのビジネスロジックを公開するのは、WCFサービスに他なりません。

WCF RIAドメインサービスには内部的にホスティングクラスDomainServiceHostがあり、アプリケーションをホストするためにWCF ServiceHostクラスを使用します。クライアントプロジェクトがドメインサービスにアクセスできるようにするには、EnableClientAccessAttribute属性が必要です。この属性は、新しいドメインサービスクラスが追加されるたびに自動的に適用されます。

次の図は、WCF RIAドメインサービスのアーキテクチャを示しています-

Wcf RIA Services 18

WCF RIAサービス–データのクエリ

次の図は、クエリをクライアント側で作成し、サーバー側で実行してクエリ可能な結果を返す方法を示しています。 DALはデータアクセスレイヤーの略です。

Wcf RIA Services 19

WCF RIAサービス–データの更新

次の図は、サーバー側でCUD（更新更新削除）操作を実行することによりデータが更新される方法を示しています。ここで、WCF RIAサービスは常にサーバー側でステートレスであることに注意する必要があります。

Wcf RIA Services 20

WCF-セキュリティ

WCFサービスは、2つのセキュリティモードまたはレベルを備えた堅牢なセキュリティシステムを備えているため、目的のクライアントのみがサービスにアクセスできます。分散トランザクションで一般的なセキュリティの脅威は、WCFによって大幅に緩和されます。

主なセキュリティ機能

WCFサービスには、次の図に示す4つの主要なセキュリティ機能があります。

Wcfセキュリティ

認証-ここでは、認証はメッセージの送信者を識別することに限定されず、相互に行われます。つまり、あらゆる種類の中間者攻撃の可能性を排除するためにメッセージ受信者の認証が必要です。
承認-これは、セキュリティを確保するためにWCFサービスによって行われる次のステップであり、ここで、サービスが発信者にさらに進むことを承認するかどうかを決定します。承認は認証に依存しませんが、通常は認証に従います。
機密性-発信者とサービスの間の情報交換は、メッセージが意図されていない他者による解釈を制限するために機密に保たれます。これを可能にするために、暗号化はさまざまな他のメカニズムとともに使用されます。
整合性-最後の重要な概念は、整合性を維持することです。つまり、メッセージが送信者から受信者への移動中に誰にも改ざんされていないことを保証します。

転送セキュリティモード

WCFは、クライアントとサーバー間の安全な通信を確保するために、次の転送セキュリティモードを提供します。さまざまな転送セキュリティモードについて以下に説明します。

なし-このモードは、いかなる種類のメッセージセキュリティも保証せず、サービスはクライアントに関する資格情報を取得しません。このモードは、メッセージの改ざんを許可する可能性があるため、非常にリスクが高いため、お勧めしません。

<wsHttpBinding>
   <binding name = "WCFSecurityExample">
      <security mode = "None"/>
   </binding>
</wsHttpBinding>

Transport -このモードは、TCP、IPC、Https、MSMQなどの通信プロトコルを使用してメッセージの安全な転送を実現する最も簡単な方法です。このモードは、転送がポイントツーポイントであり、主に制御された環境、つまりイントラネットアプリケーションで使用される場合により効果的です。

<wsHttpBinding>
   <binding name = "WCFSecurityExample">
      <security mode = "Transport"/>
   </binding>
</wsHttpBinding>

メッセージ-セキュリティモードは相互認証を許可し、メッセージが暗号化され、安全なプロトコルとは見なされないhttpを介して転送できるため、プライバシーを大幅に提供します。ここでは、メッセージ転送に関与する仲介者の数や、保護されたトランスポートがあるかどうかを考慮せずに、セキュリティがエンドツーエンドで提供されます。このモードは通常、インターネットアプリケーションで使用されます。

<wsHttpBinding>
   <binding name = "WCFSecurityExample">
      <security mode = "Message"/>
   </binding>
</wsHttpBinding>

混合-このセキュリティモードは頻繁には使用されず、クライアント認証はクライアントレベルでのみ提供されます。

<wsHttpBinding>
   <binding name = "WCFSecurityExample">
      <security mode = "TransportWithMessageCredential"/>
   </binding>
</wsHttpBinding>

両方-このセキュリティモードは、トランスポートセキュリティとメッセージセキュリティの両方で構成され、堅牢なセキュリティカバーを提供しますが、多くの場合、全体的なパフォーマンスが過負荷になります。これはMSMQのみでサポートされています。

<netMsmqBinding>
   <binding name = "WCFSecurityExample">
      <security mode = "Both"/>
   </binding>
</netMsmqBinding>

BasicHttpBindingを除くすべてのWCFバインディングには、デフォルトである程度の転送セキュリティがあります。

メッセージセキュリティレベル

メッセージレベルのセキュリティは、WCFプロトコルに依存しません。標準のアルゴリズムを使用してデータを暗号化することにより、メッセージデータ自体で使用されます。メッセージセキュリティレベルのさまざまなバインディングには、多くのクライアント資格情報が利用可能です。これらについては以下で説明します。

WCFのメッセージレベルセキュリティのクライアント資格情報*

なし-ここでは、暗号化はメッセージを保護するために使用されますが、クライアント認証は実行されません。つまり、匿名クライアントはサービスにアクセスできます。 BasicHttpBindingを除き、すべてのWCFバインディングはこのクライアント資格情報をサポートします。ただし、NetNamedPipeBindingの場合、このクライアント資格情報はまったく使用できないことに注意してください。

Windows -ここでは、リアルタイムのログインユーザーに対してメッセージ暗号化とクライアント認証の両方が行われます。この場合も、他のすべてのWCFバインディングとは異なり、NetNamedPipeBindingは使用できず、BasicHttpBindingはサポートを提供しません。
UserName -ここでは、メッセージはUserNameを提供することで暗号化およびセキュリティ保護され、クライアントはパスワードを提供する必要があるため認証されます。上記の2つのクライアント資格情報と同様に、BasicHttpBindingはUserNameをサポートせず、NetNamedPipeBindingでは使用できません。
証明書-メッセージの暗号化に加えて、クライアントとサービスの両方が証明書による認証を取得します。このクライアント資格情報は利用可能であり、NetNamedPipeBindingを除くすべてのWCFバインディングによってサポートされています。
IssuedToken -Cardspaceなどの機関から発行されたトークンは、メッセージの認証に使用されます。メッセージの暗号化もここで実行されます。

次のコードは、WCFメッセージセキュリティレベル/モードでクライアント資格情報がどのように構成されているかを示しています。

<netTcpBinding>
   <binding name = "WCFMessageSecurityExample">
      <security mode = "Message">
         <message clientCredentialType = "None"/>
      </security>
   </binding>
</netTcpBinding>

<netMsmqBinding>...</netMsmqBinding>
</bindings>
<behaviors>...</behaviors>

ここで、前者の方が高速であるため、トランスポートセキュリティモードはメッセージセキュリティレベルよりも優れていることに注意する必要があります。追加のコーディングを必要とせず、相互運用性をサポートするため、全体的なパフォーマンスが低下することはありません。

ただし、セキュリティの観点から見ると、メッセージセキュリティモードはより堅牢で、プロトコルに依存せず、エンドツーエンドのセキュリティを提供します。

WCF-例外処理

WCFサービス開発者は、適切な方法でクライアントに報告する必要がある予期しないエラーに遭遇する場合があります。 *例外*として知られるこのようなエラーは、通常、try/catchブロックを使用して処理されますが、これも非常に技術特有です。

クライアントの関心領域は、エラーの発生方法やエラーの原因に関するものではないため、SOAP Faultコントラクトを使用して、WCFでサービスからクライアントにエラーメッセージを伝達します。

フォールトコントラクトにより、クライアントはサービスで発生したエラーの文書化されたビューを持つことができます。次の例は、より良い理解を提供します。

ステップ1 *-一般的な例外を生成する除算操作で簡単な電卓サービスが作成されます。

using System;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Runtime.Serialization;
usingSystem.ServiceModel;
usingSystem.Text;

namespace Calculator {
  //NOTE: You can use the "Rename" command on the "Refactor" menu to change
  //the interface name "IService1" in both code and config file together.

   [ServiceContract]

   public interface IService1 {
      [OperationContract]
      int divide(int num1, int num2);
     //TODO: Add your service operations here
   }
}

クラスファイルのコーディングは以下に示されています-

Wcf例外処理2

ここで、数値10をゼロで除算しようとすると、電卓サービスは例外をスローします。

Wcf例外処理3

Wcf例外処理4

例外は、try/catchブロックで処理できます。

Wcf例外処理5

整数を0で除算しようとすると、catchブロックで処理したため、値10が返されます。

Wcf例外処理6

ステップ2 *-このステップでは、FaultExceptionを使用して、サービスからクライアントに例外情報を伝えます。

public int Divide(int num1, int num2) {
  //Do something
   throw new FaultException("Error while dividing number");
}

Wcf例外処理7

ステップ3 *-FaultContractを使用してエラーメッセージを送信するカスタムタイプを作成することもできます。カスタムタイプを作成するために不可欠な手順は以下に記載されています-

タイプはデータコントラクトの使用によって定義され、返されることを目的としたフィールドが指定されます。

サービス操作は、FaultContract属性によって装飾されます。タイプ名も指定されます。

サービスインスタンスが作成されて例外が発生し、カスタム例外プロパティが割り当てられます。

Wcf-quick-guide

WCF-概要

WCFの基本概念

メッセージ

終点

住所

製本

契約

ホスティング

メタデータ

WCFクライアント

チャネル

SOAP

WCFの利点

WCF-対Webサービス

WCF-開発者ツール

マイクロソフトビジュアルスタジオ

CodePlex

WCF-アーキテクチャ

契約

サービスランタイム

メッセージング

アクティベーションとホスティング

WCF-WCFサービスの作成

WCF-ホスティングWCFサービス

WCF-IISホスティング

WCF-セルフホスティング

WCF-WASホスティング

WASホストサービスを作成する

ホストされたサービスへの異なるバインディングを有効にする

WCF-Windowsサービスホスティング

WCF-WCFサービスの利用

IIS 5/6でホストされているWCFサービスの使用

セルフホストWCFサービスの使用

WASでホストされているWCFサービスの使用

WindowsサービスでホストされているWCFサービスの使用

WCF-サービスバインディング

基本的なバインド

Webサービスバインディング

IPCバインディング

他のタイプのサービスバインディング

WCF-インスタンス管理

コールごとのサービス

コールごとのサービスの実装

セッションごとのサービス

サービスコード

クライアントコード

出力

シングルトンサービス

サービスコード

ホストコード

クライアントコード

出力

WCF-トランザクション

例

WCFトランザクションプロパティ

トランザクションプロトコル

WCFトランザクションのフェーズ

WCFトランザクションを有効にする

WCF-Riaサービス

前提条件

WCF RIAドメインサービス

WCF RIAサービス–データのクエリ

WCF RIAサービス–データの更新

WCF-セキュリティ

主なセキュリティ機能

転送セキュリティモード

メッセージセキュリティレベル

WCF-例外処理