常連

# 実現したいこと（目的）
HTTPプロトコルを介して他のコンピューター上のアプリケーションとデータを交換したい。
要件:
- 盗聴、改竄、なりすまし対策が施されている。
- セルフホストである（IISは使用しない。）

# 試したこと
- WCFを使用
- RESTFul方式(WebHttpBinding)を使用
- SSLを使用
　　但し、サーバー証明書をコンピューターにインポートする手順に未精通なため、サービスのアプリケーションが直接pfxファイルを読み込んで行う方式で実装している。

# 問題点
エラー（後述）が発生して、データを交換できない。

よろしくお願い致します。

#概要
###通信イメージ
![イメージ説明](2e1f1235bf9ab63aa317480b96c9f924.png)
![イメージ説明](f09dafb506730ea172ef2ce95321b091.png)

###サービス外観
![![イメージ説明](4e6e51328a17d2ac8708e17027422a39.png)](2365d4e98d69129cd3192ba7cf05c2b8.png)

###サービス利用側外観
![イメージ説明](d138b60dfd5e32824f57d948395302ac.png)

どうぞよろしくお願い致します。

# 該当のソースコード
![イメージ説明](397bd5759792bab8127b0d557f2db3f1.png)

### サービス
###### Program.cs
```C#
using System;
using System.Security.Cryptography.X509Certificates;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Security;
using System.ServiceModel.Web;

namespace TestService
{
    class Program
    {
        static WebServiceHost host;

        static void Main()
        {
            //--------------------------バインディング
            WebHttpBinding binding = new WebHttpBinding();
            binding.Security.Mode = WebHttpSecurityMode.Transport;
            binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate;
            binding.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.None;

            //--------------------------アドレス
            Uri uri = new Uri("https://localhost:5000/TestService");

            //--------------------------サービスの作成とエンドポイントの追加
            host = new WebServiceHost(typeof(TestService));
            ServiceEndpoint se = host.AddServiceEndpoint(typeof(ITestService), binding, uri);

            var behavior = new WebHttpBehavior();
            behavior.FaultExceptionEnabled = false;
            behavior.HelpEnabled = true;
            behavior.DefaultOutgoingRequestFormat = WebMessageFormat.Json;
            behavior.DefaultOutgoingResponseFormat = WebMessageFormat.Json;
            se.EndpointBehaviors.Add(behavior);

            //--------------------------
            ServiceDebugBehavior debug = host.Description.Behaviors.Find<ServiceDebugBehavior>();
            debug.IncludeExceptionDetailInFaults = true;

            ServiceMetadataBehavior metad = new ServiceMetadataBehavior();
            metad.HttpGetEnabled = true;
            metad.HttpsGetEnabled = true;
            host.Description.Behaviors.Add(metad);

            //--------------------------
            var certificate = new X509Certificate2(@"D:\Work\TestService\ServerCert1.pfx", "pswd", X509KeyStorageFlags.UserKeySet);
            host.Credentials.ServiceCertificate.Certificate = certificate;
            host.Credentials.ClientCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None;

            //--------------------------
            host.Open();
            Console.WriteLine(string.Format(null, "URL : {0}", uri.ToString()));
            Console.WriteLine("Press <ENTER> to terminate");
            Console.ReadLine();
            host.Close();

        }
    }
}


```

##### ITestService.cs
```C#
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;

namespace TestService
{
    [ServiceContract]
    interface ITestService
    {
        [OperationContract]
        [WebInvoke(Method = "POST"
                            , RequestFormat = WebMessageFormat.Json
                            , UriTemplate = "/PostMsg"
            )]
        MessageData PostMsg(MessageData msg);
    }

    [DataContract]
    public class MessageData
    {
        [DataMember]
        public string Name { get; set; }

        [DataMember]
        public int Gender { get; set; }

        [DataMember]
        public int Age { get; set; }

    }

}


```

##### TestService.cs
```C#
using System;

namespace TestService
{
    class TestService : ITestService
    {
        public MessageData PostMsg(MessageData msg)
        {
            Console.WriteLine(string.Format(null, "受信 : {0}", msg.ToString()));

            return new MessageData()
            {
                Name = msg.Name,
                Gender = msg.Gender,
                Age = msg.Age + 1
            };
        }

    }
}


```

### サービス利用側
##### Form1.cs
```C#
using System;
using System.Windows.Forms;
using System.Security.Cryptography.X509Certificates;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Security;
using System.ServiceModel.Web;
using TestService;

namespace TestClient
{
    public partial class Form1 : Form
    {
        WebChannelFactory<ITestService> cf = null;
        ITestService channel = null;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            listBox1.HorizontalScrollbar = true;

            Uri uri = new Uri("https://123.123.123.123:5000/TestService");
            EndpointAddress endpointAddress = new EndpointAddress(uri);

            //--------------------------チャンネル
            cf = new WebChannelFactory<ITestService>(uri);
            WebHttpBinding binding = cf.Endpoint.Binding as WebHttpBinding;
            binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate;
            binding.Security.Mode = WebHttpSecurityMode.Transport;

            var behavior = new WebHttpBehavior();
            behavior.FaultExceptionEnabled = false;
            behavior.HelpEnabled = true;
            behavior.DefaultOutgoingRequestFormat = WebMessageFormat.Json;
            behavior.DefaultOutgoingResponseFormat = WebMessageFormat.Json;
            cf.Endpoint.Behaviors.Add(behavior);

            var clientCertificate = new X509Certificate2(@"D:\Work\TestService\ServerCert1.pfx", "pswd", X509KeyStorageFlags.UserKeySet);
            cf.Credentials.ClientCertificate.Certificate = clientCertificate;
            cf.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None;

            channel = cf.CreateChannel();

        }

        private void button1_Click(object sender, EventArgs e)
        {
            MessageData msg = new MessageData()
            {
                Name = "Taro",
                Gender = 1,
                Age = 3
            };
            MessageData rtn = channel.PostMsg(msg);   //<--------ここでエラー発生
            listBox1.Items.Insert(0, string.Format("Name:{0}, Gender:{1}, Age{2} ", rtn.Name, rtn.Gender, rtn.Age));

        }
    }
}


```

