Nicholas Allen's Indigo Blog

Windows Communication Foundation From the Inside

Browse by Tags

Tagged Content List
  • Blog Post: Just Exactly What You Asked For

    When implementing a transport or layered channel class the marker used to indicate that your class is a channel is to implement the IChannel interface. Therefore, all channels will implement one of the known channel shapes: IInputChannel, IOutputChannel, IDuplexChannel, IRequestChannel, or IReplyChannel...
  • Blog Post: Advanced Windows Debugging

    Channel 9 has put up a new video that mostly plugs the Advanced Windows Debugging book by Mario Hewardt and Daniel Pravat. I recommend the book for someone that needs to debug difficult issues dealing with native resources. For most people working with WCF this is never really a concern, but custom transport...
  • Blog Post: Building with Encoders

    The basis of a channel stack is that there is a series of objects that share a common interface for communication. This leaves message encoders with something of a problem as the primitive operations for encoding and decoding messages are different than the primitive operations for sending and receiving...
  • Blog Post: Best Practice for Channel Shapes

    The hierarchy of channels derives from the single interface IChannel. By itself, IChannel is not particularly interesting because it doesn't introduce any new methods for communication. Each channel shape, such as IInputChannel or IDuplexSessionChannel, has its own interface derived from IChannel that...
  • Blog Post: Shutting Down a Channel

    A common corner-case in programming is what happens when multiple operations are attempted at the same time. One way to avoid the troubles of this corner-case is to simply prohibit having multiple operations occur simultaneously. However, it typically isn't possible to make this exclusion work in a universal...
  • Blog Post: Always Begin with Accept

    Inside a service, there's a fundamental loop running whose job it is to create channels for the incoming connections to the service. There's another loop that runs later, which you may argue is equally fundamental, that reads messages from each channel to determine the actual service invocation. Every...
  • Blog Post: Live from TechEd Day 2

    I gave a chalk talk on channel development in the afternoon yesterday. I did a huge experiment for the second-half of the talk, which was to write a custom channel from scratch for the audience. That's the kind of theater that you can pull off in a chalk talk but not a regular breakout session. I started...
  • Blog Post: Custom Channel Development

    I'll be giving another talk on channel development for WCF this year at TechEd. Due to the selection of sessions, there's really only one good lead-in talk and it's currently scheduled for later in the week. That means that I'll be spending more time on background material than I normally would. However...
  • Blog Post: Writing Channel Manager Essentials

    Once you've obtained a channel manager from the binding element, you have the first object that is usable for network communication. Although the two kinds of channel managers, channel factories and channel listeners, share many of the same methods, the use of those methods tends to be quite a bit different...
  • Blog Post: Writing Binding Element Essentials

    We're back to the channel development series for another pair of days. When I left off, I promised to talk a bit about writing binding elements and channel managers. Today's article is about writing binding elements and tomorrow's article is about writing channel managers. These articles expand on the...
  • Blog Post: Responding to GetProperty

    I've created a custom implementation of GetProperty for my binding but now I'm getting errors when I go to use the channels. Why is the validation for these channels failing? This is an implementation problem that I've talked about in the past. There is a requirement that the values queried from...
  • Blog Post: Channel Writing Checklist (Optional)

    Let's fill in some of the spaces around yesterday's checklist with a list of additional features for a custom channel. Nothing that's been added to this list is required to actually send or receive messages. By doing the things listed here, you can enable some additional scenarios and make your channel...
  • Blog Post: Channel Writing Checklist (Required)

    This pair of articles marks the checkpoint between the "big picture" introductory segments and the segments where we actually start getting down into the code. The transition is going to be gradual so there's still some philosophy left, particular around the construction of bindings and binding elements...
  • Blog Post: When to Write a Channel

    Today's article is about the tension between two simple points. Writing channels can generally be used to solve just about any problem in WCF Writing channels is generally the most time-consuming way to solve a problem in WCF The key inference that you should be taking away from this discussion...
  • Blog Post: Faking Channel Security

    I occasionally see people asking how they can fake the security capabilities of a binding. These questions often start off with "I'm getting an error message that a message's required protection level is not being met". Now, I'm not precisely sure why you'd want to fake the security capabilities in this...
  • Blog Post: Designing New Faults

    The last piece of this eleven part series on fault messages covers advice for channel authors that need to define their own set of faults. Everything here assumes that you're writing a protocol channel, that you have interesting failure cases that need to be acted on programmatically, and that your...
  • Blog Post: ListenUriBindingElement

    The story from yesterday: there is an important setting for composite duplex that is only settable through the binding context. Unfortunately, proxy clients automatically create and use their own binding context so there is no convenient time to poke in a replacement value for the setting. What kind...
  • Blog Post: Design Pattern for Building Channel Factories and Listeners

    This is just a style convention that helps you avoid doing some thinking while writing custom channel classes. During the channel construction process, there's a flow of information from the binding (design time), through the channel factory and listener, and down to the channel (run time). The channel...
  • Blog Post: The GetProperty Picture

    I drew this picture for myself while working on the guidelines for implementing GetProperty . I figured that other people might find it useful as well. One of the guidelines is that queryable properties on design time objects should flow to the corresponding run time objects. The black boxes show the...
  • Blog Post: Datagram Transports

    Datagrams are a self-contained unit of data. Each datagram carries with it the routing and context information needed to receive the data without knowing about any earlier exchanges of information. This means that you can continue sending datagrams from a source to a destination even if past datagrams...
  • Blog Post: Implementation Guidelines for GetProperty

    This post is just some quick thinking about guidelines for implementing the GetProperty method. These guidelines are still in development so think of this as a draft rather than real guidance at this time. Background: We provide an extensibility point called GetProperty on many of the components...
  • Blog Post: ROT 128 Stream Upgrade Sample, Part 5

    Today is the last part of the stream upgrade sample. We've already looked at all the parts required to make the stream upgrade operate: stream, binding element, provider, initiator, and acceptor. All that's left today is to build a test harness for the code and run it. Here are the previous parts of...
  • Blog Post: ROT 128 Stream Upgrade Sample, Part 4

    The final pieces needed for the ROT 128 sample are a stream upgrade initiator and a stream upgrade acceptor. The initiator starts the upgrade process by providing an upgrade type string from GetNextUpgrade. I've coded this so that the initiator and acceptor share a type string that is stored as a static...
  • Blog Post: ROT 128 Stream Upgrade Sample, Part 3

    Last time, we built the binding element for the stream upgrade sample . The job of the binding element was to stash itself away in the binding context so that the transport could later pull out the stream upgrade and build the provider. This time we'll look at the implementation of the stream upgrade...
  • Blog Post: ROT 128 Stream Upgrade Sample, Part 2

    Building a stream upgrade for ROT 128 starts with creating a binding element to put in the channel stack. This binding element extends the special StreamUpgradeBindingElement base class , which functions very similarly to the specialized binding element base classes for transports and message encoders...
Page 1 of 2 (49 items) 12