Catálogo de publicaciones - libros

In this chapter, you learned about the details and inner workings of .NET Remoting. You read about the various processing stages of a message, and you now know the difference between IMessageSink, IClientChannelSink, and IServerChannelSink. You also know how asynchronous requests are processed, and that the inner workings of the asynchronous message handling is different for message sinks and channel sinks.

In the next chapter, I’ll show you how those sinks are created using sink providers.

In this chapter, you read about the creation of the various kinds of sinks. Together with the previous chapter, you’re now fully equipped to implement your own sinks to enhance the feature set of .NET Remoting. You also made first contact with dynamic context sinks, a topic that is covered in more detail in Chapter 15.

I admit that the last two chapters have been quite heavy in content, but in the next chapter I reward your patience by showing some real-world sinks that employ all the techniques presented here.

In this chapter you have seen how you can leverage the .NET Remoting framework’s extensibility. You should now be able to apply the internals shown in Chapters 11 and 12 to extend and customize the .NET Remoting programming model to suit your needs.

You now know the differences between IMessageSink, which is used before the message reaches the client-side formatter, and IClientChannelSink, which is used after the serialization of the IMessage object. You know that you can add properties to the IMessage object’s LogicalCallContext to pass it to the server, where it can be read by an IServerChannelSink, and you can also encrypt or compress a request by using a combination of IClientChannelSinks and IServerChannelSinks.

You also learned how sink providers are developed, and that a client-side IMessageSink has to be created by an IClientChannelSinkProvider as well and therefore has to implement the IClientChannelSink’s methods. Finally, you read about custom proxies, which allow you to implement additional functionality before the message reaches the chain of sinks.

In the next chapter, you get a chance to use the knowledge gained here to implement a complete transport channel from scratch.

After reading this chapter, you’ve finally reached the level of .NET Remoting wizardship. Not only do you know how to extend the framework using custom sinks and providers, but now you can also implement a complete channel from scratch. You learned that most work in implementing a custom channel has to be expended in understanding and encapsulating the underlying protocol. Mapping an asynchronous protocol to synchronous calls and vice versa is an especially important and challenging task. You also know how to implement IChannelSender and IChannelReceiver, how to combine them into a top-level channel, and how to assign default formatters to a channel.

In the next chapter, I introduce you to the possibilities of using the basic principle of .NET Remoting, which is the processing of method calls using messages instead of stack-based calling conventions in your local applications.

In this last chapter, I showed you some undocumented techniques to move constraints away from the implementation up to the metadata level. When using this approach together with reflection on the types of your class library, you will be able to automatically generate documentation that includes all those metadata-level checks. You learned about using different contexts in your local application and how to use IContextProperty and IContributeObjectSink to intercept calls to your objects by using IMessageSink objects.

I just want to remind you that context sinks are a great technology, but unfortunately not yet officially supported or documented by Microsoft. If you use them, it will be at your own risk! If any problems occur when doing so, you will be on your own. But isn’t that the fate of anyone who’s going to enter uncharted territory?