MS .Net Framework 70-513

The correct answer is to add the WebInvoke(UriTemplate="/Items/{id}", Method="DELETE") attribute to the operation. This is because the WebInvoke attribute is used to specify the HTTP verb and URI template for a RESTful operation in WCF. In this case, the attribute is set to Method="DELETE" to indicate that the operation should be called when the client uses the HTTP DELETE method. The UriTemplate="/Items/{id}" specifies the URI template for the operation, where {id} is a placeholder for the ID parameter that will be passed in the URL.

MTOM (Message Transmission Optimization Mechanism) message encoding should be used to configure the service to support the given requirements. MTOM encoding allows the service to attach the XML document as is without using escape characters or base64 encoding, thus minimizing the transmission size. Additionally, MTOM encoding is interoperable with systems that use SOAP but are not built on the .NET platform. This makes it the suitable choice for the given scenario.

not-available-via-ai

The correct order for configuring the binding stack is transactionFlow, binaryMessageEncoding, windowsStreamSecurity, and tcpTransport. This order ensures that transactions are supported, messages are encoded using a binary encoding, messages are secured using Windows stream-based security, and messages are sent over TCP.

To complete the deployment of the WCF service to IIS, you need to create a .svc file and add a @ServiceHost directive to this file. This .svc file should be copied to the root of the application directory. The .svc file acts as the entry point for the WCF service in IIS, and the @ServiceHost directive specifies the service class that will be hosted. By copying the .svc file to the root of the application directory, IIS will be able to locate and host the WCF service properly.

To meet the requirements, the CodeName property needs to be sent in clear text and the service needs to be able to verify that the value was not changed. Therefore, the CodeName property should have a MessageBodyMember attribute with a ProtectionLevel set to Sign. This will ensure that the property is sent in clear text and that the service can verify its integrity.

Similarly, the SecretHandshake property needs to be sent in an encrypted format and readable by the service. Therefore, it should have a MessageBodyMember attribute with a ProtectionLevel set to EncryptAndSign. This will ensure that the property is encrypted and can be decrypted by the service.

Setting the lsRequired property of each data member to true ensures that the data contract requires all data members to be present when a serialized instance is deserialized. If any data member is missing, a SerializationException will be thrown. This is the correct approach to achieve the desired behavior.

Adding the [OperationBehavior(TransactionScopeRequired=true)] attribute to the ConfirmCreditCard method will allow the code to participate automatically in existing transactions. If there is no existing transaction, a new transaction will be created automatically. This attribute ensures that the method is executed within a transaction scope, providing transactional support for the method.

To debug and fix the communication issue, the correct approach is to enable messageLogging in the System.ServiceModel diagnostics element configuration. This allows the service to log the messages received from the client. Additionally, a listener needs to be configured for the System.ServiceModel.MessageLogging trace source to capture and analyze the logged messages.

In order to ensure that the client accepts responses of up to 5 MB in size, the configuration file needs to be modified by changing the value of the maxReceivedMessageSize attribute to 5242880. This attribute specifies the maximum size of the received message that the client can handle. By setting it to 5242880, the client will be able to accept responses of up to 5 MB in size.

The correct answer is [ServiceContract(Name="Arithmetic")]
public class Calculator
{
[OperationContract(Name="Sum")]
public int Add(int x, int y)
{}
}

This is the correct code segment because it uses the ServiceContract attribute with the Name property set to "Arithmetic" to specify the name of the service. It also uses the OperationContract attribute with the Name property set to "Sum" to specify the name of the operation. This allows the class and method to be exposed as a service named "Arithmetic" with an operation named "Sum".

not-available-via-ai

The correct answer is [OperationContract] void PostData(Message data) because the Message class in WCF represents the entire SOAP message, including the headers and body. By using this code segment, the PostData method can receive any SOAP message, regardless of its content or structure.

The correct answer is to add a PrincipalPermission attribute to the method and set the Roles property to Manager. This will ensure that only users with the Manager role can call the ApproveOrder method. The PrincipalPermission attribute allows you to specify the roles that are required to access the method, in this case, only users with the Manager role.

