Our company enabled the Internet Explorer Proxy via group policy a while back to “improve performance”.  The improvement is about 10 times slower than it was before.  They insist that it is faster, but they are WRONG (yes Ken and Kevin…I’m talking about you).  Not only is it much slower, but the “bypass proxy on local addresses” doesn’t work right, so our WCF endpoints don’t work correctly without configuring them for the proxy (which we can only use message security if we do this).

[more Read on for my solution…]

Our group policy typically has these options disabled.  So it’s quite frustrating to need to turn that off for WCF.  Obviously FireFox fixed the problem for web browsing, but for WCF, this was still a problem.

So, I wrote a C# program to poll the Internet Options proxy settings, and notify me when the settings are changed, display an icon on the tray to remind me, and gives me a one-click option to toggle the proxy off when needed, then back on.  It’s not a terribly complicated program, but it demonstrates two interesting points:

1. P/Invoke variable sized arrays
2. WinForms application with NotifyIcon without having a Form at all by using a custom ApplicationContext.

So, to create a Formless Windows Forms Application, create a new Windows Forms Application, and remove the form.  Then create a new class deriving from ApplicationContext.  Add relevant code.  My proxy code looks like this:

Essentially, just make an InitializeComponent method, to create an initialize the components that are typically sited on a Form, and be sure to override the Dispose method.

Then create a Program.cs or whatever class you like for the static Main method.  In the Application.Run method, pass a new instance of your context instead of the default form.

Now, we will P/Invoke methods to actually turn on and off the Internet proxy server.  So here’s the P/Invoke signatures that I used:

And a helper class to call the methods from a nicer .NET friendly API:

This class does the P/Invoke work.

When the application is running, right clicking the tray icon allows toggling from a “proxy enabled” to “proxy disabled” state.

When the proxy is enabled and traffic is going through the proxy, the icon shows red monitors.

When the proxy is disabled and traffic is not going through the proxy, the icon shows blue monitors.

Left-clicking the icon shows the status in a balloon tip.  Clicking the balloon will toggle the proxy status.

Note: When enabling the proxy, it only turns on the currently configured proxy.  It will not configure or autoconfigure a proxy.  If there is no proxy configured, I don’t know what will happen.  I haven’t tried it.

Download the full project here or run a ClickOnce application directly here.

Comment on this
Development
.net | c# | wpf

Sometimes different instances of an object can be considered equal.  Take for example a Point class:

Two different instances of this object that have the same X and Y values should be considered equal objects.  What happens in the following snippet?

You get “The two points ARE NOT equal”.  Additionally:

Gives you “The list DOES NOT contain (1,2)”, even though it really does.

The framework doesn’t know that we intended the two objects to be equal if the X and Y properties are equal.  The framework will consider the objects equal if it is the same object, not if it has the same properties.  But we can surely tell the framework that these are the “same” object if their properties are the same.  It’s pretty easy, but can turn out bad if you don’t do it correctly.

The steps to follow are:

• Override the GetHashCode method.  This method helps “find” the object based on certain properties.
• Implement IEquitable<T> interface.  This tells the framework if the objects are actually “equal”.
• Override the object.Equals method.  This is the non-type specific equivalent of above.
• Create a == operator, delegates to the object.Equals method.
• Create a != operator, the inverse of the above.

Let’s break it down:

Override GetHashCode method.

The simplest way to do that is use the exclusive or operator (^) on the GetHashCode of each “unique” property.  So, for our Point class, even if there are other properties or fields, the two that define “uniqueness” of the object are X and Y, so the GetHashCode method becomes:

Yeah…that’s it.  More unique fields/properties? Just XOR (^) the GetHashCode of them, too.

Implement IEquitable<T>.

There’s only one method: public bool Equals(T other).  This is a three step process:

1. If the other is null, it’s not equal (obviously this is not null).
2. If the other is this, it’s obviously equal.
3. If all “unique” properties are equal, it’s equal.

Make sure to use the object.ReferenceEquals to not get into an infinite loop/stack overflow.

Again, other “unique” fields/properties are compared here as well.

Override object.Equals.

This is the non-type specific implementation of the above step, so we compare the types, then call the overload Equals(T) above.

That’s all for that.

Create a == operator.

This is a really simple step, as this operator just calls the object.Equals method.

Create a != operator.

An even simpler step: just return the inverse of the == operator.

That’s it.  Now the object is compared correctly by the framework.