## エラー内容
https://123.123.123.123:5000/TestService/PostMsg に対する HTTP 要求の発行中にエラーが発生しました。この原因としては、HTTPS ケースの HTTP.SYS でサーバー証明書が正しく構成されていないこと、またはクライアントとサーバーの間でセキュリティ バインドが整合していないことが考えられます。

##### 証明書作成
```DOS
自己証明機関の作成
makecert -n "CN=ServerCN1" -a sha1 -eku 1.3.6.1.5.5.7.3.3 -r -sv ServerCert1.pvk ServerCert1.cer -ss Root -sr localMachine -cy authority -b 11/06/2019 -e 12/31/2019

ソフトウェア発行元証明書の作成
cert2spc ServerCert1.cer ServerCert1.spc

個人情報交換ファイルの作成
pvk2pfx -pvk ServerCert1.pvk -spc ServerCert1.spc -po pswd -pfx ServerCert1.pfx -f
```
#試したこと１
①パワーシェルで、以下のコマンドを実行し、証明書の捺印を取得
Get-PfxCertificate -FilePath ServerCert1.pfx

②トランスポート層で X.509 証明書を使用して認証するクライアントをサポートするために
netsh http add sslcert ipport=0.0.0.0:5000 certhash=9512A6EA3042F7717EA02194097187207136E5FB appid={541eea84-c788-4d23-b6b2-f5210bcdf5c5} clientcertnegotiation=enable
を実行　※certhashに①で取得した捺印を、appidには、Visual StudioのサービスプロジェクトのプロパティウィンドウにあるGUIDを設定。

＝＝＝＞下記エラー発生
SSL 証明書を追加できませんでした。エラー: 1312
指定されたログオン セッションは存在しません。そのセッションは既に終了している可能性があります。

#試したこと２
サービスとクライアントの各ソースコードからセキュリティ関連のコードを除去した場合は、正常なメッセージのやり取りが実現できています。

#試したこと３
X509Certificate2メソッドのパスワードの引数をわざと違うものに設定するとちゃんとエラーになります。

#補足１
IISでは.pfxファイルをコンピュータにインポートするが、今回の試みでは、X509Certificate2メソッドの引数にファイルを指定している。

#補足２
HTTPS通信は、共通鍵暗号方式と公開鍵暗号方式のハイブリッドで成り立っているらしい。

### 環境
Microsoft Windows 10 Pro (Version 1903)
Microsoft Visual Studio Community 2019
Microsoft .NET Framework 4.7.2

HTTPプロトコルを介して他のコンピューターのアプリケーションとデータを安全に交換したい。（セルフホスト）

お世話になっております。

**行いたいこと**
同一PC内で2つのソフトウェア間でbyte配列の受け渡しを行いたいと思っています。
クライアント側から要求があった際にホスト側からbyte配列を送信する仕様にしたいと思っています。
配列の大きさは最大11,059,200byteを予定しています。

**問題点**
大量のデータを送信しようすると下記のようなエラーが出力されます。
最後にソースコードを記載しています。

**エラー**
`Host`クラスの`callback.SendByteArr(arr);`にて
__System.ServiceModel.CommunicationException: 'パイプ パイプを閉じています。 (232, 0xe8) への書き込みエラーが発生しました。'
内部例外
PipeException: パイプ パイプを閉じています。 (232, 0xe8) への書き込みエラーが発生しました。__

