Develop Reference

Notify the Multiple instances of UI using Wcf service

I have a application in WPF, which will allow me to add,delete and edit student. That UI can be opened more than once.
When the UI makes change to the data through the service every other connected client should also be updated with latest changes.
Is that possible to have wcf service do it for me? How can we do it?

Each WPF UI window should establish a connection with the host WCF Service.
The Service is required to be a of singleton type.
Also you'll have to enable session.
Each UI window should start have it's own connection with the service. And must also handle callback method.
The service must track these session and callback method ID.
Now when a UI thread makes change to the data (I am assuming using the WCF service in consideration) the service will have to iterate the session collection and send notification.
There are only two binding that support this netTcp and WSDualHttp.
The Service and Callback service would look as below:
[ServiceContract(SessionMode = SessionMode.Required,
CallbackContract = typeof(INotifyMeDataUpdate))]
public interface IService
{
[OperationContract(IsInitiating=true)]
void Register();
[OperationContract(IsTerminating= true)]
void Unregister();
[OperationContract(IsOneWay=true)]
void Message(string theMessage);
}
public interface INotifyMeDataUpdate
{
[OperationContract(IsOneWay=true)]
void GetUpdateNotification(string updatedData);
}
The implementation would as below:
[ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]
public class Service : IService
{
object _lock = new object();
Dictionary<string, INotifyMeDataUpdate> _UiThreads =
new Dictionary<string, INotifyMeDataUpdate>();
public void Register()
{
string id = OperationContext.Current.SessionId;
if (_UiThreads.ContainsKey(id)) _UiThreads.Remove(id);
_UiThreads.Add(id, OperationContext.Current.GetCallbackChannel<INotifyMeDataUpdate>());
}
public void Unregister()
{
string id = OperationContext.Current.SessionId;
if (_UiThreads.ContainsKey(id)) _UiThreads.Remove(id);
}
public void Message(string theMessage)
{
foreach (var key in _UiThreads.Keys)
{
INotifyMeDataUpdate registeredClient = _UiThreads[key];
registeredClient.GetUpdateNotification(theMessage);
}
}
}

WCF service hosted Windows Service not saving state between calls

I am trying to make a simple windows service that maintains a queue of integers and accepts new integers from other applications via a WCF call. My current implementation seems to maintain separate queues for each application which communicates with it, which is not what I want.
I started by following the instructions at from Microsoft on How to: Host a WCF Service in a Managed Windows Service.
My WindowsService class looks like this:
public class MyWindowsService : ServiceBase{
public ServiceHost serviceHost = null;
public MyWindowsService(){
ServiceName = "AdHocReportService";
}
public static void Main(){
ServiceBase.Run(new MyWindowsService());
}
protected override void OnStart(string[] args){
if (serviceHost != null)
serviceHost.Close();
serviceHost = new ServiceHost(typeof(MyService));
serviceHost.Open();
}
protected override void OnStop(){
if (serviceHost != null){
serviceHost.Close();
serviceHost = null;
}
}
}
In my Service class I have a queue and an Add method. The add method returns the count of items in the queue after the add. The code looks like this:
public class MyService : IMyService
{
private Queue<int> myQueue= new Queue<int>();
public int Add(int reportId)
{
myQueue.Enqueue(reportId);
return myQueue.Count;
}
}
Lastly, I test my service using the following code in a ConsoleApp:
MyServiceClient client = new MyServiceClient();
int count = client.Add(10);
Console.WriteLine(count); //prints 1
count = client.Add(25);
Console.WriteLine(count); //prints 2
Console.ReadLine();
I would expect this to print 1 and 2 the first time my test is run, then 3 and 4 the second time, and then 5 and 6 the third and so on. However, it simply returns 1 and 2 each time, as if the Console App is instantiating the object itself and not operating on the object inside the Windows Service. What am I not understanding?

I think you want a singleton WCF service. See here.
By default, the instance mode for a WCF service is per-call. So an instance of your service is being created by the host for each call you make.
Note: When using a singleton service, your operations need to be thread safe. So I suggest switching from a Queue to a ConcurrentQueue, so you can handle multiple concurrent clients.
Alternative: Use a MSMQ binding. This will ensure you that all of your incoming messages are queued out of process, therefore persisted between restarts too.

WCF Timer based service not calling client back