So, running the original test code:

Results in:

The two points ARE equal
The list DOES contain (1,2)

The full Point class is:

And that’s it.

Enjoy.  Or don’t.  Whatever.

Comment on this
Development
.net | c#

It’s out there thousands of times.  And here it is again.  The thing I couldn’t find in my Googling for a good regular expression was the “3 of 4 conditions”.  There was “all of 3” or “all of 4”, but I couldn’t find “3 of 4”.

So, here’s what I came up with:

^.*(?=.{10,})((?=.*[a-z])(?=.*[A-Z])(?=.*\d)|(?=.*[a-z])(?=.*[A-Z])(?=.*\W)|(?=.*[a-z])(?=.*\d)(?=.*\W)|(?=.*[A-Z])(?=.*\d)(?=.*\W)).*$

• At least 10 characters
• At least 3 of the following conditions
  • Lowercase alpha character
  • Uppercase alpha character
  • Number
  • Non-alphanumeric character

How it works:

Let’s start by looking at the regular expression required for ALL of the 4 conditions listed above:

^.*(?=.{10,})(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*\W).*$

Broken up, the expression says this:

So, let’s break down the example input: this.IS.a.t34t.

To demonstrate a little bit, let’s name the matches.  So our expression becomes:

^(?'match_0'.*)(?=.{10,})(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*\W)(?'match_1'.*)$

Visualizing this:

So you can see that the first match is grouped and named “match_0” and the second match is grouped named “match_1”.

Ok.  If you’re still with me, that is how we make it match all of the aforementioned conditions.  Now how do we make it match 3 of the 4?  There is no simple declarative mechanism for “3 of 4”, so I used a combination. 

A combination of 3 of 4 items is only 4, so there’s not that much to do.  Remember, we need a combination, in which order is not important. We don’t care about order, just existence.  The formula for the number of items in a combination is

(n!)/(r!(n – r)!)

where n is the number of items to choose from (4) and r is the number chosen (3). So (4!) / (3!(4 – 3)!) is 24 / 6 = 4.  There are only 4 combinations in a “3 of 4” scenario: (lowercase, uppercase, digit), (lowercase, uppercase, non-alphanumeric), (lowercase, digit, non-alphanumeric), and (uppercase, digit, non-alphanumeric).

As an aside: if the order of the options is important, it is called a permutation.  The formula for a permutation is

n! / (n – r)!

which gives us 24 / 1 = 24 permutations.  Since we need to use alternation in our regular expression, that’s a lot of typing: (lowercase, uppercase, digit) (lowercase, uppercase, non-alphanumeric) (lowercase, digit, uppercase) (lowercase, digit, non-alphanumeric) (lowercase, non-alphanumeric, uppercase) (lowercase, non-alphanumeric, digit) (uppercase,lowercase, digit) (uppercase,lowercase, non-alphanumeric) (uppercase, digit,lowercase) (uppercase, digit, non-alphanumeric) (uppercase, non-alphanumeric,lowercase) (uppercase, non-alphanumeric, digit) (digit,lowercase, uppercase) (digit,lowercase, non-alphanumeric) (digit, uppercase,lowercase) (digit, uppercase, non-alphanumeric) (digit, non-alphanumeric,lowercase) (digit, non-alphanumeric, uppercase) (non-alphanumeric,lowercase, uppercase) (non-alphanumeric,lowercase, digit) (non-alphanumeric, uppercase,lowercase) (non-alphanumeric, uppercase, digit) (non-alphanumeric, digit,lowercase) (non-alphanumeric, digit, uppercase).

So our expression to require all four conditions is:

^.*(?=.{10,})(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*\W).*$

Which states that each of the lookaheads must be true, (10 chars)(lower)(upper)(digit)(non-alphanumeric).  What we want is to make a statement like, “10 characters and at least 3 of my 4 conditions”, which with combinations becomes, “10 characters and at least one of my combinations.”  So it would look more like (10 chars)((c1)|(c2)|(c3)|(c4)).

Now replacing with our real regular expression syntax, our final expression is:

^.*(?=.{10,})((?=.*[a-z])(?=.*[A-Z])(?=.*\d)|(?=.*[a-z])(?=.*[A-Z])(?=.*\W)|(?=.*[a-z])(?=.*\d)(?=.*\W)|(?=.*[A-Z])(?=.*\d)(?=.*\W)).*$

