Search results matching tag 'Core.Net WCF'

Agenda for MSNetwork Web vNext Session

ddobric — Sun, 31 Mar 2013 12:49:16 GMT

Here is the preliminary agenda for MSNetwork upcoming session next week.

There are few important things which will unfortunately not be covered in this session.
But if you really want to dive deeper behind Steaming and Push technologies, I would recommend you to read this post.

How to activate WCF on IIS8 and Windows 8?

ddobric — Mon, 24 Sep 2012 15:03:18 GMT

When you start working with WCF on Windows 8 and IIS8, you might run into following problem.

HTTP Error 404.3 - Not Found

The page you are requesting cannot be served because of the extension configuration. If the page is a script, add a handler. If the file should be downloaded, add a MIME map.

To make this working you have enable (install/activate) Advanced .NET 4.5 Features, which are mostly related to WCF:

WinDays 2012 KeyNote Demo Step Through

ddobric — Sat, 12 May 2012 11:54:46 GMT

Few days ago I showed the Demo at WinDays 2012 keynote under the name “SharePoint Ralay”. The idea of the keynote was to show some important features which never have been shown or documented in the way as of very one common industry scenario. To keep things simple we didn’t go to deep into details of SharePoint and ServiceBus. We wanted to to build a demo which will show how to build few complex and enterprise relevant scenarios, but to be in the same time interesting for most developers in audience and even for journalists who have been attending the key note.
So I decided to target three common industrial issues which daenet has been asked to solve multiple times during 2011:

1. How to get (or put) SharePoint data out of enterprise without changing of infrastructure?
2. How to build dynamic WCF contract?
3. How to build Failover cluster in 48 Seconds?

1. How to get/put data out of SPS without changing of infrastructure?

Most SharePoint Developers live in their collaborative context which mostly does not require such scenarios. But when building SharePoint solutions you will figure out that SharePoint isn’t application platform in term how one solution or enterprise architect expect to be. Today, complex systems are systems which consist of usually distributed and hybrid hybrid applications.Distributed means they at least do not run in one process and hybrid means they can be build on top of different technologies.
So, imagine now one application which is build in .NET 4.5 which should run in SharePoint. To make it more simpler image a JAVA application which runs at different machine on different geographic location. Now put it in SharePoint and let talk to each other. Application Platform is the platform which enables to do such things. Any other application platform like SharePoint, CRM, BizTalk or anything else is a platform of their own definition with huge limitations. Because of that be careful, when you say platform. “One can be a boss in his village, but just some little peace in the global world”. The part of Microsoft which build such platforms is called Business Platform Division.

So, let’s get now some data out of SharePoint in context of distributed application scenario. First of all in the world of distributed thinking, you should never allow external parties get in touch with your platform directly. To illustrate this constraint, think on giving the public access to your database. You will probably never allow somebody to send you DB-commands which will be executed against your DB (SQL Injections etc..). If you do it it is wrong and please think change it.. By following the same rule you shouldn’t let anybody to dig in your SharePoint platform for the same reason. You even should not share the secret, that you platform is SPS.

The easiest way is to provide some kind of intermediary component which will abstract the business scenario over secret platform which is running in the background. The technology which does exactly this job is WCF. We will put WCF service between SPS and external party. At some point of time when you have lot of such services, you can start to talk about Middle-Ware. This is a fine solution, but there is a still one practical problem.

The service contract could look in our case as shown below:

[ServiceContract(Name = "EchoContract", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
public interface ISpsRelayService
{
[OperationContract]
List<MyEntity> Query(QueryEntity query);
}

You should define the QueryEntity which somehow describes what you want. SPS developer would like to to see here probably SPS- “ClientObjects”. Unfortinatelly they have never been designed for such scenarios. They can only be used by explicit helper libraries. Such libraries do not work out of SharePoint and their dependent entities are not serializable.
But never mind, define your entities like your business needs them (see service contract above).

The service implementation (see code below) will read the QueryEntity instance and build appropriate SPS-query (not shown in the demo below).
After all we will call SPS WebService hosted internally in our enterprise at http://yourhost:44445 and finally build response as collection of MyEntity instances.
This service decouples the SPS from external parties and provides very simple and business related contract as usual in the SOA world.
Following code snippet shows how to implement the service which gets documents from some SharePOint library and returns them as collection to the external party. In fact this is nothing very complicated (not yet)..

public List<MyEntitity> Query(QueryEntity query)
{
ClientContext clientContext = new ClientContext("http://yourhost:44445");

            Web oWebsite = clientContext.Web;
            var files = oWebsite.GetFolderByServerRelativeUrl("/Shared%20Documents").Files;
            clientContext.Load(files);
            clientContext.ExecuteQuery();

List<MyEntitity> items = new List<MyEntitity>();

            foreach (var doc in files)
            {
                dynamic o = new MyEntitity();
                o.Name = doc.Name;
                o.Something = DateTime.Now.Ticks;
                o.Version = doc.UIVersionLabel;

items.Add(o);
}

return items;
}

To make it available in the internet this service needs to have a public endpoint accessible by the external party. And exactly this is the change demand in infrastructure which is very, very often an organizational issue or even “No go”. First somebody hast to give you an public IP address, then you need to configure NAT and DNS for it, then Security, port mapping from probably 80 to 4445 etc., etc..
I want to build some kind of VPN between my WCF (talking to SPS) and external caller, but without changing any piece of infrastructure. The next picture shows this scenario. Windows Azure provides a platform service called “Service Bus”. This one provides a feature called relying. Relaying can connect two participants directly thorough firewall. Two participants are connected through Service Bus intermediary by using bidirectional TCP connection, which remains open after once is established.

Following code shows how to start-up the service which will listen on Service-Bus packets and relay SharePoint to external caller.

static void Main(string[] args)
{
ServicePointManager.ServerCertificateValidationCallback = validateServerCert;

           // create the service URI based on the service namespace which you will obtain when creating the
           // service bus namespace.
          Uri address = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespaceDomain, "SpsRelayService/DocumentLibrary");

          // create the credential object for the endpoint
          TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
          sharedSecretServiceBusCredential.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);

// create the service host reading the configuration
ServiceHost host = new ServiceHost(typeof(SpsRelayService), address);

          // create the ServiceRegistrySettings behavior for the endpoint
          IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings()
{ DisplayName = "Sharepoint Relay Document Library Service", DiscoveryMode = DiscoveryType.Public };

          foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
          {

               // add the Service Bus credentials to all endpoints specified in configuration
             endpoint.Behaviors.Add(sharedSecretServiceBusCredential);

             // Optionally you can add the URI in the registry.
             endpoint.Behaviors.Add(serviceRegistrySettings);
          }

// Open the service
host.Open();

Console.ForegroundColor = ConsoleColor.Cyan;

          Console.WriteLine("Service address: " + address);
          Console.WriteLine("Press [Enter] to exit");
          Console.ReadLine();

          // close the service
          host.Close();
      }

Similarly, external party will also establish the connection as shown in the next snippet:

static void Main(string[] args)
{
ServicePointManager.ServerCertificateValidationCallback = validateServerCert;

// create the service URI based on the service namespace
Uri address = ServiceBusEnvironment.CreateServiceUri("https", serviceNamespaceDomain, "SpsRelayService/DocumentLibrary");

           // create the credential object for the endpoint
           TransportClientEndpointBehavior sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
           sharedSecretServiceBusCredential.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);

// create the channel factory loading the configuration
ChannelFactory<ISpsRelayService> channelFactory = new ChannelFactory<ISpsRelayService>("RelayEndpoint", new EndpointAddress(address));

// apply the Service Bus credentials
channelFactory.Endpoint.Behaviors.Add(/*swtBehavior*/sharedSecretServiceBusCredential);

           // create and open the client channel
           ISpsRelayService channel = channelFactory.CreateChannel();

           ((ICommunicationObject)channel).Open();

           Console.WriteLine("Enter text to echo (or [Enter] to exit):");

           string input = Console.ReadLine();

           List<MyEntity> res = channel.Query(new QueryEntity(){…});

            ((ICommunicationObject)channel).Close();

           channelFactory.Close();
       }

If you ever worked with WCF there is not much more to say. The code shown above contains a bit sugar around standard WCF.Everything else is a matter of channel which is hidden behind RelayBinding. For more information about ports in use take a look here.
Following binding must be configured in both service and client.

After you start service and then client,the client will send the request to service through firewall. The service will get data out of SPS and relay it back to the client.

2. How to build dynamic WCF contract?

In the world of SOA you always should build a clear contract between two boundaries. That means contracts like following one are not well designed:

Message Operation(Message msg);