I want to make a WCF timer service where clients can register in order to get called back from the service after a certain time has passed. The problem is that the client doesn't get called back. No Exception is thrown.
The callback interface is:
[ServiceContract]
public interface ITimerCallbackTarget
{
[OperationContract(IsOneWay = true)]
void OnTimeElapsed(int someInfo);
}
The service looks like:
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
ConcurrencyMode = ConcurrencyMode.Single)]
public class TimerService : ITimerService
private readonly Timer _timer = new Timer(2000); //System.Timers.Timer
public void Subscribe()
{
ITimerCallbackTarget listener =
OperationContext.Current.GetCallbackChannel<ITimerCallbackTarget>();
_timer.Elapsed += (p1, p2) =>
{
listener.OnTimeElapsed(999);
};
_timer.Start();
}
The callback method used by the client is:
private class TimerCallbackTarget : ITimerCallbackTarget
{
public void OnTimeElapsed(int someInfo)
{
Console.WriteLine(someInfo);
}
}
The client registers like this:
private static void TestTimerService()
{
InstanceContext callbackInstance = new InstanceContext(new TimerCallbackTarget());
using (DuplexChannelFactory<ITimerService> dcf =
new DuplexChannelFactory<ITimerService>(callbackInstance,
"TimerService_SecureTcpEndpoint"))
{
ITimerService timerProxy = dcf.CreateChannel();
timerProxy.Subscribe();
}
}
If I use a different thread at the subscribe method without Timer it works:
ThreadPool.QueueUserWorkItem(p =>
{
listener.OnTimeElapsed(999);
});
It even works with the Timer (for three seconds) if I put a Thread.Sleep(3000) at the end of the subscribe method so my guess is that maybe the channel to the callback-object gets closed after the subscribe method is finished. Using a class-scope variable for the callback object retrieved with OperationContext.Current.GetCallbackChannel(); instead of the method-scope variable didn't help.
Previously i tried creating new Threads in the elapsed event handler of the Timer of the timer service to make it faster. An ObjectDisposedException was thrown with the message: "Cannot access a disposed object. Object name: 'System.ServiceModel.Channels.ServiceChannel". I then tried to simplify my service and found that even using only the Timer causes problems as described but I guess the exception indicates that somewhere the connection to the client's callback object is lost. It's strange that there is no excepiton if I don't make new threads in the Timer thread. The callback method just isn't called.

In a duplex binding the lifetime of the two channels are linked. If the channel to the TimerService closes, then the callback channel to the CallbackTarget closes too. If you try to use a channel that was closed, you can get an ObjectDisposedExcpetion. In your case this is bad, because you don't want to keep the Subscribe() channel open just to receive OnTimeElasped() calls... and I'm assuming you want to subscribe for an infinitely long time.
A duplex channel is trying to make your life easier, but doesn't fit your needs. Behind the scenes a duplex channel is actually creating a second WCF service host for the CallbackTarget. If you create the client's service host manually to receive callbacks, then you can manage its lifetime independently of the Subscribe() channel.
Below is a fully functional command line program that demonstrates the idea:
Create a TimerService
Create a TimerClient to receive notificatioins
Pass the TimerClient's endpoint address to the TimerService as a part of the subscribe call
TimerService uses the address it got from Subscribe() to send notifications to the TimerClient.
Note that no channel is left open longer than needed to make a single call.
Standard disclaimer: This is intended to show how to create "duplex like" behavior. There's a lack of error handling and other short cuts.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.Timers;
using System.ServiceModel.Description;
namespace WcfConsoleApplication
{
[ServiceContract]
public interface ITimerCallbackTarget
{
[OperationContract(IsOneWay = true)]
void OnTimeElapsed(int someInfo);
}
[ServiceContract]
public interface ITimerService
{
[OperationContract(IsOneWay = true)]
void Subscribe(string address);
}
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
ConcurrencyMode = ConcurrencyMode.Single)]
public class TimerService : ITimerService
{
private readonly Timer _timer = new Timer(2000);
private ChannelFactory<ITimerCallbackTarget> _channelFac;
private int _dataToSend = 99;
public void Subscribe(string address)
{
// note: You can also load a configured endpoint by name from app.config here,
// and still change the address at runtime in code.
_channelFac = new ChannelFactory<ITimerCallbackTarget>(new BasicHttpBinding(), address);
_timer.Elapsed += (p1, p2) =>
{
ITimerCallbackTarget callback = _channelFac.CreateChannel();
callback.OnTimeElapsed(_dataToSend++);
((ICommunicationObject)callback).Close();
// By not keeping the channel open any longer than needed to make a single call
// there's no risk of timeouts, disposed objects, etc.
// Caching the channel factory is not required, but gives a measurable performance gain.
};
_timer.Start();
}
}
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
ConcurrencyMode = ConcurrencyMode.Single)]
public class TimerClient : ITimerCallbackTarget
{
public void OnTimeElapsed(int someInfo)
{
Console.WriteLine("Got Info: " + someInfo);
}
}
class Program
{
static void Main(string[] args)
{
ServiceHost hostTimerService = new ServiceHost(typeof(TimerService), new Uri("http://localhost:8080/TimerService"));
ServiceHost hostTimerClient = new ServiceHost(typeof(TimerClient), new Uri("http://localhost:8080/TimerClient"));
ChannelFactory<ITimerService> proxyFactory = null;
try
{
// start the services
hostTimerService.Open();
hostTimerClient.Open();
// subscribe to ITimerService
proxyFactory = new ChannelFactory<ITimerService>(new BasicHttpBinding(), "http://localhost:8080/TimerService");
ITimerService timerService = proxyFactory.CreateChannel();
timerService.Subscribe("http://localhost:8080/TimerClient");
((ICommunicationObject)timerService).Close();
// wait for call backs...
Console.WriteLine("Wait for Elapsed updates. Press enter to exit.");
Console.ReadLine();
}
finally
{
hostTimerService.Close();
hostTimerClient.Close();
proxyFactory.Close();
}
}
}
}

