Comment communiquer entre service WCF et de l'application hôte?

J'ai réussi à le résoudre à l'aide de l'information provenant de cette question. Dans lequel il a été souligné que les classes de service peuvent également être transmises à l'hôte. Ensuite, il est aussi simple que d'ajouter un écouteur d'événement qui répond aux événements du Service.

OriginalL'auteur Martijn

Il y a un cadre et un tutoriel disponible qui semble gérer ce problème tout à fait bien WPF Hôte de Service sur Codeplex.

EDIT: mis à Jour pour illustrer la technique créé par le WPF Service d'Accueil de modèle.

WPF Service d'Accueil est un modèle pour Visual Studio qui crée un squelette d'application et le client de test. Je vais décrire les éléments pertinents ici.

Voici ce que le squelette de projet ressemble:

ClientServiceHost.cs

using System;
using System.ServiceModel;
namespace WPFServiceHost1.Service
{
public class ClientServiceHost : IDisposable
{
private bool _Initalized;
private ServiceHost _InnerServiceHost;
private MainWindow _MainWindow;
public ClientServiceHost(MainWindow mainWindow)
{
_MainWindow = mainWindow;
InitializeServiceHost();
}
private void InitializeServiceHost()
{
try
{
ClientService clientService = new ClientService(_MainWindow);
_InnerServiceHost = new ServiceHost(clientService);
_InnerServiceHost.Opened += new EventHandler(_InnerServiceHost_Opened);
_InnerServiceHost.Faulted += new EventHandler(_InnerServiceHost_Faulted);
_InnerServiceHost.Open();
}
catch (Exception ex)
{
throw new Exception("Unable to initialize ClientServiceHost", ex);
}
}
void _InnerServiceHost_Opened(object sender, EventArgs e)
{
_Initalized = true;
}
void _InnerServiceHost_Faulted(object sender, EventArgs e)
{
this._InnerServiceHost.Abort();
if (_Initalized)
{
_Initalized = false;
InitializeServiceHost();
}
}
#region IDisposable Members
public void Dispose()
{
try
{
_InnerServiceHost.Opened -= _InnerServiceHost_Opened;
_InnerServiceHost.Faulted -= _InnerServiceHost_Faulted;
_InnerServiceHost.Close();
}
catch
{
try { _InnerServiceHost.Abort(); }
catch { }
}
}
#endregion
}
}

MainWindow.xaml

<Window x:Class="WPFServiceHost1.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="WPFServiceHost1" Height="344" Width="343" Closing="Window_Closing">
<Grid>
<Label Height="28" Margin="12,12,0,0" Name="label1" VerticalAlignment="Top" HorizontalAlignment="Left" Width="119">Messages received:</Label>
<ListBox Margin="21,38,26,21" Name="listBox1" />
</Grid>
</Window>

MainWindow.xaml.cs

using System.Threading;
using WPFServiceHost1.Service;
namespace WPFServiceHost1
{
///<summary>
///Interaction logic for Window1.xaml
///</summary>
public partial class MainWindow : Window
{
public SynchronizationContext _SyncContext = SynchronizationContext.Current;
private ClientServiceHost _ClientServiceHost;
public MainWindow()
{
InitializeComponent();
_ClientServiceHost = new ClientServiceHost(this);
}
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
_ClientServiceHost.Dispose();
}
}
}

IClientService.cs

using System.ServiceModel;
namespace WPFServiceHost1.Service
{
[ServiceContract(Namespace = "urn:WPFServiceHost")]
public interface IClientService
{
[OperationContract]
void ClientNotification(string message);
}
}

ClientService.cs

using System;
using System.ServiceModel;
namespace WPFServiceHost1.Service
{
[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Single, InstanceContextMode = InstanceContextMode.Single, UseSynchronizationContext = false)]
public class ClientService : IClientService
{
private MainWindow _MainWindow;
public ClientService(MainWindow window)
{
_MainWindow = window;
}
#region IClientService Members
public void ClientNotification(string message)
{
try
{
_MainWindow._SyncContext.Send(state =>
{
_MainWindow.listBox1.Items.Add(message);
}, null);
}
catch (Exception ex)
{
throw new FaultException(ex.Message);
}
}
#endregion
}
}

App.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<behaviors>
<serviceBehaviors>
<behavior name="ClientServiceBehavior">
<serviceDebug includeExceptionDetailInFaults="false" />
</behavior>
</serviceBehaviors>
</behaviors>
<services>
<service behaviorConfiguration="ClientServiceBehavior"
name="WPFServiceHost1.Service.ClientService">
<endpoint address="ClientService" binding="basicHttpBinding" contract="WPFServiceHost1.Service.IClientService"/>
<host>
<baseAddresses>
<add baseAddress="http://localhost:8010" />
</baseAddresses>
</host>
</service>
</services>
</system.serviceModel>
</configuration>

Et la TestClient Programme.cs:

using System;
using System.ServiceModel;
using System.Threading;
namespace TestClient
{
class Program
{
static void Main(string[] args)
{
IClientService proxy = null;
try
{
proxy = ChannelFactory<IClientService>.CreateChannel(new BasicHttpBinding(), new EndpointAddress("http://localhost:8010/ClientService"));
Console.WriteLine("Press <Enter> when ClientService is running.");
Console.ReadLine();
Console.WriteLine();
Console.WriteLine("Sending a single message to ClientService");
proxy.ClientNotification("Hello from TestClient");
Console.WriteLine();
Console.Write("Enter a valid number to load test ClientService: ");
string result = Console.ReadLine();
int testCount = Convert.ToInt32(result);
int counter = 0;
object counterLock = new object();
while (true)
{
lock (counterLock)
{
Thread t = new Thread(() => proxy.ClientNotification(string.Format("Load test from TestClient: {0}", ++counter)));
t.Start();
}
if (counter == testCount)
break;
}
Console.ReadLine();
}
finally
{
ICommunicationObject co = proxy as ICommunicationObject;
try
{
co.Close();
}
catch { co.Abort(); }
}
Console.ReadLine();
}
}
}

OriginalL'auteur PIntag