The correct answer is to set the messageAuthenticationAuditLevel attribute of the serviceSecurityAudit behavior to Failure. This will enable auditing of authentication failures for the WCF service. By setting the messageAuthenticationAuditLevel to Failure, the service will track and log unsuccessful attempts to access the service, providing valuable information for security analysis and troubleshooting.

By applying the [ServiceBehavior(IncludeExceptionDetailInFaults = true)] attribute to the ContosoService class, any unhandled exceptions thrown by the service will be sent as a fault message to the clients. This attribute allows the service to include exception details in the fault message, including the stack trace. This ensures that clients receive information about the exceptions that occurred on the server, helping them to diagnose and handle any errors effectively.

Setting the ProtectionLevel property in line 01 to EncryptAndSign will ensure that all calls to Operation1 and Operation2 from the client are encrypted and signed. This means that the data being transmitted will be encrypted to protect its confidentiality and integrity, and it will also be signed to ensure that it has not been tampered with during transmission. This is the appropriate action to take in order to meet the requirement of encrypting and signing all calls to these operations.

The correct answer is IExtensibleDataObject. By implementing the IExtensibleDataObject interface, the data contract class allows new data members to be added without breaking existing functionality. This interface provides a mechanism for adding extra data to the serialized message without requiring a strict schema validation. It ensures forward compatibility by allowing the addition of new data members without affecting existing contracts.

To expose the existing WCF service contract over both HTTP and TCP, you need to add an endpoint configured with a netTcpBinding. This allows the service to accept requests over TCP in addition to HTTP. By adding this endpoint, clients can now communicate with the service using either protocol.

Setting the value of ServiceSecurityContext.Current.WindowsIdentity.ImpersonationLevel to TokenImpersonationLevel.Delegation allows the service to access out-of-process resources on behalf of the originating caller. Delegation impersonation level allows the service to delegate the caller's identity to another resource, such as a database or file server, allowing the service to access those resources using the caller's identity. This ensures that the service can access the necessary resources while still maintaining the security and permissions of the originating caller.

The correct answer is [ServiceBehavior(InstanceContextMode = lnstanceContextMode.PerSession, ConcurrencyMode = ConcurrencyMode.Multiple)]. This attribute configuration ensures that each client request will have its own session, allowing for stateful conversations. Additionally, the ConcurrencyMode is set to Multiple, which means that multiple client requests can be processed simultaneously.

To ensure that the stack trace details of the exception are not included in the error information sent to the client, you need to add the [FaultContract(typeof(FaultException))] attribute to the service contract at line 05. This attribute specifies that the service can throw a FaultException, which is a fault message that can be sent to the client. Additionally, you should replace line 14 with the following line: throw new FaultException(anOrder, "Divide by zero exception");. This will throw a FaultException with a custom error message instead of the original exception, preventing the stack trace details from being exposed to the client.

The BasicHttpContextBinding should be used in this scenario to ensure compatibility with ASP.NET session state. This binding allows the WCF service to access the HttpContext of the ASP.NET application, which includes the session state. The NetTcpContextBinding and NetTcpBinding do not provide access to the HttpContext, while the NetMsmqBinding is used for communication with Message Queuing (MSMQ) and does not support session state.

To ensure that the Web service can accept messages larger than 64 KB without generating errors, the value of maxReceivedMessageSize on the endpoint binding should be increased. This setting determines the maximum size of the messages that the service can receive. By increasing this value, the Web service will be able to handle larger messages without encountering any errors.

The correct answer is to insert the [OperationBehavior(TransactonScopeRequired=true, TransactionAutoComplete=false)] attribute to OperationOne on ContosoService and insert the [OperationBehavior(TransactionScopeRequired=true, TransactionAutoComplete=true)] attribute to OperationTwo on ContosoService. These attributes specify that both operations require a transaction scope and that OperationOne should not automatically complete the transaction while OperationTwo should. This ensures that both operations execute under the same transaction context when invoked in the same session.