WCF Per Instance

I have a WCF service code like this:
[ServiceContract]
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
ConcurrencyMode = ConcurrencyMode.Multiple)]
public class SomeService
{
public string Password { [OperationContract] get; [OperationContract] set; }
public void CheckPassword()
{
if (Password == null || Password != "password")
throw new FaultException("Invalid Password");
}
[OperationContract]
public string SomeMethod()
{
this.CheckPassword();
return "Some Data";
}
}
And the client windows application consumes it like this:
public class ClientClass
{
public ClientClass()
{
STASomeService.Value.SomeMethod();
}
}
public class ClientClass
{
public ClientClass()
{
STASomeService.Value.set_Password("password");
}
}
How can I reset the value of SomeService.Password whenever the SomeService class is instantiated? I do not want an attacker to access my service methods, but when the actual client set the password, the passwords stays in the SomeService.Password property in every service call. But I want to retain the Password value per instance because the client needs that.
My code is in C#, framework 4, build in VS2010 Pro.
Please help. Thanks in advance.

You shouldn't have to reset the value of SomeService.Password because it isn't static. Are you seeing something to the contrary?
Since you're using InstanceContextMode.Single (which I originally overlooked), your best recourse my be to mock the behavior of having individual instances in your network bound singleton. The only way I can think of to facilitate this is to have a proxy service class that matches your service's contracts and delegates its calls to custom instances based on specific criteria (which would define the session). It would be cumbersome to maintain this way and adds a unnecessary level of abstraction, but (in my head at least) it should work

WCF swap service interfaces

I'm new with WCF and still experimenting.
I have two ServiceContract like this:
[ServiceContract]
public interface IFirst
{
[OperationContract(IsOneWay = true)]
void First();
}
[ServiceContract]
public interface ISecond
{
[OperationContract(IsOneWay = true)]
void Second();
}
On server side Client class implementing those interfaces:
public class Client : IFirst, ISecond
{
static int count = 0;
int id;
public Client()
{
count++;
id = count;
Console.WriteLine("{0} client created.", id);
}
public void First()
{
Console.WriteLine("First from: " + id.ToString());
}
public void Second()
{
Console.WriteLine("Second: " + id.ToString());
}
}
and host:
ServiceHost host = new ServiceHost(typeof(Client), new Uri("net.tcp://localhost:8000"));
NetTcpBinding binding = new NetTcpBinding();
host.AddServiceEndpoint(typeof(IFirst), binding, "");
host.AddServiceEndpoint(typeof(ISecond), binding, "");
host.Open();
On client side:
ChannelFactory<IFirst> firstFactory = new ChannelFactory<IFirst>(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8000"));
IFirst iFirst = firstFactory.CreateChannel();
iFirst.First();
ChannelFactory<ISecond> secondFactory = new ChannelFactory<ISecond>(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8000"));
ISecond iSecond = secondFactory.CreateChannel();
iSecond.First();
This works fine. It calls First and then Second method but for each call creates new instance of Client class. It is obvious because when client creates channel, service creates new instance of Client object. What I wish to achieve is call Second after First but for the same instance of Client. Is it even possible? I know I can put this two methods in one service but it is not what I wish for.

As per my understanding you want to call the two methods while creating only one client.
In WCF you can control Instancing by setting InstanceContextMode property of Service Behavior Attribute. There are three possible values
-PerCall
-PerSession
-Single
You can use PerSession as it keeps the object active for the next calls from client.
The object is released when the session ends
You can decorate your class
[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]
Hope this helps.

At first I was a little confused by you calling your Service Implementation "Client" :P
But anyway, by default, WCF uses InstanceContextMode.PerCall, which means that it will instantiate a new Service implementation instance for every request into the Service.
If you want for subsequent service calls to be handled within the same service instance, you will have to use either PerSession or Single InstanceContextModes.
http://msdn.microsoft.com/en-us/library/ms731193.aspx summarises Sessions, Instances and Concurrency in WCF pretty well.