A Windows Communication Foundation (WCF) client and service share the following service contract interface:

[ServiceContract]
public interface IContosoService
{
[OperationContract]
void SavePerson(Person person);
}

They also use the following binding:
NetTcpBinding binding = new NetTcpBinding() { TransactionFlow = true };

The client calls the service with the following code:
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required))
{
IContosoService client = factory.CreateChannel();
client.SavePerson(person);
Console.WriteLine(Transaction.Current.TransactionInformation.DistributedIdentifier);
ts.Complete();
}

The service has the following implementation for SavePerson:

public void IContosoService.SavePerson(Person person)
{
person.Save();
Console.WriteLine(Transaction.Current.TransactionInformation.DistributedIdentifier);
}

The distributed identifiers do not match on the client and the server.
You need to ensure that the client and server enlist in the same distributed transaction. What should you do?

A Windows Communication Foundation (WCF) solution uses the following contract:

[ServiceContract(SessionMode=SessionMode.Allowed)]
public interface IMyService
{
[OperationContract(IsTerminating=false)]
void Initialize();
[OperationContract(IsInitiating=false)]
void DoSomething();
[OperationContract(IsTerminating=true)]
void Terminate();
}

You need to change this interface so that:
* lnitialize is allowed to be called at any time before Terminate is called.
* DoSomething is allowed to be called only after Initialize is called, and not allowed to be called after Terminate is called.
* Terminate will be allowed to be called only after Initalize is called.

Which two actions should you perform? (Each correct answer presents part of the sdution. Choose two)

A Windows Communication Foundation (WCF) solution provides a session-based counter.
The service is self-hosted. The hosting code is as follows:

ServiceHost host = new ServiceHost(typeof(CounterService));
NetTcpBinding binding1 = new NetTcpBinding(SecurityMode.None);
host.AddServiceEndpoint(“MyApplication.ICounterService”, binding1, “net.tcp://localhost:23456”);
host.Open();

This service is currently exposed over TCP, but needs to be exposed to external clients over HTTP.
Therefore, a new service endpoint is created with the following code:

host.AddServiceEndpoint(“MyApplication.ICounterService”, binding2, “http://localhost:12345”);

You need to complete the implementation and ensure that the session-based counter will perform over HTTP as it does over TCP.
What should you do?

A Windows Communication Foundation (WCF) solution uses the following contract to share a message across its clients.
(Line numbers are included for reference only.)

01 [ServiceContract]
02 public interface ITeamMessageService
03 {
04 [OperationContract]
05 string GetMessage();
07 [OperationContract]
08 void PutMessage(string message);
09 }

The code for the service class is as follows:

10 public class TeamMessageService: ITeamMessageService
11 {
12 Guid key = Guid.NewGuid();
13 string message = “Today’s Message”;
14 public string GetMessage()
15 {
16 return stringFormat(“Message:{0} Key:{1}”,
17 message, key);
18 }
19 public void PutMessage(string message)
20 {
21 this.message = message;
22 }
23 }

The service is self-hosted. The hosting code is as follows:

24 ServiceHost host = new ServiceHost(typeof(TeamMessageService));
25 BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.None):
26 host.AddServiceEndpoint(MyApplication.ITeamMessageService, binding, “http://localhost:12345”);
27 host.Open();

You need to ensure that all clients calling GetMessage will retrieve the same string, even if the message is updated by clients calling PutMessage.
What should you do

You have a secured Windows Communication Foundation (WCF) service.
You need to track unsuccessful attempts to access the service. What should you do?