I have also seen in some projects following variant of the similar contract, which is semantically the same one as previous one:

string Operation(string msg);

By using such contract the client has no way to know how to serialize the message. Even after the service version is changed, there is no way to communicate this to anybody instead of verbal human communication which is time intensive and error prone. Compare it with “add service reference” to create the proxy. The client and service must in such cases implement code which serializes/deserializes respectively the message (string).
In other words, using service contracted this way is called “Anti-Pattern”, which should not be used in the SOA world.

Many developers think they can build SOA solution if they are just able to build WCF based service. This is a mistake. When you use WCF it doesn’t mean at all that you are by default SOAP capable. In our scenario I will use out this fact as my advantage. Connecting external party to our relay service is not SOA focused scenario. It is more about classical EAI and not SOA. Such kind of connecting system is known as interface with point-to-point connection. This is also not the best pattern in the world of SOA (I mean point2point interface). and it should b e avoided when building middle-wares. But this is another story.

In other words, If you are connecting two systems as point2poin it might be valid to apply SOA anti-pattern.This is in context of SOA an anti-pattern, but not an anti-pattern in universe of possible solutions. If you have two parties talking to each other then you can often change the contract between them without of too much organizational difficulties.If you are changing often the contract (in our case MyEntity and MyQuery) it is easier to make it dynamic. In this case you can build it once without need to change it in the future, because it is dynamic one. Following example shows how to use ExpandoObject to build dynamic WCF contract. If you don’t know what this is take a look on Alexandra’s and Rick’s posts.

ServiceContract(Name = "SpsRelayContract", Namespace = "http://daenet.deServiceModel/Relay/")]
public interface ISpsRelayService
{
[OperationContract]
List<ExpandoObject> Query(ExpandoObject expression);
}

The good thing on Expando-contract is that you can do something like this:

dynamic o = new ExpandoObject();
               o.Name = “bla bla”;
               o.Something = DateTime.Now.Ticks;
               o.Method= new SomeDelegate(someMethod);

You can set on this object whatever property you want (more or less). But note in a case of WCF the method instance as property wouldn’t make a sense, because that instance will not exist on some other process and some other machine. However all other properties can be set as you like. And WCF will serialize them automatically for you. In other words, if you have a new property you don’t have to change contract. You just set it like:

o.NewPropery = 17;

The consumer of this value just hast to know that is there (because,. remember, there is not clear contract, Add-Reference or SVCUTIL).

As a recap, note that ExpandoObject provides a dynamic contract. Build your Service on top of this entity and you will not have to change the contract when new properties are added in the business scenario, which service implements. Remember that this is not a SOA capable solution, but it is valid to build Point-To-Point scenarios when one party is connecting to another one.

3. How to build Failover cluster in 48 Seconds?

Last but not least I there is an issue which has been mostly forgotten in almost all our discussion when building relaying scenarios. I every project you will reach a point when the solution has to be deployed in the production. Then you will ask yourself how to build redundancy based on relying? This means, you want to provide a fail-over instance of you WCF relaying service which will be used when the first one is not reachable. The picture shown bellow illustrates this requirement.

To make this working you really do not have to change any peace of infrastructure. Just start the another instance of the service on another machine. That’s all. This will work by using both protocols TCP and HTTP. There are currently few undocumented differences in routing when using different protocols, nut in general both will provide you the stable and reliable fail-over mechanism.

Remark: If you are demoing this scenario with both WCF-instances on one machine, the basicHttpRelayBinding will not work with out-of-the-box configuration, because both instances will try to start listening for contract sharing at the same address. In a case of netTcpRelayBindig this will not happen. So, the latter one can be started multiple timas at one box.

Thanks to Tomislav Tipuric director of WinDays technical track who has visionary recognized the industry need for this scenario.

WCF Duplex via WebSocket

ddobric — Sat, 26 Nov 2011 16:36:45 GMT

Long time ago WCF has introduced DUPLEX channels (bindings). A duplex service, can send messages back to the client endpoint, providing event-like behavior. Duplex communication is established when one client connects to a service and provides the service with a channel on which the service can send messages back to the client. The idea behind duplex is very nice and promising. Unfortunately there are few limitations which prevents this pattern to be widely used in almost all scenarios.
For example, duplex works on top of the session which is established between client and the service. If this session is broken the callbacks cannot be invoked etc., etc..
Moreover, if the client is invoking the service operation from internet location which is hidden by firewall NAT, the service will not be able to reach the client.
In fact, Duplex has infrastructural and pattern driven limitations.