With the first combination in red, the second combination in blue, the third combination in orange, and the fourth combination in green.

In my next post, I’ll post my Regular Expression Test Bench.  There are a few of these online also, but I needed one with better visualization.  I needed to see the matches and captures, and highlight each of them in the text independently on demand.  Here is a screenshot of the app.  It’s being deployed as a Click-Once app, so I’ll post the URL soon. :)

Comment on this
Development
.net | asp.net

Ever wanted to know the CustomBinding equivalent of a standard binding?  Use this tool to see them.

[More Click here to see the tool]

BasicHttpBinding CustomBinding MsmqIntegrationBinding NetNamedPipeBinding NetPeerTcpBinding NetTcpBinding WSDualHttpBinding WSHttpBinding WS2007HttpBinding WSFederationHttpBinding WS2007FederationHttpBinding

How’s it done?

Create the binding and save with the ServiceContractGenerator.  That writes to a config file.  Then I read it back.

So I created a web user control with a combo, literal and a button:

And in the button handler:

Comment on this
Development
.net | wcf

In my previous post, I described compiling a custom version of Cassini that could listen to external requests, not just loopback.  Now, I want to use that version of Cassini to debug from Visual Studio.  The problem is that the command lines are different.  Visual Studio uses Webdev.WebServer.exe, and issues argument in the format

/port:1234 /path:c:\temp /vpath:/test

Cassini expects arguments in the format

apppath port virtroot

So, in main.cs, I have modified the Main function as so:

   50 public MainForm(String[] args) {

   51     //_portString = "80";

   52     //_virtRoot = "/";

   53     //_appPath = string.Empty;

   54 

   55     // look for arguments in the form of /port:1234, or /path:"abcdefg" or /vpath:/

   56     foreach (string arg in args)

   57     {

   58         if (arg.StartsWith("/port:", StringComparison.OrdinalIgnoreCase)) _portString = arg.Substring(6).Trim();

   59         if (arg.StartsWith("/path:", StringComparison.OrdinalIgnoreCase)) _appPath = arg.Substring(6).Trim();

   60         if (arg.StartsWith("/vpath:", StringComparison.OrdinalIgnoreCase)) _virtRoot = arg.Substring(7).Trim();

   61     }

   62 

   63     try {

   64         if (string.IsNullOrEmpty(_appPath) && args.Length >= 1) _appPath = args[0];

   65         if (string.IsNullOrEmpty(_portString) && args.Length >= 2) _portString = args[1];

   66         if (string.IsNullOrEmpty(_virtRoot) && args.Length >= 3) _virtRoot = args[2];

   67     }

   68     catch {

   69     }

   70 

   71     InitializeForm();

   72 

   73     if (string.IsNullOrEmpty(_appPath)) {

   74         appDirTextBox.Focus();

   75         return;

   76     }

   77 

   78     Start();

   79 }

Now, the application will accept command line arguments in either form.

I copy this cassini-v35.exe to C:\Program Files\Common Files\microsoft shared\DevServer\9.0 and rename it webdev.webserver.exe (making a backup of the old webdev.webserver.exe of course), and now I can launch my custom Cassini from Visual Studio.

Comment on this
Development
.net | visual studio | asp.net

When adding headers to a HttpWebRequest or HttpWebResponse, you may have come across the error “This header must be modified using the appropriate property.”  Some headers are restricted from simply setting via the headers collection.

[more Click to read more…]

Line 35: { Line 36: HttpWebRequest request = (HttpWebRequest)WebRequest.Create(target); 
Line 37: request.Headers.Add(context.Request.Headers); 
Line 38: using (StreamReader reader = new StreamReader(context.Request.InputStream)) 
Line 39: {

[ArgumentException: This header must be modified using the appropriate property. Parameter name: name] System.Net.WebHeaderCollection.ThrowOnRestrictedHeader(String headerName) +5370110 System.Net.WebHeaderCollection.Add(String name, String value) +32 System.Collections.Specialized.NameValueCollection.Add(NameValueCollection c) +108 Sfx.Web.Handlers.RequestProxy.ProcessRequest(HttpContext context) in C:\temp\RequestProxy.cs:37 System.Web.CallHandlerExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute() +181 System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean& completedSynchronously) +75

You can see above that copying the headers collection from one request into another is going to cause the problem.  The following is a list of request and response headers that must be set via properties instead of headers collection.  These properties will be translated to headers on the wire:

Comment on this
Development
.net