Links

msmq wcf and iis getting them to play nice

AutoFac WAS Hosting and Non-HTTP Activation

Windows Components Installed

Microsoft Message Queue (MSMQ) Server > MSMQ Server Core

Microsoft .NET Framework > Windows Communication Foundation Non-HTTP Activation

IIS 7 Configuration

1. Add net.msmq to the list of enabled protocols. In IIS, Web App -> Advanced Settings -> Enabled Protocols. It is a comma separated list (http,net.msmq).
2. Make sure Client and Service have correct permissions to access the private queue

MSMQ Config

Add NETWORK SERVICE to the new MSMQ (windows 7 that is in Computer Managment -> Services and Applications -> Message Queuing

C# code to create initialize private queue

The queue name must match the URI of your service’s .svc file according to this

  // Create and connect to a private Message Queuing queue.
if (!MessageQueue.Exists(@".\Private$\JangoFettClient/CloneService.svc"))
{
    // Create the queue if it does not exist.
    MessageQueue.Create(@".\Private$\JangoFettClient/CloneService.svc");
}

Example Service Config

<bindings>
    <netMsmqBinding>
        <binding name="MsmqBindingNonTransactionalNoSecurity"
                        exactlyOnce="false">
            <security mode="None"/>
        </binding>
    </netMsmqBinding>
</bindings>
<services>
<service name="JangoFettClient.CloneService">
    <endpoint name="msmq" 
              address="net.msmq://localhost/private/JangoFettClient/CloneService.svc"
              binding="netMsmqBinding" 
              bindingConfiguration="MsmqBindingNonTransactionalNoSecurity"
              contract="JangoFettClient.ICloneOrderProcessor" />
</service>
</services>

Example Service

Example of data contract that would automatically become the listener and pull the items from MSMQ via WCF

namespace JangoFettClient
{
    public class CloneService : ICloneOrderProcessor
    {
        private readonly ILog _logger;

        public CloneService(ILog logger)
        {
            _logger = logger;
        }

        public void SendMessage(CloneOrder request)
        {
            _logger.Info("Message received from MSMQ");
        }
    }
}

Errors with easy fixes

The protocol ‘net.msmq’ is not supported. Add net.msmq to the list of enabled protocols. See IIS 7 Configuration above for more information.

Last week in the office I thought to my self, “Holiday weekend coming! I’ll have time to play with WP7 or maybe I’ll play with HTML5”. Then I saw this tweet on twitter.

We as developers spend too much time playing with baubles and shiny new tools and not enough time on core skills and fundamentals

I thought well, instead of using some free time this holiday weekend to build something why not do a little research. I happened to have a problem at work which someone suggested using the Visitor Pattern. So I spent some time looking over a few resources and Wikipedia has a great explanation. I won’t try to repeat that. One area I was stuck on though was the concept of double dispatch. I found this example on StackOverflow.com which solidified the concept. For some reason learning by spaceship and rebel alliance works for me.

So now that I had a good understand all I needed to was implement it right? I thought about it and figured that could wait. Now is an opportunity to work on my fundamentals. The Wikipedia article mentioned Common Lisp and how the Visitor Pattern simplified when using dynamic languages. This got me to thinking what would this look like in F# or a functional language?

While looking into functional languages I came across this Stack Overflow question “I am a C# developer, Should I start looking more on F# [closed]”.  Jon Skeet’s answer influenced me and I figured I would pick up a book Real World Functional Programming. It fits into the category of fundamentals because it’s using C# and F# to teach functional programming. Which I haven’t used in many years.

So I start reading with the goal in mind that I would make a quick example of the visitor pattern in F#. Don’t think I am a super geek (not that you would be confused because of my skills). I did take time to drink a few of these and go to the Crowded House concert this weekend. By the fourth chapter or so things started to sink in with F# and functional programming.

If I were using a declarative functional style of programming, I wouldn’t even need the visitor pattern at all!  I don’t have objects that would need to be separated from the algorithm. I would only have types and could use pattern matching and discriminated unions to perform my algorithm. The visitor pattern is needed in my current project because I’m using an implicit OO coding approach.

It was really shocking to me that this wasn’t obvious right away. I’ve been doing OO for so long now I’ve completely become accustomed to dealing with objects and state. A programming world without objects had completely slipped from my mind. Glad I took the time to get started on this book as it’s already giving me new ideas and techniques I can use in my daily C# and OO programming. Now to start working on some of the other programmer competencies.

using System;
using System.Collections.Generic;

namespace PropositionalLogic
{
    public class Program
    {
        public class truthvalue
        {
            public bool X { get; set; }
            public bool Y { get; set; }
        }

        public static bool XorY(bool x, bool y)
        {
            return (x || y);
        }

        public static bool XandY(bool x, bool y)
        {
            return (x && y);
        }

        public static bool Exclusive(bool x, bool y)
        {
            return (x && y) && !(x && y);// always false
        }

        public static bool Tautoloty(bool x, bool y)
        {
            return x || y || (!x && !y);// always true
        }

        public static bool Contradition(bool x, bool y)
        {
            return x || (y && !y);
        }

        public static bool MaterialImplication(bool x, bool y)
        {
            return !x || y; 
            //this can also be expressed as the following conjunction !(x && !y);
        }

        public static bool BiConditional(bool x, bool y)
        {
            return MaterialImplication(x, y) && MaterialImplication(y, x); //"if and only if"
        }

        static void Main(string[] args)
        {
            var truthTable = new List<truthvalue>
                                 {
                                     new truthvalue() {X = false, Y = false},
                                     new truthvalue() {X = false, Y = true},
                                     new truthvalue() {X = true, Y = false},
                                     new truthvalue() {X = true, Y = true}
                                 };

            var sentences = new Dictionary<string , Func<bool, bool, bool>>
                                {
                                    {"X v Y", XorY},
                                    {"X & Y", XandY},
                                    {"(x v y)& -(x & y)", Exclusive},
                                    {"x v y v (-x & -y)", Tautoloty},
                                    {"x -> y", MaterialImplication},
                                    {"x ~ y", BiConditional}
                                };

            CalculateTruthTable(truthTable, sentences);

            Console.ReadLine();
        }

        private static void CalculateTruthTable(IEnumerable<truthvalue> truthTable, 
Dictionary<string , Func<bool, bool, bool>> sentences)
        {
            foreach (var sentence in sentences)
            {
                Console.WriteLine("");
                Console.WriteLine("|X      |Y      |{0}  |", sentence.Key);

                foreach (var value in truthTable)
                {
                    var x = value.X;
                    var y = value.Y;

                    var result = sentence.Value(x, y);

                    Console.WriteLine("|{0}  |{1}  |{2}  |", PrettyPrint(x), PrettyPrint(y), 
                                       PrettyPrint(result));
                }
            }
        }

        private static string PrettyPrint(bool input)
        {
            return input ? input + " " : input.ToString();
        }
    }
}

string strValues = "search term";
string strURL = "http://mysite.com?search="
+ encryptQueryString(strValues);
Response.Redirect(strURL);

string strScramble = Request.QueryString["search"];
string strdeCrypt = decryptQueryString(strScramble.Replace(" ", "+"));

The “strScramble.Replace(” “, “+”)” is a scary way to get around the request.querystring automatically changing the “+” into a space.   A better way is to use System.Uri.EscapeDataString before adding the querystring value. Then HttpUtility.UrlDecode works as expected returning the “+”.

According to this blog on MSDN (http://blogs.msdn.com/yangxind/default.aspx), when encoding the URL use “System.Uri.EscapeDataString”, when decoding the URL use “ HttpUtility.UrlDecode“.

Example using Uri.EscapeDataString and taking out replace:

string strValues = "search term";
string strURL = "http://mysite.com?search="
+ encryptQueryString(Uri.EscapeDataString(strValues));
Response.Redirect(strURL);

string strScramble = Request.QueryString["search"];
string strdeCrypt = decryptQueryString(strScramble);

There are two decoding methods in .NET

Encoded Characters	HttpUtility.UrlDecode	System.Uri.UnescapeDataString
%26	&	&
%24	$	$
%2b	+	+
%20	Space	Space
+	Space	+
%25	%	%
%3c	<	<