This should be slightly changed in WCF 4.5. The WCF 4.5 introduces new binding NetHttpBinding, which establishes the duplex-session on top of WebSocket protocol. This protocol allows calling back operation event if the client is behind the firewall.

How does this can work?

On the beginning of the session client sends the typical HTTP request to service. This request contains a few more header like Upgrade-, Sec-WebSocket-Version-, Sec-WebSocket-Key header etc. After that Binding can use polling or it can open the permanent TCP connection between client and service (ConnectionMode= Upgrade/Allowed).
Today we expect that TCP connection which is basically TCP- streaming between client and service established after first HTTP-request. This is very powerful mechanism to establish real time communication are real evening. Remember Duplex was as a pattern the simulation of evening. If the connection is not upgraded the polling will still be just a simulation of evening. However what ever the connection mode is used, the NAT issue is behind us. It will just work.

Please do not be confused with other implementations of WebSockets. At the moment there are four implementations.Not all of them provide the same thing.
For example, following four libraries provides the functionality around WebSocket specification. They all are compatible with each other. Note that .NET implementation of the client functionality is missing and as I know it is unfortunately currently not at Microsoft Agenda. That means, if you want to use WebSockets as a .NET client you will have to use WinRT Windows.Networking.Sockets.Dll.

Microsoft.ServiceModel.WebSockets
Provides the native WebSocket Server implementation which can be hosted on top of WCF. (See WebSocketService)

Microsoft.Web.WebSockets
Provides the native WebSocket Server implementation of WebSockets handlers in ASP.NET and ASP.NET MVC. (See WebSocketHandler)

WIndows.Networking.Sockets
WinRT implementation of WebSocket client functionality .

Java Script
Browser imlementation of client functionality, curentlly suported on IE10 only (in the Windows world)

Last but not least, the namespace System.ServiceModel contains the Duplex implementation based of WebSockets. You cannot use this one in combination with any of libraries listed above. This post is related to this namespace only! Don’t get confused.

Let’s build one sample

Service

Following code-snipet shows the service contract related to CallBack-ISampleServiceCallback .

namespace Service

{

[ServiceContract(Namespace="http://daenet.com/orderservice",

                     CallbackContract = typeof(ISampleServiceCallback))]
    public interface ISampleService
    {

        [OperationContract]
        bool CreateOrder(long productId, int amount, long customerId);
    }

}

An this is how the callback contract is designed:

namespace Service
{
    [ServiceContract]
    public interface ISampleServiceCallback
    {
        [OperationContract(IsOneWay=true)]
        void OrderPurchased(long orderId, string comment);

[OperationContract(IsOneWay = true)]
void OrderCanceled(string reason);

}
}

An here is the the service implementation:

namespace Service
{
    public class SampleService : ISampleService
    {
        private static Dictionary<Guid, ISampleServiceCallback> m_CallbackChannels =

new Dictionary<Guid, ISampleServiceCallback>();

        public bool CreateOrder(long productId, int amount, long customerId)
        {
            var ctxId = Guid.NewGuid();

m_CallbackChannels.Add(ctxId, OperationContext.Current.GetCallbackChannel<ISampleServiceCallback>());

            new Thread(new ThreadStart(delegate()
                {
                    Thread.Sleep(5000);

                    if (amount > 10)
                        m_CallbackChannels[ctxId].OrderCanceled("Not in store");
                    else
                        m_CallbackChannels[ctxId].OrderPurchased(new Random().Next(10000), "Purchased successfully");
                })).Start();
            return true;
        }
    }
}

To make this working we will need a peace of configuration. This is a part of web.config file. That means I used IIS8 to host the web socket. This is important, because to host WebSockets you need to enable WebSocket protocol which is at the moment specifically on Windows 8 only. As already mentioned, I used IIS8, but self-hosted service will work too, as long you are running it on Windows 8. To make WebSockets working Microsoft has slightly changed few things in the http.sys and IIS pipeline implementation. This is why IIS Express does not support WebSockets at the moment (not yet).

</binding>

</netHttpBinding>

</bindings>

As you see I used here NetHttpBinding.

Client

Now let’s implement the Client. Create the console or any other application and add the service reference to running service. This is automatically generated.

</customBinding>