**試したこと**
エラー内容で調べたところ帯域不足の可能性があるなどの情報が得られたので
構成エディター ツール (SvcConfigEditor.exe)で**ソースコード**＞App.configのように帯域の値を大きくしてみました。[このページ](https://www.pine4.net/Memo/Article/Archives/39)などを参考にしました。
→ 同じエラーが出力される

Host側のarrのサイズ変更
(1) `var arr = new byte[500];`  → ○
(2) `var arr = new byte[65000];`  → ○
(3) `var arr = new byte[65500];`  → ×
上記の(3)よりデフォルトの帯域最大値である65535より小さい値でも同一のエラーが出力されることが分かりました。
これにより帯域以外に原因があるのではと考えました。

**質問**
・エラーの原因・解決策などありましたら教示いただけないでしょうか。
・また、WCF以外にプロセス間で大量データをやりとりする手法があれば教えて頂ければ幸いです。

**ソースコード**
```C#
        // サーバー・クライアント共通インターフェース
        [ServiceContract(CallbackContract = typeof(ICallback))]
        internal interface IHost
        {
            [OperationContract(IsOneWay = true)]
            void ByteArrRequest();
        }

        [ServiceContract]
        internal interface ICallback
        {
            [OperationContract(IsOneWay = true)]
            void SendByteArr(byte[] bs);
        }
```
```C#
        // ホスト側
        [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Multiple, UseSynchronizationContext = false)]
        public class Host : IHost
        {
            public void ByteArrRequest()
            {
                Console.WriteLine("[HOST]: CLIENTから要求あり");

                var callback = OperationContext.Current.GetCallbackChannel<ICallback>();

                var arr = new byte[65500];
                callback.SendByteArr(arr); // ★ここでエラーが出力される
            }
        }

        ServiceHost sh;
        public MainWindow()
        {
            InitializeComponent();

            const string addr = "net.pipe://localhost/test1";
            var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
            // 追記1(解決策)
            binding.MaxReceivedMessageSize = 64000000;
            binding.MaxBufferSize = 64000000;
            var readerQuotas = new XmlDictionaryReaderQuotas();
            readerQuotas.MaxArrayLength = 64000000;
            readerQuotas.MaxStringContentLength = 64000000;
            readerQuotas.MaxDepth = 32;
            binding.ReaderQuotas = readerQuotas;
            // 追記1ここまで
            sh = new ServiceHost(typeof(Host));
            sh.AddServiceEndpoint(typeof(IHost), binding, addr);
            sh.Open();
        }
```
```C#
        // クライアント側
        class Callback : ICallback
        {
            public void SendByteArr(byte[] message)
            {
                Console.WriteLine(message.Length);
            }
        }

        public MainWindow()
        {
            InitializeComponent();

            const string addr = "net.pipe://localhost/test1";
            var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
            // 解決策
            binding.MaxReceivedMessageSize = 64000000;
            binding.MaxBufferSize = 64000000;
            var readerQuotas = new XmlDictionaryReaderQuotas();
            readerQuotas.MaxArrayLength = 64000000;
            readerQuotas.MaxStringContentLength = 64000000;
            readerQuotas.MaxDepth = 32;
            binding.ReaderQuotas = readerQuotas;
            // 解決策ここまで
            var host = DuplexChannelFactory<IHost>.CreateChannel(new InstanceContext(new Callback()), binding, new EndpointAddress(addr));

            host.ByteArrRequest();
        }
```
↓ App.config(ホスト・クライアント共に同一内容)
```XAML
  <system.serviceModel>
    <bindings>
      <netNamedPipeBinding>
        <binding name="NewBinding0" closeTimeout="00:20:00" openTimeout="00:20:00"
          receiveTimeout="00:20:00" sendTimeout="00:20:00" maxBufferSize="64000000"
          maxReceivedMessageSize="64000000">
          <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="64000000"
            maxBytesPerRead="64000000" />
        </binding>
      </netNamedPipeBinding>
    </bindings>
    <behaviors>
      <endpointBehaviors>
        <behavior name="NewBehavior0">
          <dataContractSerializer maxItemsInObjectGraph="10000000" />
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="MyBehavior">
          <dataContractSerializer maxItemsInObjectGraph="100000000" />
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
```
**環境**
C# .Net F/W 4.6.1
WPF

C# WCFで大容量通信時のエラーに関して

### 実行環境
VB/C#
WPF .Net Framework4.7.2

### 実現したいこと
プロセス間通信を行いフォームからフォームへ通信を行いたいです。

※イメージ
![![イメージ説明](1c64d47da58a7a0556d2b1c4f0458540.png)

### 進捗状況
Form1,Form2の画面の表示(インスタンスの生成)は出来ています。

### ソースコード
※フォーム１はC#、フォーム２はVBで開発しています。

①フォーム１のXAML
```
<Window x:Class="Form1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <TextBox x:Name="TextBox1" HorizontalAlignment="Left" Height="23" Margin="61,40,0,0" TextWrapping="Wrap" VerticalAlignment="Top" Width="120"/>
        <Button Content="Button" HorizontalAlignment="Left" Margin="238,40,0,0" VerticalAlignment="Top" Width="75" Height="23" Click="Button_Click"/>
    </Grid>
</Window>
```

②フォーム１のコードビハインドクラス
```
namespace Form1
{
    /// <summary>
    /// MainWindow.xaml の相互作用ロジック
    /// </summary>
    public partial class MainWindow : Window
    {
        private IWcfClient Host;

        public MainWindow()
        {
            Process.Start("Form2.exe");

            Host = new ChannelFactory<IWcfClient>(
                new NetNamedPipeBinding(NetNamedPipeSecurityMode.None),
                new EndpointAddress("net.pipe://localhost/Form2")).CreateChannel();

            InitializeComponent();
        }

        /// <summary>
        /// ボタン押下時のイベント
        /// </summary>
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var message = Host.CallExecute(TextBox1.Text);
                MessageBox.Show(message);
            }
            catch(FaultException<FailureInfo> fx)
            {
                FailureInfo info = fx.Detail;
                MessageBox.Show(info.Message);
            }
        }
    }
}

```

③サービスのインタフェース
```
namespace Form1
{
    [ServiceContract]
    public interface IWcfClient
    {
        [OperationContract]
        [FaultContract(typeof(FailureInfo))]
        string CallExecute(string text);
    }
}
```

④サービスの具象クラス
```
namespace Form1
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
    public class WcfClient: IWcfClient
    {
        public string CallExecute(string text)
        {
　　　　　　　// WCF通信で発生する例外を追跡するためにthrow
            throw new FaultException<FailureInfo>(new FailureInfo(), "WCF通信エラー");
        }
    }
}
```

⑤デバッグ用（FaultExceptionでプロセス間通信の例外を見るために使用）
```
namespace Form1
{
    [DataContract]
    public class FailureInfo
    {
        [DataMember]
        public string Message
        {
            get; set;
        }
    }
}
```

⑥フォーム２のコードビハインドクラス
```
''' <summary>
''' Form2のコードビハインド
''' </summary>
Public Class MainWindow
    Public Host As ServiceHost
    Public Const Uri As String = "net.pipe://localhost/Form2"

    Public Sub New()
        Host = New ServiceHost(GetType(WcfClient))
        Host.AddServiceEndpoint(
                GetType(IWcfClient),
                New NetNamedPipeBinding(NetNamedPipeSecurityMode.None),
                New Uri(Uri))
        Host.Open()

        InitializeComponent()
    End Sub

    ''' <summary>
    ''' テキストボックスに値をセットする
    ''' </summary>
    Public Function Reply(ByVal text As String) As String
　　　　　// テキストボックスにフォーム1より受け取った値をセット
        TextBox1.Text = text
        Return "Form2 Replyメソッドが呼ばれました"
    End Function
End Class
```

### 試行内容
「④サービスの具象クラス」を以下のようにFacadeを用い、呼び出すアセンブリ・クラス・メソッドを動的に指定出来るように書き替え、Form1からForm2へプロセス間通信を実行しました。
```
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
    public class WcfClient: IWcfClient
    {
        public string CallExecute(string text)
        {
            // Facadeを用いてForm２のReplyメソッドをコール
            return Facade<string>("Form2.exe", "Form2.MainWindow", "Reply", text);
        }
        private T Facade<T>(string assembly, string className, string methodName, string text = "")
        {
            string path = Environment.CurrentDirectory + @"\" + assembly;
            Assembly asm = Assembly.LoadFrom(path);
            object obj = asm.CreateInstance(className);
            Type type = obj.GetType();
            MethodInfo mi = type.GetMethod(methodName);
            object[] param = new object[1];
            param[0] = text;
            object returnObj = mi.Invoke(obj, param);
            return (T)returnObj;
        }
    }
}
```
上記を実行した結果、以下のスタックトレースが出力されました。
```
System.ServiceModel.FaultException
  HResult=0x80131501
  Message=内部エラーのため、クライアントは要求を処理できませんでした。このエラーの詳細については、例外情報をクライアントに返信するためにサーバーで IncludeExceptionDetailInFaults を有効にするか (ServiceBehaviorAttribute または <serviceDebug> 構成動作を通じて)、Microsoft .NET Framework SDK ドキュメントに従ってトレースを有効にして、サーバーのトレース ログを調べてください。
  Source=mscorlib
  スタック トレース:
   場所 System.Runtime.Remoting.Proxies.RealProxy.HandleReturnMessage(IMessage reqMsg, IMessage retMsg)
   場所 System.Runtime.Remoting.Proxies.RealProxy.PrivateInvoke(MessageData& msgData, Int32 type)
   場所 Form1.IWcfClient.CallExecute(String text)
   場所 Form1.MainWindow.Button_Click(Object sender, RoutedEventArgs e) (C:\workspace\20191020\WcfConnection\Form1\MainWindow.xaml.cs):行 34
   場所 System.Windows.RoutedEventHandlerInfo.InvokeHandler(Object target, RoutedEventArgs routedEventArgs)
   場所 System.Windows.EventRoute.InvokeHandlersImpl(Object source, RoutedEventArgs args, Boolean reRaised)
   場所 System.Windows.UIElement.RaiseEventImpl(DependencyObject sender, RoutedEventArgs args)
   場所 System.Windows.UIElement.RaiseEvent(RoutedEventArgs e)
   場所 System.Windows.Controls.Primitives.ButtonBase.OnClick()
   場所 System.Windows.Controls.Button.OnClick()
   場所 System.Windows.Controls.Primitives.ButtonBase.OnMouseLeftButtonUp(MouseButtonEventArgs e)
   場所 System.Windows.UIElement.OnMouseLeftButtonUpThunk(Object sender, MouseButtonEventArgs e)
   場所 System.Windows.Input.MouseButtonEventArgs.InvokeEventHandler(Delegate genericHandler, Object genericTarget)
   場所 System.Windows.RoutedEventArgs.InvokeHandler(Delegate handler, Object target)
   場所 System.Windows.RoutedEventHandlerInfo.InvokeHandler(Object target, RoutedEventArgs routedEventArgs)
   場所 System.Windows.EventRoute.InvokeHandlersImpl(Object source, RoutedEventArgs args, Boolean reRaised)
   場所 System.Windows.UIElement.ReRaiseEventAs(DependencyObject sender, RoutedEventArgs args, RoutedEvent newEvent)
   場所 System.Windows.UIElement.OnMouseUpThunk(Object sender, MouseButtonEventArgs e)
   場所 System.Windows.Input.MouseButtonEventArgs.InvokeEventHandler(Delegate genericHandler, Object genericTarget)
   場所 System.Windows.RoutedEventArgs.InvokeHandler(Delegate handler, Object target)
   場所 System.Windows.RoutedEventHandlerInfo.InvokeHandler(Object target, RoutedEventArgs routedEventArgs)
   場所 System.Windows.EventRoute.InvokeHandlersImpl(Object source, RoutedEventArgs args, Boolean reRaised)
   場所 System.Windows.UIElement.RaiseEventImpl(DependencyObject sender, RoutedEventArgs args)
   場所 System.Windows.UIElement.RaiseTrustedEvent(RoutedEventArgs args)
   場所 System.Windows.UIElement.RaiseEvent(RoutedEventArgs args, Boolean trusted)
   場所 System.Windows.Input.InputManager.ProcessStagingArea()
   場所 System.Windows.Input.InputManager.ProcessInput(InputEventArgs input)
   場所 System.Windows.Input.InputProviderSite.ReportInput(InputReport inputReport)
   場所 System.Windows.Interop.HwndMouseInputProvider.ReportInput(IntPtr hwnd, InputMode mode, Int32 timestamp, RawMouseActions actions, Int32 x, Int32 y, Int32 wheel)
   場所 System.Windows.Interop.HwndMouseInputProvider.FilterMessage(IntPtr hwnd, WindowMessage msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
   場所 System.Windows.Interop.HwndSource.InputFilterMessage(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
   場所 MS.Win32.HwndWrapper.WndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
   場所 MS.Win32.HwndSubclass.DispatcherCallbackOperation(Object o)
   場所 System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
   場所 System.Windows.Threading.ExceptionWrapper.TryCatchWhen(Object source, Delegate callback, Object args, Int32 numArgs, Delegate catchHandler)
   場所 System.Windows.Threading.Dispatcher.LegacyInvokeImpl(DispatcherPriority priority, TimeSpan timeout, Delegate method, Object args, Int32 numArgs)
   場所 MS.Win32.HwndSubclass.SubclassWndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam)
   場所 MS.Win32.UnsafeNativeMethods.DispatchMessage(MSG& msg)
   場所 System.Windows.Threading.Dispatcher.PushFrameImpl(DispatcherFrame frame)
   場所 System.Windows.Threading.Dispatcher.PushFrame(DispatcherFrame frame)
   場所 System.Windows.Application.RunDispatcher(Object ignore)
   場所 System.Windows.Application.RunInternal(Window window)
   場所 System.Windows.Application.Run(Window window)
   場所 System.Windows.Application.Run()
   場所 Form1.App.Main()
```
調べたところ、FaultExceptionの実行例外の詳細をクライアント側で取得するためには⑤のようなデバッグ追跡用のデータクラスが必要であったため、「FailureInfoクラス」を新規作成しました。
そしてプロセス間通信の実行例外（FaultException）のスタックトレースを確認するため「④サービスの具象クラス」のように書き換えました。

### 質問内容
「④サービスの具象クラス」でFaultExceptionをスローし、プロセス間通信の実行例外のスタックトレースを確認した結果、以下が出力されました。
自身で調査しましたが、真因が追求出来ていません。解決策をご存知の方いらっしゃいましたらご教授お願い致します。
```
   場所 System.Runtime.Remoting.Proxies.RealProxy.HandleReturnMessage(IMessage reqMsg, IMessage retMsg)
   場所 System.Runtime.Remoting.Proxies.RealProxy.PrivateInvoke(MessageData& msgData, Int32 type)
   場所 Form1.IWcfClient.CallExecute(String text)
   場所 Form1.MainWindow.Button_Click(Object sender, RoutedEventArgs e) (C:\workspace\20191020\WcfConnection\Form1\MainWindow.xaml.cs):行 34
```

WCF通信 フォーム間のプロセス間通信について

### 前提・実現したいこと

WCFを使用して、名前付きパイプによるプロセス間通信を行うプログラムを実装しています。

プロセス間でイベント通知を行い、データを転送したいのですが、双方向通信にしてもイベントが飛びません。
WCFを利用したプロセス間のイベント通知によるデータ転送の実現方法を教えて頂きたいです。
やりたいことのイメージとして、以下の画像を参考にして下さい。
![イメージ説明](b1fcaceee54f9d08c89526427762a332.png)

ClientとServiceの双方向通信のサンプルはネット上にたくさん転がっていますが、
あるClientがイベントを叩くと、もう一方のClientにイベント通知がされる、
というパターンが見つかりませんでした。

参考としてサイトをご紹介頂ける場合は、英語のサイトでも構いません。

### 発生している問題・エラーメッセージ

WCFによるプロセス間のイベント通知が出来ない。

下記のソースコードのようにすると、以下のようになってしまいます。
1. 1つ目のプロセスでイベント登録(OnCallback)。
2. 2つ目のプロセスでInvokeしようとすると、OnCallbackがnullになっていてInvokeされない。

### 該当のソースコード

サービスの定義（IdataTransferService.cs）
```C#
namespace DataTransferWCFService
{
    [ServiceContract(CallbackContract = typeof(IGetResponseCallback))]
    public interface IDataTransferService
    {
        [OperationContract(IsOneWay = true)]
        void Register(byte[] data);

        [OperationContract(IsOneWay = true)]
        void Clear();
        
        [OperationContract]
        byte[] GetResponse(UInt32 id, byte[] request);

        /// <summary>
        /// コールバック用
        /// </summary>
        /// <param name="id"></param>
        /// <param name="message"></param>
        [OperationContract(IsOneWay = true)]
        void Send(UInt32 id, byte[] message);
    }
}
```

コールバックインターフェースの定義（IGetResponseCallback.cs）
```C#
namespace DataTransferWCFService
{
    public interface IGetResponseCallback
    {
        [OperationContract(IsOneWay = true)]
        void GetResponseCallback(UInt32 id, byte[] message);
    }
}
```

サービスの実装（DataTransferService.cs）
```C#
namespace DataTransferWCFService
{
    public class DataTransferService : IDataTransferService
    {
        private static List<byte[]> dataList = new List<byte[]>();
        
        public void Clear()
        {
            dataList.Clear();
        }

        public byte[] GetResponse(uint id, byte[] request)
        {
            
            byte[] response = dataList.ElementAt((int)id)
                                       .Concat(request)
                                       .ToArray();

            return response;
        }

        public void Register(byte[] data)
        {
            dataList.Add(data);
        }

        /// <summary>
        /// コールバック用
        /// </summary>
        /// <param name="id"></param>
        /// <param name="request"></param>
        public void Send(uint id, byte[] message)
        {
            IGetResponseCallback callback = OperationContext.Current.GetCallbackChannel<IGetResponseCallback>();

            callback.GetResponseCallback(id, message);
        }
    }
}
```

サービスの開始周り（DataTransfer.cs）
```C#
namespace DataTransfer
{
    public class DataTransfer
    {
        public _DataTransfer instance = _DataTransfer.Instance;

        /// <summary>
        /// サービスの開始とチャンネルの実体化
        /// </summary>
        public void PreStart()
        {
            this.instance.Start();
            this.instance.Create();
        }

        /// <summary>
        /// チャンネルの実体化
        /// </summary>
        public void Create()
        {
            this.instance.Create();
        }

        public void Register(byte[] data)
        {
            this.instance.Register(data);
        }

        public void Clear()
        {
            this.instance.Clear();
        }

        public byte[] GetResponse(UInt32 id, byte[] request)
        {
            return this.instance.GetResponse(id, request);
        }
    }

    public class _DataTransfer : IGetResponseCallback
    {
        private static string PIPE_NAME = @"net.pipe://sample";
        public ServiceHost host;
        public IDataTransferService proxy;
        public DuplexChannelFactory<IDataTransferService> factory;
        public delegate void CallbackEventHandler(object sender, CommunicationEventArgs args);
        public event CallbackEventHandler OnCallback;
        //シングルトンパターン
        private static _DataTransfer instance = new _DataTransfer();
        public static _DataTransfer Instance
        {
            get
            {
                return instance;
            }
        }

        private _DataTransfer()
        {

        }

        /// <summary>
        /// サービスを開始
        /// </summary>
        public void Start()
        {
            Instance.host = new ServiceHost(typeof(IDataTransferService), new Uri(PIPE_NAME));

            Instance.host.AddServiceEndpoint(typeof(IDataTransferService), new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
            {
                ReceiveTimeout = TimeSpan.MaxValue
            }, string.Empty);

            try
            {
                host.Open();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// チャンネルの実体化
        /// </summary>
        public void Create()
        {
            Instance.factory = new DuplexChannelFactory<IDataTransferService>(new InstanceContext(Instance), new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
            {
                MaxReceivedMessageSize = Int32.MaxValue
            }, PIPE_NAME);
            Instance.proxy = Instance.factory.CreateChannel();
        }

        public void Clear()
        {
            try
            {
                Instance.proxy.Clear();
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        public void Register(byte[] data)
        {
            try
            {
                Instance.proxy.Register(data);
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

        public byte[] GetResponse(UInt32 id, byte[] request)
        {
            try
            {
                Instance.proxy.Send(id, request);

                byte[] response = Instance.proxy.GetResponse(id, request);

                Instance.proxy.Send(id, response);

                return response;
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex.Message);

                return null;
            }
        }

        /// <summary>
        /// コールバックメソッドの実装
        /// </summary>
        /// <param name="id"></param>
        /// <param name="message"></param>
        public void GetResponseCallback(uint id, byte[] message)
        {
            Instance.OnCallback?.Invoke(this, new CommunicationEventArgs(id, message));
        }
    }
}
```

本体（Program.cs）
```C#
namespace WCFIPC
{
    class Program
    {
        static void Main(string[] args)
        {
            //1つ目のプロセスでは
            Transfer transfer = new Transfer();
            transfer.Register(new byte[] { 0x12, 0x34, 0x56 });

            //2つ目のプロセスでは
            DataTransfer.DataTransfer dataTransfer = new DataTransfer.DataTransfer();
            dataTransfer.Create();
            var response = dataTransfer.GetResponse(0xFF, new byte[] { 0x78, 0x90 });
        }
    }

    class Transfer
    {
        public DataTransfer.DataTransfer service = new DataTransfer.DataTransfer();

        public void Register(byte[] data)
        {
            this.service.PreStart();
            this.service.Register(data);

            //ここでイベントの購読をしたい
            this.service.instance.OnCallback += Instance_OnCallback;
        }

        private void Instance_OnCallback(object sender, DataTransferWCFService.CommunicationEventArgs args)
        {
            Console.Write(args.Message);
        }

        public void Clear()
        {
            this.service.Clear();
        }
    }
}
```

### 試したこと

・上記実装。
・以下のようにイベントを処理するクラスを実装し、DataTransferServiceでそのオブジェクトを保持した。サービスインターフェースにそのオブジェクトを返すようなメソッドを定義し実装したが、期待通りの動作をしてくれなかった。
```C#
[DataContract]
    public class EventHelper
    {
        public delegate void CallbackEventHandler(object sender, CommunicationEventArgs args);
        [field: DataMember]
        public event CallbackEventHandler OnCallback;

        [OperationContract]
        public void Fire(UInt32 id, byte[] message)
        {
            this.OnCallback?.Invoke(this, new CommunicationEventArgs(id, message));
        }
    }
```

### 補足情報（FW/ツールのバージョンなど）

Visual  Studio 2019
.NET Framework 4.7.2

WCFによるプロセス間のイベント通知

###前提・実現したいこと
WCFサービスを、Windowsサービスにホストさせて、クライアントとTCP通信したいと思い、下記の記事を参考に実装進めております。

[How to: Host WCF in a Windows Service Using TCP](https://msdn.microsoft.com/en-us/library/ff649818.aspx)

例外を発生することなく、正常にTCPでクラサバ通信を行いたいと考えています。

###発生している問題・エラーメッセージ

サービスクライアントインスタンスをオープンするときに、例外が発生してしまいます。

なお、リモート先のマシンはファイヤーウォールを有効にしていて、該当のポート50000番(50000という数字は一例です)について例外設定(送受信ともに許可)しています。
そして、ポイントはファイヤーウォールを無効にすると例外が発生せず、正常にやり取りができていることです。


```ここに言語を入力

 Service1Client client = null;
 string address = "net.tcp://<RemoteMachineName>:50000/MyService";
 client = new Service1Client ("netTcpMyEndpoint", address);
 client.Open(); // <-- ここで例外 'System.Net.Sockets.SocketException'発生

// MyServiceClientはSystem.ServiceModel.ClientBase<TestProject.MyServiceReference.IService1>を継承し、
// TestProject.DebugWcfServiceReference.IService1を実装しているクラスです。
// これは Visual Studioにてサービス参照追加をした際に、自動で生成されるクラスです。
```


下記の例外が発生します。


```
＜メッセージ＞
'System.Net.Sockets.SocketException'
例外メッセージ : ”ホスト <RemoteMachineName> に対する DNS エントリが存在しません。”

＜トレース＞
例外がスローされました: 'System.Net.Sockets.SocketException' (System.dll の中)
例外がスローされました: 'System.ServiceModel.EndpointNotFoundException' (System.ServiceModel.dll の中)
例外がスローされました: 'System.Reflection.TargetInvocationException' (mscorlib.dll の中)
例外がスローされました: 'System.ServiceModel.EndpointNotFoundException' (mscorlib.dll の中)

```

###Windowsサービスクラス
```ここに言語を入力
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceModel;
using System.ServiceProcess;
using System.Text;
using System.Threading.Tasks;
using WcfServiceLibrary1;

namespace WindowsService1
{
	public partial class Service : ServiceBase
	{
		internal static ServiceHost myServiceHost = null;

		public Service()
		{
			InitializeComponent();
		}

		protected override void OnStart(string[] args)
		{
			try
			{
				if (myServiceHost != null)
				{
					myServiceHost.Close();
				}
				myServiceHost = new ServiceHost(typeof(Service1));
				myServiceHost.Open();
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex.Message);
				Console.WriteLine(ex.StackTrace);
				throw;
			}
		}

		protected override void OnStop()
		{
			try
			{
				if (myServiceHost != null)
				{
					myServiceHost.Close();
					myServiceHost = null;
				}
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex.Message);
				throw;
			}
		}
	}
}
```


###ホスト側のApp.Config
```ここに言語を入力
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <startup> 
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
  </startup>
  <appSettings>
    <add key="aspnet:UseTaskFriendlySynchronizationContext" value="true" />
  </appSettings>
  <system.web>
    <compilation debug="true" />
  </system.web>
  
  <system.serviceModel>
    <bindings>
      <netTcpBinding>
        <binding name="netTcpServerBinding" portSharingEnabled="true">
          <security mode="None"/>
        </binding>
      </netTcpBinding>
    </bindings>
    <services>
      <service name="WcfServiceLibrary1.Service1">
        <endpoint address="" binding="netTcpBinding" bindingConfiguration="netTcpServerBinding"
          name="netTcpMyEndpoint" contract="WcfServiceLibrary1.IService1">
          <identity>
            <dns value="localhost" />
          </identity>
        </endpoint>
        <endpoint address="mex" binding="mexTcpBinding" bindingConfiguration=""
          contract="IMetadataExchange" />
        <host>
          <baseAddresses>
            <add baseAddress="net.tcp://localhost:50000/Service1" />
          </baseAddresses>
        </host>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior>
          
          <serviceMetadata httpGetEnabled="False" httpsGetEnabled="False"/>
          
          <serviceDebug includeExceptionDetailInFaults="False" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>

</configuration>

```

###実試したこと
・上記の参考サイトのコードにおけるService1というクラス名が、WCFサービスとWindowsサービスで重複していたので、WindowsサービスのほうをServiceに名前変更しております。
・ファイヤーウォールの例外設定の変更
→ TCP 0-60000 を送受信許可、UDP 53を送受信許可
→ UDP 0-60000 を送受信許可 ← 「サービスクライアントインスタンスをオープンするときに、例外が発生」という問題は解決されました

###補足情報(言語/FW/ツール等のバージョンなど)
C# 6.0
Visual Studio 2015

Windowsサービスを用いたWCFサービスでクライアントとTCP通信する際の例外を回避したい2

■Visual Studio 2010で開発を行っています。
WCFServiceに現在
http://localhost:ポート番号/SampleService/引数/引数/引数
で接続してサービスを呼び出して処理を行うことは可能なのですが、

localhostをIPアドレスに変えて動くようにするにはどうすればよいのかがわからないです。
例：http://255.255.255.255:8080/SampleService/引数/引数/引数
一応サーバ側のコードも載せておきます。

■Global.asax
```C#
<%@ Application Language="C#" %>

<script runat="server">

    void Application_Start(object sender, EventArgs e) 
    {
        // アプリケーションのスタートアップで実行するコードです
        System.Web.Routing.RouteTable.Routes.Add(
            new System.ServiceModel.Activation.ServiceRoute(
                "SampleService", new System.ServiceModel.Activation.WebServiceHostFactory(), typeof(【namespace】.SqmpleService)));
    }
    void Application_End(object sender, EventArgs e) 
    {
        //  アプリケーションのシャットダウンで実行するコードです

    }
・・・・・・・・・・・・
・・・・・・・・・
・・省略・・・
・・・・・・
・・・・  
</script>

```

■web.config
```XML
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.web>
    <compilation debug="true" targetFramework="4.0"/>
  </system.web>

  <system.serviceModel>
    <serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true" />
    
    <services>
      <service name="【namespace】.sampleService" behaviorConfiguration="NewBehavior">
        <endpoint address="" 
                  behaviorConfiguration="ServiceBehavior" 
                  binding="webHttpBinding" 
                  bindingConfiguration="" 
                  contract="【namespace】.ISampleService"/>
      </service>
    </services>
    
    <behaviors>
      <endpointBehaviors>
        <behavior name="ServiceBehavior">
          <webHttp/>
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="NewBehavior">
          <serviceMetadata httpGetEnabled="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
    
    <bindings/>
  </system.serviceModel>
</configuration>
```

■SampleService.svc
```C#
<%@ ServiceHost Service="【namespace】.SampleService"%>
```

申し訳ありません、よろしくお願いいたします。

SampleServiceとISampleServiceは現状localhostからの接続で問題なく動作しているためコードは省略いたします。

【追記】
![イメージ説明](29f9eec3ccfa7fecdfcdd792a2cc7c06.png)

【テンプレート】
![イメージ説明](7a9920a2c7f8093335eaebf38a5154ca.png)

WCFServiceにlocalhost以外(IPアドレス等)で接続したい。

◆Visual Studio 2010
◆.netFrameWork3.5

現在WCFRestServiceを使用してウェブブラウザから引数付きURLを受け付け、その引数を利用してDBを更新、DB処理がうまくいったかどうかの戻り値を返す処理を組んでいます。

が、、、
WCFサービスにhttp://localhost:ポート番号/Service.svc
WCFサービスにhttp://localhost:ポート番号/Service.svc?wsdl

まではネットで調べた通り下記参考先に添付されている画面と同様なものにつなげることができます。
**◆参考 一番下の画面の日本語Ver
**単純な WCF サービスの実装**
**http://aspnet.keicode.com/basic/wcf-simple-service.php**

しかしここから中のサービスを呼ぶことができません。
やりたいことの例を記します。
**【ウェブブラウザからの入力値】**
http://localhost:ポート番号/Service.svc/StatusUpdater/26/yamada/hanako
↓
**【C#】**
UriTemplate="StatusUpdater/{age}/{myoji}/{name}"的なイメージ
↓
**【DataBase】**
yamada hanakoさんの年齢を26に更新
↓
Httpステータスコードを返す(正常終了：200, 異常:500...etc)



果たしてWebブラウザから引数付きのURLを入力しただけでプログラムを走らせることは可能なのでしょうか。。。IDEで実行してないので、まずデバッグができないですよね。
下記を参考にXMLページが返ってくるものをコピペで作り、コード中にdebaug.writeline(...)等書きましたが案の定デバッグしてないのでコンソールに出力されるはずもなく。。。
ましてや引数付URLを入力しただけで裏で処理が走りDBに接続して更新処理を行うなんてできるのでしょうか。

**10 行でズバリ!! リモートからの SharePoint 接続 – REST の使用 (C#)
https://code.msdn.microsoft.com/office/10-SharePoint-REST-C-d76023f9**

完全に詰まっております。

WCFで組んだもののServiceをWebブラウザ上で動かす方法が知りたい

■Visual Studo2010
■.netFramework3.5
_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

■PjStartStatusRestApp(サービス(Iサービスを実装)とIサービスが入っているプロジェクト)
 対象フレームワーク.NET Framework3.5

■restSample(Form1.cs, App.configが配置されている)
 対象フレームワーク.NET Framework3.5

■/pjRestWeb(webサイトかつweb.configが配置されている)
 対象フレームワーク.NET Framework4.0

webサイトと対象フレームワークを合わせても変わりませんでした。
_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
【Form1.cs】
『int result = service.PjStrSttsUpdater(mode.Text, code.Text, すsubcode.Text);』の部分で掲題のエラーが発生します。
フォームのボタンを押したらテキストボックスの文字列を取得して、DBの更新結果をラベルに表示するだけの簡単な処理なので、フォームのボタンをポチポチ連打していたら突然発生しました。
```C#
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using 【namespace】.PjStatusRestApp;
using System.IO;
using System.Runtime.Serialization;
using System.ServiceModel.Activation;
using System.ServiceModel.Web;
using System.Web;
using System.Diagnostics;

namespace 【namespace】.restSample
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            this.label1.Text = "return";
            this.mode.Text = string.Empty;
            this.pjsbno.Text = string.Empty;
            this.pjcode.Text = string.Empty;
            this.labelReslt.Text = string.Empty;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                // 20170313 UIに記述
                var factory = new WebChannelFactory<IPjStartApplication>(new Uri(ConfigUtil.GetSISetting("PjStartApplication.Url")));
                var service = factory.CreateChannel();
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊ココ＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
                int result = service.PjStrSttsUpdater(mode.Text, code.Text, subcode.Text);
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
                string resultMessage = string.Empty;
                if (result == 200) resultMessage = "正常終了";
                else if (result == 400) resultMessage = "パラメータ不正";
                else if (result == 401) resultMessage = "申請ステータスが同じ";

                // 結果の表示
                labelReslt.Text = resultMessage;

                // ここまで
            }
            catch (Exception ex)
            {
                // エラーだった場合はイベントログに内容を出力
                LogWriter.CreateInstance().Write(LogLevel.Error, ex.Message, ex);
            }
        }
    }
}

```

クライアント側(このフォームからテキストを送っています)
App.config
```XML
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <client>
      <endpoint name="PjStartApplicationClientEndpoint" address="http://localhost:55723/【path】/PjStrSttsUpdater" binding="webHttpBinding" contract="【namespace】.PjStartApplication"/>
    </client>
  </system.serviceModel>
</configuration>

```

サーバ側 web.config
```XML
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.web>
    <compilation debug="true" targetFramework="4.0"/>
  </system.web>

  <system.serviceModel>
    <serviceHostingEnvironment aspNetCompatibilityEnabled="true"/>
    <services>
      <service name="【namespace】.PjStartApplication" behaviorConfiguration="NewBehavior">
        <endpoint address="" behaviorConfiguration="ServiceBehavior" binding="webHttpBinding" bindingConfiguration="" contract="【namespace】.IPjStartApplication"/>
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name="ServiceBehavior">
          <webHttp/>
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="NewBehavior">
          <serviceMetadata httpGetEnabled="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <bindings/>
  </system.serviceModel>
</configuration>
```

ブラウザを起動してテストしているわけではないですが、一応ブラウザのキャッシュクリアも試したのですが、ダメでした。

調べても有力な情報を見つけることができず一日詰まっております。。。


**<<2017/03/17 17:09 追記>>**
■Interface
```C#
namespace 【namespace】.PjStatusRestApp
{
    /// <summary>
    /// 状況更新サービス
    /// </summary>
    [ServiceContract]
    public interface IPjStartApplication
    {
        /// <summary>
        /// 状況更新
        /// </summary>
        /// <param name="PjStrSttsUpdater"></param>
        [OperationContract]
        [WebInvoke(
            Method = "POST",
            BodyStyle = WebMessageBodyStyle.Wrapped,
            //RequestFormat = WebMessageFormat.Json,
            //ResponseFormat = WebMessageFormat.Json,
            UriTemplate = "PjStrSttsUpdater")]
        int PjStrSttsUpdater(string mode, string code, string subcode);

    }
}
```

■サービス
```C#
namespace 【namespace】.PjStatusRestApp
{
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Required)]
    public class PjStartApplication : IPjStartApplication
    {
        public int PjStrSttsUpdater(string mode, string code, string subcode)
        {
            {
                #region 更新処理
                using (SqlConnection cnn = "Connection取得処理")
                {
                    string connectionString = string.Empty;
                    connectionString = "DB接続用文字列";
                    cnn.ConnectionString = connectionString;
                    cnn.Open();
                    SqlCommand cmd = new SqlCommand();
                    cmd.Connection = cnn;
                    cmd.CommandType = CommandType.StoredProcedure;

                    cmd.CommandText = "[dbo].[PjStartStatusUpdate]";
                    cmd.Parameters.Clear();
                    cmd.Parameters.Add("@MODE", System.Data.SqlDbType.NVarChar).Value = mode;
                    cmd.Parameters.Add("@CODE", System.Data.SqlDbType.NVarChar).Value = code;
                    cmd.Parameters.Add("@SUBCODE", System.Data.SqlDbType.NVarChar).Value = subcode;

                    // Return
                    cmd.Parameters.Add("ReturnValue", System.Data.SqlDbType.Int);
                    cmd.Parameters["ReturnValue"].Direction = System.Data.ParameterDirection.ReturnValue;

                    // 実行
                    cmd.ExecuteNonQuery();
                    int returnValue = (int)cmd.Parameters["ReturnValue"].Value;
                    // 戻り値の出力
                    // Debug.WriteLine(returnValue);
                    return returnValue;
                #endregion
                }
            }
        }
    }
}

```