This course provides an introduction to WCF. It then covers how to use WCF for the enterprise and for the Web. It covers two aspects all architects and .NET developers need to understand: versioning and serialization.
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!
Introducing WCF Hi, this is Aaron Skonnard with Pluralsight. I'll be presenting this module on Introducing WCF, or Windows Communication Foundation. As far as prerequisites are concerned, we assume you'll have some familiarity with basic web service concepts, but we don't expect you to have any concrete experience using WCF or. NET 3. 0. If you're brand new to these things, you're in the right place. We'll begin this module by providing you with a quick overview to the world of connected systems. Along the way, we'll discuss some of the trends that have caused the industry to move towards this new concept of services. We'll discuss service-orientation, a new design paradigm that you can adopt to build service-oriented architectures. After that brief introduction, we'll be prepared to turn our attention to Windows Communication Foundation, a new programming model that's part of. NET 3. 0 for building these types of service-oriented solutions. We'll cover some of the basics around how you write the WCF code to both implement and consume services. And towards the end of this module, we'll answer some of the most common questions that developers ask when they're first presented with this new technology. Okay, with that in place, let's dive in.
Designing SOAP Services Hi, my name is Scott Seely, and I'm with Pluralsight. In this module, we're going to cover how to architect and design SOAP services. We start the module by looking at the various SOAP service design styles that are available to us as developers. We'll then try to understand the WS-* stack, and by understanding the WS-* stack, we'll understand what it means when we pick different features from WS-*, for example, what does it mean when I want to use reliable messaging, what does it mean when I want to use metadata exchange, dynamic binding or security? Then take a look at how to use all of this information to expose things like control interfaces over SOAP. Control interfaces are handy when you have a limited number of clients that need to access a service or some other background process and make adjustments to that background process. A lot of times what you need to do with your messaging system is you need it to be fast. We'll take a look at how do you optimize your system to create the fastest, most performant SOAP messaging system you can build. On the other end of the spectrum from speed, you may also want to make sure that you have an interoperable SOAP service. This means that you want to be able to produce a service that works well on. NET, on Java, and on other SOAP stacks. Beyond interoperability, you also want to make sure that your services are secure. Do you want to use security that uses HTTPS and the underlying transport or do you want to use security that's built into the WS security specification? We'll take a look at how you balance against those two needs to build services that are secure and interoperable.
Designing REST Services Hello, my name is Scott Seely and I'm with Pluralsight. In this module, we're going to talk about how to design REST services. We're going to cover a number of topics pertinent to REST. We start off by looking at two different service design styles, RPC oriented and REST oriented. Once we understand the difference between those service design styles, we're going to dig deeper into understanding REST, or representational state transfer. With a firm understanding of representational state transfer, we're then going to look at how we can use that information to take resources in our applications and build what's called a resource oriented architecture. With the resource oriented architecture in place, we're then going to look at how we use WCF and other. NET technologies to enable Ajax and JSON integration. When expressing these resource oriented architectures, we have many choices about how we do so. One way we can do this is through the syndication programming model that's available through WCF. If the syndication programming model isn't exactly what we're looking for and we want to express the relationships in between objects, we can also use OData and WCF Data Services.
Versioning Hi, my name is Scott Seely, and I'm with Pluralsight. In this module, we're going to talk about versioning data and versioning services. We'll start out by taking a look at what is versioning, so that we all have the same idea of what we're talking about when we're talking about the notion of versioning. When we're talking about versioning, there's three different things we can talk about. One is versioning data. When we version data, we're changing the way that we layout our data structures, name things, and so on. We can then also add versions to the SOAP endpoints we expose, and when we change versions on SOAP endpoints, we're talking about adding or removing functionality, such as functions that can be called or changing parameters that can be called on those endpoints. And finally, we talk about versioning REST endpoints. Note that we're talking about versioning SOAP and versioning REST differently. The reason why is because you version these in slightly different ways. In general though, you're going to find that the same theme occurs again and again. When you change something that the user sees or the client sees, you've got a new version. Let's start out then
Serialization Hi, my name is Scott Seely, and I'm with Pluralsight. In this module we're going to cover WCF serialization. We'll start out with an introduction to serialization and introduce some of the common terminology that's used when people are talking about reading and writing objects to and from streams. We'll then dig into the default behaviors for serialization and look what happens when you make no statements to the serialization infrastructure whatsoever. We'll then take a look at how you can take control of the format and do things like set the XML names based on your XML serialized objects and set the order of the objects in their element as they go out into the streams. Sometimes you need the simple format of JSON to send your data. We'll take a look at how WCF supports JSON serialization. And finally, we'll look at some of the neat stuff you can do with binary serialization and take a look at why XML itself doesn't have to be bloated.