Generated binding looks a strange, but it works. In fact NetHttpBinding is CustomBinding implementation which use http-transport and binary message encoder.

You can do the same thing by using NetHttpBinding instead of CustomBinding:

Meeting Prof. Dr. Dan Reed

ddobric — Sun, 31 Oct 2010 20:28:01 GMT

Frankfurt am Main – Germany, October 28 – 29, 2010
International Supercomputing Conference 2010 has been hosted this year in Frankfurt am Main - Germany. ISC Cloud'10 is a conference that focuses on massive data processing and large application simulations in the Cloud.This inaugural Cloud program is organized by an international committee of recognized experts in areas such as cloud computing, high performance computing, and data-and compute-intensive applications in the cloud, in industry and in research.

The number of internationally recognized speakers have been invited this year to give an overview of the state of research in this area. For example Dan Reed from Microsoft with a keynote talk on Technical Clouds: Seeding Discovery and Kathy Yelick from Lawrence Berkeley Laboratory with her keynote on Science in the Clouds: A View from Berkeley.

I had a pleasure to meet in person Prof.Dr. Dan Reed who practically started the conference with a great keynote. Dan is by the way Microsoft Corporate Vice President, Technology Strategy and Policy & Extreme Computing Group, Microsoft, USA.
He is working on many interesting projects, which could possible change the future of information technology or even already has changed it.I have tried to recap our conversation in few major topics.

The Society, new technologies and the Cloud

At the moment, I’m disappointed about how we (people in Germany) are ready to adopt new ideas. For example Google-Street View. Too many people are too scared. Are we getting too old that fast? because of this, I asked following question:

Dan, what is easier? To develop a new technology or to adopt it by society?

Dan thinks that we are at the moment just renaming more or less already existing terms and technologies. For example, many years ago we started to talk about “hosted services”. Isn’t that somehow SasS?
It seems to be just a question of time when things like Windows Azure will be totally adopted. In research space people work with high performance computing. In application development space people use more domain specific tools and do not need raw parallel computing.

When things like massive scale in Windows Azure will be adopted is also a measure of hardware and performance. For example, do I need to calculate my Excel sheets on my single machine or to span it across multiple machines in the cloud?

In third, consumers space, the cloud has already begun by integrating of client devices, laptops, mobile phones etc.

It will take a time, by the cloud is adopting by society step by step.

Security consideration as “Made in Germany”

Because I have a feeling that society in Germany seems to be surprisingly sometimes very conservative and in some points often even destructive, when new technologies need be adopted. My colleges in US are adopting the cloud more quickly than my colleges in Germany.
I asked why:
Dan, What is more safe? My credit card in the pocked or my data in the cloud?

Dan found this question very, amusing. :)

He answered shortly: ”The security is a perception”. It is some kind of social trust to some person”. Dan thinks, that perception of security in the cloud can be achieved by adopting of common international policy. It is a conflict between economy and technology. One of major problems are different cultural expectations and policies. We need to look for commonalities.
In technology we need approvable chain of trust, which would involve different penetrations. We will also need a trusted platform models with cryptographic support. This kind of security should enable external users to verify that what they expect to see.
One of very important researching in this context is for example “searchable encryption”. Soon we will need to run computation on encrypted data in general.
Such kind of technology will definitely have an impact on perception of security and trust in the cloud.

Cooperation between Extreme Computing research and Windows Azure Team

Because I have often a feeling that some research projects sometimes are a bit disconnected from real industry needs, I just had to ask this question:

Dan, how tightly do you work with Windows Azure team?

Dan says, that lot of research work is already consisted part of Windows Azure.
I find also few next statements very interesting for community.
At the moment Dan’s group is working on the next generation of hardware for cloud. For example, they are trying to build the processor, computer etc. to spent as less energy as possible.

About the next big thing

Because I’m working in highly innovative software company (daenet) I just have to know what his group is doing right now?

Dan, What is your most exciting project at the moment which is not under NDA?

Again, he found my question funny.
As I understood, the major requirement in his group is at the moment to build the hardware which is able reuse energy like solar and wind energy sources . The structure and concepts of such hardware will have a strong impact on infrastructure and implicitly also on and programming model and applications itself . In this concept things like power grids, solar and wind energy play a very important role.
It is lot of about eco-friendly and much more smaller datacenters. More efficient cooling, by complete redesign of hardware. And, it is not all about technology. Much more other things come into play. For example energy cost or even geological and political stability.

