Windows Communication Foundation (WCF) is the basis for building connected systems on the Windows platform using .NET, making it possible to build secure, reliable, and transacted services that can be composed into service-oriented applications. This course explores several key areas of WCF service architecture, including serialization, service contracts, faults and exceptions, security and reliability.
Aaron is a co-founder of Pluralsight where he serves as the Chief Executive Officer. Aaron has authored numerous Pluralsight courses in the areas of Azure (cloud computing), WCF, Web services, XML and BizTalk Server. Over the years, Aaron has written numerous articles, whitepapers, and books and he's a contributing editor with MSDN Magazine where he authored The XML Files and Service Station columns for years. Aaron frequently speaks at industry events including TechEd, PDC, and VSLive!
Service Contracts Hi. This is Aaron Skonnard with Pluralsight and I'll be presenting this module on WCF Service Contracts. In this particular piece, we're going to be exploring the details around how you can map methods in your WCF services to the messages that are actually transmitted on the wire. We assume at this point that you have some good understanding of the WCF programming model basically how to write simple clients and services and are ready to dive into the details around the service contract architecture and implementation details. We'll start this module by reviewing some of the architecture around service contracts just to make sure we have a complete understanding of how they're meant to be used. And then we'll dive into the details around how service contracts are used. We'll discuss the dispatching procedures that are used by the WCF runtime, how to import and export service contracts and how to control all the mapping details between your methods and those messages by looking at the service contract attributes and the properties that they expose. Then we'll dig in to how to design different types of operations in your service contracts. We'll discuss briefly request for apply operations which are the default in WCF and then we'll look at how to do both one-way and duplex operations. And then finally, we'll spend a few minutes looking at some more advance service contract topics including message contracts and generic contract.
Faults and Exceptions Hi! This is Aaron Skonnard with Pluralsight and I'll be presenting this module to you on Faults and Exceptions in Windows Communication Foundation. At this point we assume that you have good knowledge of the WCF programming model both on the client side and the service side. And now you are ready to explore the built in functionality around Exceptions and how to translate those Exceptions into SOAP faults that can be handled by your clients. In this module we'll start by reviewing the concepts of exceptions and faults and how you can move between those two different representations. We'll discuss how to deal with undeclared exceptions that may occur within your service implementation. And how you can control exactly what the client will be able to see in those cases. Then we'll discuss how to throw explicit SOAP faults within Windows Communication Foundation through the FaultException and FaultException of T classes. We'll discuss both how to throw those faults and how to catch those faults on the client side. We'll also discuss how you can advertise those faults in your service contracts using the fault contract attribute. Then we'll show you how to implement a global exception handling component by implementing the IErrorHandler interface. We'll show you how to implement a behavior that you can use to inject that custom error handling component into your service implementations. And then finally we'll discuss the various techniques around how you handle exceptions on the client side. For example the order in which you need to handle these different types of SOAP faults that may flow down from your service implementations.
Security Hi. This is Aaron Skonnard with Pluralsight. I'll be presenting this module to you on Security in Windows Communication Foundation. In this module, we assume that you have a solid understanding of the WCF Programing Model and are ready to dive into the details of the various security choices that it offers. In this module, we'll start by discussing how WCF provides for three important security features often known as the CIA of security; confidentiality, integrity, and authentication. And you'll see that security is on by default in almost all of WCF bindings. But we'll also show you how you can configure different aspects of WCF security through some key properties. We'll show you how to configure transport versus Message-Based security using the security mode property. And then we'll show you how to configure authentication details via the client credential type property. And then we'll turn our attention towards authorization and we'll show you several different techniques for implementing authorization logic within your WCF services. We'll look at impersonation, your own custom role-based access control implementation, and a more declarative service authorization behavior technique.
Reliability Hello everyone. This is Aaron Skonnard with Pluralsight and I'll be presenting this module to you on reliability in Windows Communication Foundation. We assume in this module that you have a solid understanding of the WCF programming model and you're ready to explore the various options that WCF provides for increasing the reliability of your connected systems. We'll begin this module by exploring several different areas in which you can increase the reliability of connected systems architectures. We'll discuss reliable messaging techniques specifically those that are provided by the WS-Reliable Messaging Protocol, and then we'll discuss queued messaging, in other words building messaging scenarios on top of MSMQ using WCF. And then we'll discuss the role of transactions in reliability specifically how we can leverage ACID transactions and how we can use those types of transactions and flow them across service boundaries. And then we'll discuss long running transactions or sagas, and how you can use compensating transaction architectures to increase the overall reliability of your system.