The correct line of code to insert at line 04 is "host = new ServiceHost(typeof(DataAccessService));". This is because the ServiceHost constructor requires the type of the service to be hosted, which in this case is DataAccessService.

The correct answer is to update the service contract to have SessionMode as Required and add the behavior to the service implementation with InstanceContextMode as PerSession. This configuration ensures that both TxOp1 and TxOp2 are invoked under the same client session, allowing them to run under the same transaction context.

The correct answer is AnnouncementService. This class is the most suitable for implementing a client that logs notifications from a Windows Communication Foundation (WCF) service. The name "AnnouncementService" suggests that it is specifically designed for handling notifications and announcements. As a result, it would be the most appropriate choice for logging the notifications sent by the WCF service when it is started and stopped.

The correct answer is to change line 03 to typeof(IDuplexSessionRouter). This is because the router needs to handle both one-way and request-reply operations, and the IDuplexSessionRouter interface supports both types of operations. By changing the line to typeof(IDuplexSessionRouter), the router will be able to handle both types of operations successfully.

Creating a proxy derived from DuplexClientBase on the client allows the client application to interact with the WCF service. DuplexClientBase provides support for duplex communication, which means that both the client and the service can send messages to each other. This is necessary when using a callback contract, as the service needs to be able to send messages back to the client. By creating a proxy derived from DuplexClientBase, the client application can establish a connection with the service and receive callback messages.

The correct answer is to catch and handle TimeoutFaultException and catch FaultException and create a new channel. This is because the implementation of the SearchMessages method throws TimeoutFaultException exceptions for database timeouts and throws an Exception for any other issue. These exceptions are received on the client side as generic FaultException exceptions. Therefore, it is necessary to catch and handle TimeoutFaultException separately and create a new channel if a FaultException is caught.

The correct answer is "serviceDebug". By configuring and applying the "serviceDebug" behavior to the service, the application will transmit the exceptions raised by the database to the client calling the service. This behavior allows for debugging and troubleshooting purposes by providing detailed information about any exceptions that occur during the service operation.

The correct answer is [OperationContract]
[WebInvoke(Method="POST")]
string Operation1(string s).

This code segment uses the [WebInvoke] attribute with the Method property set to "POST", which ensures that the Operation1 method responds to HTTP POST requests.

The correct answer is "ChannelFactory factory = new ChannelFactory("netPipe");". This is because the endpoint in the client configuration file has the name attribute set to "netPipe", so when creating the channel factory, we need to pass the same name to match the endpoint.

To route incoming messages to the appropriate services, two message filters should be added to the router. The first message filter should have a priority of 100 and forward messages that total between $0 and $500 to Service A. This ensures that messages within the specified range are directed to the correct service. The second message filter should have a priority of 0 and forward all messages to Service B. This ensures that any messages not falling within the $0 to $500 range are directed to Service B.

The correct answer is net.msmq://localhost/system$DeadLetter. This is because the failed-delivery queue in MSMQ is known as the Dead Letter queue, and it is located under the system queue path. Therefore, the URI should specify the system$DeadLetter queue to read messages from the failed-delivery queue.

The correct answer is to add the line of code "client.Endpoint.Behaviors.Add(new ClientViaBehavior(new Uri("net.tcp://www.contoso.com/IMyService")));". This code adds a behavior to the client's endpoint, specifically the ClientViaBehavior, which allows the client to specify a different URI for sending messages. In this case, it sets the URI to "net.tcp://www.contoso.com/IMyService", which matches the URI of the server's net.tcp endpoint. This ensures that the client can communicate with the server using the correct URI.

The correct code segment to deserialize the response into a strongly typed object representing the return value of the method is:

DataContractSerializer s = new DataContractSerializer(typeof(Item));
Item item = s.ReadObject(response.GetResponseStream()) as Item;

This code uses the DataContractSerializer to deserialize the response stream into an object of type Item. The ReadObject method is used to read and deserialize the stream, and the result is cast to the Item type.

The correct answer is to insert the following two lines of code between lines 02 and 03:

Console.WriteLine(item.Content.Type);
Console.WriteLine(((TextSyndicationContent)item.Content).Text);