In this context I also asked following question:

Is there some even more exciting project, which is a top secret one?

Dan laughed again and answered “I couldn't’ tell you that”. :)

The message for developers

I was interested to know when we developers need to move to Windows Azure programming model?
He thinks that we all are today in a division of the future. In fact, we need to build software as usual today. But, the Cloud is inside of Microsoft truly more than just a marketing story. Microsoft is committed to Cloud.
I asked him to define more precisely the time when we will no more build any other than cloud capable software. (please all of you who is reading this, do not understand this absolutely). I wanted to know does this point of time falls in this decade?
He said, “Definitely.It is sooner as we think”.

Dan, thank you for your time.

Damir

WCF Analytic Trace Messages

ddobric — Sat, 23 Oct 2010 11:50:10 GMT

Some of you may know that windows provides by default Event Trace Session called “EventLog-Microsoft-Windows-Application Server-Applications-Analytic”. session.

This session can be enabled by enabling of Analytic-Event log:

Assuming that your service has following diagnostic configuration and both, client and service are running on the same machine the trace will produce messages shown below:

1. The Dispatcher invoked 'BeforeSendRequest' on a ClientMessageInspector of type 'Microsoft.VisualStudio.Diagnostics.ServiceModelSink.StubClientEventSink'.

2. The Client is executing Action 'http://tempuri.org/ICalculator/Add' associated with the 'ICalculator' contract. The message will be sent to 'http://localhost/MyService/Calculator.svc'.

3. The transport sent a message to 'http://localhost/MyService/Calculator.svc'.

4. ServiceHost started: 'Microsoft.Samples.MyService.Calculator'.

5. The transport received a message from 'http://localhost/MyService/Calculator.svc'.

6. The Dispatcher received a message from the transport. Correlation ID == '{00000000-0000-0000-0000-000000000000}'.

7. The Dispatcher invoked ~~'AfterReceiveReply'~~(means AfterReceiveRequest) on a MessageInspector of type 'Microsoft.VisualStudio.Diagnostics.ServiceModelSink.StubServerEventSink'.

8. An OperationInvoker invoked the 'Add' method. Caller information: '::1:10376'.

9. Custom Message (if exist)
Name:'DidAddLogic', Reference:'Default Web Site/MySevicetor.svc|Calculator', Payload:1+7=8

10. An OperationInvoker completed the call to the 'Add' method. The method call duration was '3' ms.

11. The Dispatcher invoked ~~'BeforeSendRequest'~~ (means BeforeSendReply) on a MessageInspector of type 'Microsoft.VisualStudio.Diagnostics.ServiceModelSink.StubServerEventSink'.

12. The Dispatcher sent a message to the transport. Correlation ID == '{00000000-0000-0000-0000-000000000000}'.

13. The transport sent a message to 'http://localhost/MyService/Calculator.svc'.

14. The transport received a message from 'http://localhost/MyService/Calculator.svc'.

15. The Client completed executing Action 'http://tempuri.org/ICalculator/Add' associated with the 'ICalculator' contract. The message was sent to 'http://localhost/MyService/Calculator.svc'.

17. The Dispatcher invoked 'AfterReceiveReply' on a ClientMessageInspector of type 'Microsoft.VisualStudio.Diagnostics.ServiceModelSink.StubClientEventSink'.

Here is the explanation. The blue trace-messages are client trace-messages and red messages are produced by service.
Client implements usually IClientMessageInspector ans Service implements IDispatchMessageInpsector.

public interface IClientMessageInspector
{
    // Methods
    void AfterReceiveReply(ref Message reply, object correlationState);
    object BeforeSendRequest(ref Message request, IClientChannel channel);
}

public interface IDispatchMessageInspector
{
    // Methods
    object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext);
    void BeforeSendReply(ref Message reply, object correlationState);
}

Mesages 7 and 11 seem to have invalid description, but the sequence is correct. Messages 4 to 13 are traced out if the service is started in debugger. If the service is not started in debugger only messages traced out.Nate that under some circumvents last statement is not always valid.

Attach Debugger Security Warning

ddobric — Fri, 13 Nov 2009 17:12:55 GMT

While debugging you WCF-Service or ASP.NET application within UnitTest you may get following warning when stepping into the service code.

“Attaching to this process can potentially harm your computer…”

For example, this can happen when you have the UnitTest which invokes the Service via generate Proxy instance. When you start the UnitTest method in debugger the Visual Studio will attach VsTest.exe process. However, if you want to step into the service code (by pressing “F11”) the Visual Studio will first have to attach to the process which hosts the service. This might be Cassini or IIS. At this moment you may get following warning:

If you have been doing this for a while you might be surprised that this message sometimes appears and sometimes not. If you have this feeling you are right.
This message will appear if the attaching process which hosts the service is hosted by user which has no debugging permissions. Mostly this just mean it is not the local admin. More precisely, if the host is a process started by IIS (w3wp.exe) the host identity is defined by identity of the pool of the web application which hosts the service.

So, if the pool’s identity has no permission for debugging the message shown above will be popped up. Please be also aware that when working in team you will sometimes be forced to create (next picture) the local directory. In this case IIS will automatically setup the application to default pool, which by default (NETWORK_SERVICE) has no debugging permission.

Authenticode verification with signtool.exe

ddobric — Sat, 02 May 2009 14:37:05 GMT

This post shows two examples which shows how to verify signature of an application based on Authenticode policy. First example will fail, because the application is signed with the key, whose root certificate is not trusted.

Example 1 (it will fail)

C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin>signtool verify /v /pa c:\temp
\SampleApplication.exe

Verifying: c:\temp\SampleApplication.exe
SHA1 hash of file: 99CE8EA6C1096C7CF9CD96C4A2E707A096CA1E76
SignTool Error: WinVerifyTrust returned error: 0x800B010D
        The certification path terminates with the test root which is not truste
d with the current policy settings.
Signing Certificate Chain:
    Issued to: Root Agency
    Issued by: Root Agency
    Expires:   01.01.2040 01:59:59
    SHA1 hash: FEE449EE0E3965A5246F000E87FDE2A065FD89D4

        Issued to: daenetauthenticode
        Issued by: Root Agency
        Expires:   01.01.2040 01:59:59
        SHA1 hash: 79FBF8FAE05640808B8B488BD5728B59B19D0766

File is not timestamped.
SignTool Error: File not valid: c:\temp\SampleApplication.exe

Number of files successfully Verified: 0
Number of warnings: 0
Number of errors: 1

Example 2 (it will succeed)

Now after the root certificate is installed under trusted publishers, the same verification will pass successfully.

C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin>signtool verify /v /pa c:\temp
\SampleApplication.exe

Verifying: c:\temp\SampleApplication.exe
SHA1 hash of file: 99CE8EA6C1096C7CF9CD96C4A2E707A096CA1E76
Signing Certificate Chain:
    Issued to: Root Agency
    Issued by: Root Agency
    Expires:   01.01.2040 01:59:59
    SHA1 hash: FEE449EE0E3965A5246F000E87FDE2A065FD89D4

        Issued to: daenetauthenticode
        Issued by: Root Agency
        Expires:   01.01.2040 01:59:59
        SHA1 hash: 79FBF8FAE05640808B8B488BD5728B59B19D0766

File is not timestamped.
Successfully verified: c:\temp\SampleApplication.exe

Number of files successfully Verified: 1
Number of warnings: 0
Number of errors: 0

Manipulating of Message Header in Silverlight

ddobric — Thu, 19 Feb 2009 22:43:56 GMT

Almost two years ago I have posted in "Hacking of WCF's OperationContext" about manipulating of header of the message in WCF. The same feature is also provided in Silverlight since RTW 2 BETA2. Here is an example:

Service proxy = new Service();

proxy.OnOperationCompleted +=
new EventHandler<DoWorkCompletedEventArgs>(onCompleted);

     using (OperationContextScope ctx=
     new OperationContextScope(proxy.InnerChannel))
     {

      OperationContext.Current.OutgoingMessageHeaders.Add
        (MessageHeader.CreateHeader("SomeHeader",
         "http://daenet.eu", "..."));

         proxy.OperationkAsync("foo");
     }

Next example shows how to obtain the header value:

void onCompleted(IAsyncResult result)
{
Service proxy = (Service1)result.AsyncState;

     using (OperationContextScope ocs =
     new OperationContextScope(((Service1Client)proxy).InnerChannel))
     {

string res = proxy.EndDoWork(result);

        string header=
          OperationContext.Current.IncomingMessageHeaders.GetHeader<string>
          ("SomeHeader", "http://daenet.eu");
     }
}