These lines of code will display the content type and body of each syndication item to the console.

Adding the [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)] attribute to the TeamMessageService class ensures that only one instance of the service class is created and shared among all clients. This means that all clients calling GetMessage will retrieve the same string, even if the message is updated by clients calling PutMessage.

The correct answer is to use the CreateBufferedCopy method of the Message class to load the messages into memory and to use the CreateMessage method of the MessageBuffer class to make a copy of the messages.

By using the CreateBufferedCopy method, the messages are loaded into memory, allowing them to be processed multiple times within the method. This method creates a buffered copy of the original message, which can be accessed and processed multiple times without affecting the original message.

Additionally, by using the CreateMessage method of the MessageBuffer class, a copy of the messages can be made. This allows for further processing or manipulation of the messages without modifying the original message.

The correct answer is ChannelFactory. In WCF, a ChannelFactory is used to create a channel that can be used to communicate with a service. It provides methods to create a channel of a specified type and configure the channel's behavior. The ChannelFactory class is typically used on the client side to create a proxy that can consume the service.

The first possible way to achieve the goal is to change line 25 to the code segment "DuplexChannelFactory factory = new DuplexChannelFactory(callbackContext, binding, address);". This ensures that the callback context is passed to the DuplexChannelFactory, allowing the service callback to be processed by the instance of NameService.

The second possible way is to change line 26 to the code segment "IGreetingService greetingServicefactory = CreateChannel(callbackContext);". This creates the channel using the CreateChannel method with the callback context parameter, ensuring that the service callback is processed by the instance of NameService.

not-available-via-ai

The correct code segment to use is $get(String.format("/Catalogsvc/Catalog/Items/{0}", itemId), null, function (data) {
...
}, "json"). This is because the RetrieveItemDescription method in the service interface is decorated with the [WebGet] attribute, which specifies a UriTemplate of "/Catalog/Items/{id}". This means that the URL to retrieve the item description should be in the format "/Catalogsvc/Catalog/Items/{id}", where {id} is the id of the item. The code segment correctly uses String.format to substitute the {0} placeholder with the value of the itemId variable. The "json" parameter in the code segment specifies that the response format should be JSON.

To enable message logging and include all security information such as tokens and nonces in logged messages, you need to add the XML segment mentioned in the machine configuration file to the system.serviceModel configuration section. This will configure the WCF client application to log the messages and include the necessary security information. Additionally, there is no need to generate the ContosoService class using the Add Service Reference wizard or add the SoapProcessingBehavior code segment. The IogKnownPii attribute and XML segment in the application configuration file are not relevant for this requirement.

The correct answer is to generate a proxy class with asynchronous methods and use it for the new clients. By generating a proxy class with asynchronous methods, new clients can issue non-blocking calls to get the data. This means that the new clients will not have to wait for the GetData call to complete before continuing with their operations. This solution allows for concurrent execution of multiple operations, improving the overall performance and responsiveness of the system without affecting the existing clients.

Changing the service behavior to [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single, ConcurrencyMode=ConcurrencyMode.Multiple)] allows multiple clients to access the service simultaneously, increasing the rate at which clients get the required response. This is because the service instance is shared among multiple clients, allowing them to execute concurrently. Similarly, changing the service behavior to [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)] creates a new service instance for each client request, allowing multiple clients to be served simultaneously and improving the response rate.

To configure the WCF service to execute under the Windows logged-on identity of the calling application, you need to add a ServiceAuthorization behavior to the service configuration and set ImpersonateCallerForAllOperations to true. This will allow the service to impersonate the caller's identity for all operations, ensuring that the service executes with the appropriate permissions and complies with government regulations of auditing and accountability.

The correct answer is to add the following attribute to the SavePerson operation on lContosoService: [TransactionFlow(TransactionFlowOption.Allowed)]. This allows the client and server to participate in the same distributed transaction. Additionally, the implementation of SavePerson should have the attribute [OperationBehavior(TransactionScope.Required = true)] to ensure the transaction is required for the operation.