Yishai Galatzer's Blog

Rendering an image from an embedded Web Browser (C# WPF application)

yishai g. — Wed, 21 Mar 2012 00:08:25 GMT

How is all started

So this week I was working on an extension for WebMatrix, Luke Sampson of http://StudioStyle.es just integrate a cool piece of code from Matt MCElheny. The news is that the studiostyle.es website now supports converting the over 1,000 themes uploaded for Visual Studio 2010 into the WebMatrix format, and hence we automatically got a very large load of themes to choose from.

Still we aspired for an even better experience, currently the WebMatrix user will have to install the ColorThemeEditor extension, go to the site, find a theme, download it, import it, and so on. Just too many steps. So Luke and some other folks (thanks Justin Beckwith and Scott Hanselman) started chatting. Luke was super fast, two hours later he announced that there is an api to the site.

By hitting:

http://studiostyl.es/api/schemes.xml I could now get a live feed of all the themes available

and for each one he provided a preview, and a download link. So I was ready to write the update to my extension.

The preview came from the following style link http://studiostyl.es//schemes/son-of-obsidian/snippet

This returns an HTML page, that looks like this:

and I was planning to show one per item in a WPF list view. Unfortunately the web browser control is not too happy inside a WPF life (since it’s basically a thin wrapper around native window). So instead I decided to render the browser into a bitmap and then show it on the list. I Spent several hours playing around and searching for a solution online, and couldn’t find any valid solution for my case.

When I came back to work, I chatted with Mikhail Arkhipov and he has some old class that did something very similar.

What doesn’t work

The WPF WebBrowser control is really just a wrapper around the WinFrom WebBrowser control. So at first I thought I’ll load the page off the screen and render it. Well it turns out that if this control is not on the screen it will never actually render. I wasn’t inclined to add it to the view as a hack, but I tried anyways. Well turns out that rendering the image using RenderTargetBitmap doesn’t work either. I guess because it’s an activeX and not a true WPF control.

So what is the solution

First I used a WinForms WebBrowser, so instead of instantiating a System.Windows.Controls.WebBrowser I used System.Windows.Forms.WebBrowser

Things already start to look better because I got the browser to render without going on the screen. I still couldn’t figure out how to render the bitmap. This where mshtml came to help.

The browsers document can be cast into IViewObject like in the code below:

   1: var viewObject = wb.Document.DomDocument as IViewObject;

for more info: http://msdn.microsoft.com/en-us/library/windows/desktop/ms680763(v=vs.85).aspx

and now rendering can happen.

In my code I wasn’t hitting the server directly using Navigate and in order to do verify that I actually got the site data back rather than an error page I looked for a <pre tag that I knew Luke is always including in the response and is highly unlikely in an error page.

Of course I could have gotten an HttpWebRequest get the response and then feed the browser with the plain html, except that this page actually has some Jquery links, and it felt way more natural to let the browser deal with it. It’s really up to the implementer to pick what suits his application.

I’m attaching the full code below, here is some explanations on how it works and how to use it.

How to use it:

1. Add a reference to mshtml it’s going to appear in the COM section in VS2010

2. In your code instantiate a WebBrowserUtility utility object

3. Whenever you get a uri you want to render hookup to the WebBrowserImageReady event, and call Navigate with the Uri

   1: private WebBrowserUtility _browserUtility;

2:

   3: ...

4:

   5: _browserUtility = new WebBrowserUtility();

6:

   7: _browserUtility.WebBrowserImageReady += ImageReady;

8:

   9: _browserUtility.Navigate(PreviewUri);

4. The event will fire back after some time with the image on the eventargs, in my case if the html text did not include “<pre” it will return null.

5. In my case I use CroppedImage to remove the scrollbars and I just render larger than I need (see lines 41, 42), cheap and dirty tricks that works nicely in my case. It’s a bit more complex to remove the scrollbars, but there are plenty of blogs on how to achieve that.

A word of caution: The webbrowserutility might not call back on the event, so you might want to spin up a timer disconnect it and dispose it after a while.

That’s it you are ready to roll.

How it works:

Lines 37-43:

When you instantiate the utility a WinForms browser is generated, that is important for rendering off the screen. The WPF one simply never fires an event back when it’s ready in this case.

Line 45:

I made navigate a separate method to avoid timing issues in hooking up the WebBrowserImageReady event. It can only be called once! The browser is disposed after the first navigation. Of course this can be modified to make the class reusable and disposable.

Line 57+:

When the browser finishes downloading it fires document ready event, at that point I’m getting the Document.Text and doing a simple text search for a <pre (yes it could be better, in my case it’s a sufficient test).

I then create an image and “Cast” or QueryInterface really for the IViewObject. If I got it I’ll create graphics and Draw it on the bitmap (that’s the method signature defined below on line 132+).

Since this is a WPF app, I now convert it back to a WPF Image, and raise the event. If I failed in any way the event fires with a null image.

   1: using System;

   2: using System.Runtime.InteropServices;

   3: using System.Windows;

   4: using System.Windows.Controls;

   5: using System.Windows.Interop;

   6: using System.Windows.Media.Imaging;

   7: using mshtml;

8:

   9: using Forms = System.Windows.Forms;

  10: using Drawing = System.Drawing;

11:

  12: namespace ColorThemeManager

  13: {

  14:   internal class WebBrowserImageReadyEvengArgs : EventArgs

  15:   {

  16:     public BitmapSource Bms

  17:     {

  18:       get;

  19:       private set;

  20:     }

21:

  22:     public WebBrowserImageReadyEvengArgs(BitmapSource b)

  23:     {

  24:       Bms = b;

  25:     }

  26:   }

27:

  28:   internal class WebBrowserUtility : IDisposable

  29:   {

  30:     public Forms.WebBrowser WebBrowser { get; private set; }

31:

  32:     public BitmapSource BitmapSource { get; private set; }

33:

  34:     public event EventHandler<WebBrowserImageReadyEvengArgs>

  35:                                     WebBrowserImageReady = null;

36:

  37:     public WebBrowserUtility()

  38:     {

  39:       WebBrowser = new Forms.WebBrowser();

  40:       WebBrowser.DocumentCompleted += DocumentCompleted;

  41:       WebBrowser.Width = OnlineTheme.BrowserWidth;

  42:       WebBrowser.Height = OnlineTheme.BrowserHeight;

  43:     }

44:

  45:     public void Navigate(Uri url)

  46:     {

  47:       if (WebBrowser != null)

  48:       {

  49:         WebBrowser.Navigate(url);

  50:       }

  51:       else

  52:       {

  53:         throw new InvalidOperationException();

  54:       }

  55:     }

56:

  57:     private void DocumentCompleted

  58:         (object sender,

  59:          Forms.WebBrowserDocumentCompletedEventArgs e)

  60:     {

  61:       using (var wb = (Forms.WebBrowser)sender)

  62:       {

  63:         var text = wb.DocumentText ?? string.Empty;

  64:         bool validResult = text.Contains("<pre");

65:

  66:         if (validResult)

  67:         {

  68:           var pixelFormat = Drawing.Imaging.PixelFormat.Format24bppRgb;

69:

  70:           using (var bitmap = new Drawing.Bitmap(wb.Width,

  71:                                                  wb.Height,

  72:                                                  pixelFormat))

  73:           {

  74:             var viewObject = wb.Document.DomDocument as IViewObject;

75:

  76:             if (viewObject != null)

  77:             {

  78:               var sourceRect = new tagRECT();

  79:               sourceRect.left = 0;

  80:               sourceRect.top = 0;

  81:               sourceRect.right = wb.Width;

  82:               sourceRect.bottom = wb.Height;

83:

  84:               var targetRect = new tagRECT();

  85:               targetRect.left = 0;

  86:               targetRect.top = 0;

  87:               targetRect.right = wb.Width;

  88:               targetRect.bottom = wb.Height;

89:

  90:               using (var gr = Drawing.Graphics.FromImage(bitmap))

  91:               {

  92:                 IntPtr hdc = gr.GetHdc();

93:

  94:                 try

  95:                 {

  96:                   int hr = viewObject.Draw(1 /*DVASPECT_CONTENT*/,

  97:                                   (int)-1,

  98:                                   IntPtr.Zero,

  99:                                   IntPtr.Zero,

 100:                                   IntPtr.Zero,

 101:                                   hdc,

 102:                                   ref targetRect,

 103:                                   ref sourceRect,

 104:                                   IntPtr.Zero,

 105:                                   (uint)0);

 106:                 }

 107:                 finally

 108:                 {

 109:                   gr.ReleaseHdc();

 110:                 }

 111:               }

 112:

 113:               BitmapSource = Imaging.CreateBitmapSourceFromHBitmap(

 114:                                   bitmap.GetHbitmap(),

 115:                                   IntPtr.Zero,

 116:                                   Int32Rect.Empty,

 117:                                   BitmapSizeOptions.FromEmptyOptions());

 118:             }

 119:           }

 120:         }

 121:       }

 122:

 123:       WebBrowser = null;

 124:

 125:       if (WebBrowserImageReady != null)

 126:       {

 127:         WebBrowserImageReady(this,

 128:             new WebBrowserImageReadyEvengArgs(BitmapSource));

 129:       }

 130:     }

 131:

 132:     [ComVisible(true), ComImport()]

 133:     [GuidAttribute("0000010d-0000-0000-C000-000000000046")]

 134:     [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]

 135:     private interface IViewObject

 136:     {

 137:       [return: MarshalAs(UnmanagedType.I4)]

 138:       [PreserveSig]

 139:       int Draw(

 140:         ////tagDVASPECT

 141:           [MarshalAs(UnmanagedType.U4)] UInt32 dwDrawAspect,

 142:           int lindex,

 143:           IntPtr pvAspect,

 144:           [In] IntPtr ptd,

 145:         //// [MarshalAs(UnmanagedType.Struct)] ref DVTARGETDEVICE ptd,

 146:           IntPtr hdcTargetDev, IntPtr hdcDraw,

 147:           [MarshalAs(UnmanagedType.Struct)] ref tagRECT lprcBounds,

 148:           [MarshalAs(UnmanagedType.Struct)] ref tagRECT lprcWBounds,

 149:           IntPtr pfnContinue,

 150:           [MarshalAs(UnmanagedType.U4)] UInt32 dwContinue);

 151:     }

 152:

 153:     public void Dispose()

 154:     {

 155:       if (WebBrowser != null)

 156:       {

 157:         WebBrowser.Dispose();

 158:         WebBrowser = null;

 159:       }

 160:     }

 161:   }

 162: }

And this it how it looks at the end

Come give it a spin

-> Install webmatrix from here:

http://www.microsoft.com/web/webmatrix/betafeatures.aspx

-> Open any site

-> Click on the gallery icon:

-> Install ColorThemeManager

-> Switch to to the Files workspace, open any file

-> Click on the Theme button

-> Notice the new fun colors in your editor

Unit tests should not Debug Assert

yishai g. — Thu, 31 Mar 2011 18:00:52 GMT

Preface

When we write unit tests we try to cover all edge cases, not just run through the cases that work. That means that in many cases the product code will assert before throwing an exception.

We have to separate cases here

1. We expected the assert and want to ignore it

2. We did not expect an assert, and in this case we don’t want to get the unit test stalled, but rather simply fail.

In this blog I’m suggesting a rather simple approach for dealing with this issue that will only require changes to the unit tests for case 1 above. The approach is relevant for MsTest based unit tests, although it can apply to other frameworks as well with some minor modifications.

Background

When we call Debug.Assert, Debug.Fail, Trace.WriteLine or similar methods, the resultant messages are routed to the static list of trace listeners (System.Diagnostics.Trace.Listeners). One of these listeners is the DefaultTraceListener that among other things pops up the Assert Dialog in debug mode.

For more information:

http://msdn.microsoft.com/en-us/library/system.diagnostics.tracelistener.aspx

http://msdn.microsoft.com/en-us/library/system.diagnostics.defaulttracelistener.aspx

Obviously when we run unit tests we don’t want this dialog to come up, because it will stall the overall run. If we are running hundreds of unit tests and a few of them pop asserts, we will be sitting for a long time waiting for results to come back (or interactively keep clicking ignore).

Thankfully we can modify this static list on run time to suit our needs.

A Basic solution

   1: TraceListener removeListener = null;

   2: foreach (TraceListener listener in Debug.Listeners)

   3: {

   4:     if (listener is DefaultTraceListener)

   5:     {

   6:         removeListener = listener;

   7:         break;

   8:     }

   9: }

  10: Debug.Listeners.Remove(removeListener);

In this solution we simply iterate through the list of listeners (Debug.Listeners) and find the DefaultTraceListener and remove it.

Note that I’m not assuming it’s the first listener, since I don’t want to make assumptions that this list was never manipulated.

This code can be added before encountering an assert in the body of the test, but it poses a few limitations

1. It will remove the listener for the tests to follow

2. You have to put it in any test that fires asserts because there is no guarantee in what order or even if all tests are run

Fortunately we can make this a more global approach

   1: [TestClass]

   2: public class UnitTestInitializer

   3: {

   4:     private static bool _initialized = false;

   5:     private static object _lock = new object();

6:

   7:     [AssemblyInitialize]

   8:     public static void Initialize(TestContext context)

   9:     {

  10:         lock (_lock)

  11:         {

  12:             if (_initialized)

  13:             {

  14:                 return;

  15:             }

16:

  17:             TraceListener removeListener = null;

  18:             foreach (TraceListener listener in Debug.Listeners)

  19:             {

  20:                 if (listener is DefaultTraceListener)

  21:                 {

  22:                     removeListener = listener;

  23:                     break;

  24:                 }

  25:             }

  26:             Debug.Listeners.Remove(removeListener);

  27:         }

  28:     }

  29: }

In this approach I create another test class with the sole purpose of initializing the complete test assembly. It will now run for every test regardless if that test is run on it’s own or as part of a group run.

Note that the Initialize method is decorated with [AssemblyInitialize] and is within a [TestClass]

Still with this approach asserts will now be ignored, and the only way to see that they got fired is the Trace section of the test result, which will typically be ignored if the test passed.

Fail on assert (well sometimes…)

Most of the time we want asserts to fail the tests but not always, sometimes when testing edge cases we do expect the product to assert, and we don’t want the test to fail in these cases.

So the following FailOnAssert class got created, and we add it to the DebugListerner list (this line goes below line 26 in the above code snippet)

   1: Debug.Listeners.Add(FailOnAssert.GetInstance());

FailOnAssert

   1: public class FailOnAssert : TraceListener

   2: {

   3:     [ThreadStatic]

   4:     private static bool _disable;

5:

   6:     private static FailOnAssert _instance = null;

7:

   8:     private static object _lock = new object();

9:

  10:     private FailOnAssert()

  11:     {

12:

  13:     }

14:

  15:     public static FailOnAssert GetInstance()

  16:     {

  17:         if (_instance != null)

  18:         {

  19:             return _instance;

  20:         }

21:

  22:         lock (_lock)

  23:         {

  24:             if (_instance == null)

  25:             {

  26:                 _instance = new FailOnAssert();

  27:             }

  28:         }

  29:         return _instance;

  30:     }

31:

  32:     public static bool Disable

  33:     {

  34:         get

  35:         {

  36:             return _disable;

  37:         }

  38:         set

  39:         {

  40:             _disable = value;

  41:         }

  42:     }

43:

  44:     public override void Fail(string message)

  45:     {

  46:         if (!Disable)

  47:         {

  48:             Assert.Fail("Product raised an assert: " + message);

  49:         }

  50:     }

51:

  52:     public override void Fail(string message, string detailMessage)

  53:     {

  54:         if (!Disable)

  55:         {

  56:             Assert.Fail("Product raised an assert: " + message + "\n" + detailMessage);

  57:         }

  58:     }

59:

  60:     public override void Write(string message)

  61:     {

  62:     }

63:

  64:     public override void WriteLine(string message)

  65:     {

  66:     }

  67: }

Fail on assert is a TraceListener, in order to do that I derived it from a TraceListener. And overridden the Fail, Write and WriteLine methods. Since the calls to Debug.Assert and Debug.Fail ultimately turn into calls to Fail, they call Assert.Fail and stop the test.

Note that Write and WriteLine are abstract in the TraceListener base class and have to be overridden although they don’t serve any purpose in this case.

The Disable property is used to temporarily allow asserts to fire without failing the tests, the _disable member is decorated with the [ThreadStatic] attribute since we don't want a test on one thread inadvertently changing this behavior for another thread.

The messages logged by any product trace calls are logged by the unit test framework listeners and hence I don't need to implement any logging in my code.

Using the Disabled Property:

   1: try

   2: {

   3:     FailOnAssert.Disabled = true;

   4:     MyTestAction();

   5: }

   6: finally

   7: {

   8:     FailOnAssert.Disabled = false;

   9: }

Conclusion

Unexpected asserts should not be ignored or stall the tests, and should trigger a test failure.

By simply adding this code to any existing unit tests project we where able to catch all asserts being fired without having to edit file by file, the code was generic enough to simply drop two files into each assembly and be mostly done.

Compatibility Checking in WebMatrix - When the checker reports failures

yishai g. — Fri, 04 Feb 2011 20:10:12 GMT

Intro

In WebMatrix V1 we released a new feature called Publish Compatibility. This feature inspects your local application for dependencies and requirements. It will then runs a set of tests against your remote website. The idea is to identify any potential issues with your remote internet server missing components that are must have for your site to run.

For example, if your site is using a database (say Microsoft SQL server or MySQL) the remote server must support accessing these databases or else your site will simply fail after publishing.

Ben Byrd and Bilal Aslam published a great article taking you through this feature:

http://blogs.iis.net/bilalaslam/archive/2010/11/12/new-feature-in-webmatrix-beta-3-publish-compatibility.aspx

Server

If you are using shared hosting from the spotlight category, typically it means that the server already supports the applications from the WebMatrix gallery. If you setup a server yourself, you will have to ensure you have all the dependencies in place. Here is a set of articles by Bilal Aslam and Simon Tan on how to setup a server, please note that the target audience for this is a hosting provider setting up production servers.

http://learn.iis.net/page.aspx/951/install-server-components/

http://learn.iis.net/page.aspx/984/configure-web-deploy/

http://learn.iis.net/page.aspx/952/validate-your-server-configuration/

How it works

Compatibility checker works in two ways, the first one used for databases and ASP.NET version is using Web Deploy. Web Deploy tries to connect to the databases on your remote and also adjusts your ASP.NET version to match your site’s preferences (from 2.0 to 4.0 or vice versa).

These tests will succeed if Web Deploy can access your remote database, which means either Microsoft SQL Server or MySQL is installed and configured correctly on the remote server.

For the ASP.NET version, the compatibility checker will run a piece of code on the remote server (Web Deploy provider) and first check if your application pool matches the one on the remote site. If they don’t it will attempt to adjust them.

The second way is by publishing test pages to a secure location on your site. If publishing of these files succeed, WebMatrix then tries to hit (or request) these pages. For each dependency WebMatrix tries to verify that the page is behaving as expected thus reflecting that the dependencies are available on the remote site.

Just to clarify, we do not put any user info in these pages, and they will not appear to the standard user browsing your site. Further more we delete them as soon as the compatibility check is done, so within a few seconds of starting the tests, they are gone from the server.

Why does the test return Unavailable

Most commonly it simply means the remote server does not support all the dependencies your site needs. But there are a few other cases I wanted to highlight, they mostly revolve around the Simple HTML Page test.

This test does a very simple task, it uploads a hello world html page then tries to retrieve it. So how can such a simple test fail? The Not Available result will only come up if we successfully managed to upload the files.

Well this can mean one of two things, the files got uploaded but not where you expected them to go. Or the files where uploaded to the right spot, but for some reason your remote site is redirecting the request away from them.

Mismatch

The most common reason is that your destination URL is pointing to a different location from where your files got published to. If you use the Web Deploy protocol verify that the site name and server combination match the destination URL. In FTP you need to look at the server and the site path.

Redirection

We also found that if there are rewrite rules in the root of the site, the compatibility checker will not pick up the changes. This case will typically happen only after you published something to the site and now you are trying the compatibility again. Since we are trying to find static files, we cannot get them anymore and report failure. Typically in this case all the request based tests will fail (Simple HTML, PHP, PHP Drivers, etc.)

Here is a solution for this issue:

Find the following file it’s going to be in your program files (or program files(X86) if you run a 64bit OS).

Microsoft WebMatrix\config\Compatibility\Web.Config

Back the current one you have.

Open it in an editor and replace the content with the following:

<?xml version="1.0"?>

<system.webServer>

<rules>

</rules>

</rewrite>

</system.webServer>

</configuration>

This will disable all URL rewrite rules for the subfolder where the files are getting published to and will not affect the rest of your site.

What if this still doesn’t resolve my issues

Here is a way to get more information, what this will turn on tracing for Publish Compatibility. Then feel free to post the trace to the WebMatrix forums at http://forums.iis.net

Word of caution, make sure you backup the files and make the changes accurately or WebMatrix might stop working.

Close all instances of WebMatrix

Go to the Program Files/Microsoft WebMatrix folder.

Find the file called: webmatrix.exe.config

Back it up

Open the file in a text editor (preferably an XML editor)

The file should start something like:

<configuration>
  <startup useLegacyV2RuntimeActivationPolicy="true">
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"  />
  </startup>
  <runtime>

…

Right after the configuration tag add the following

<system.diagnostics>

<source name="PublishCompatibility"

switchName="sourceSwitch"

switchType="System.Diagnostics.SourceSwitch">

<add name="FileWriter"

type="System.Diagnostics.TextWriterTraceListener"

initializeData="C:\FilePathtoYourtace.log">

<filter type="System.Diagnostics.EventTypeFilter"

initializeData="Verbose"/>

</add>

</listeners>

</source>

</sources>

</system.diagnostics>

Make sure you replace the highlighted text with where you want your files to get stored.

Now run compatibility checker again and send us the results from that file.

Don’t forget to restore the configuration file back after you are done.

for more info: http://msdn.microsoft.com/en-us/library/system.diagnostics.textwritertracelistener.aspx

Summary

Publish Compatibility is a powerful tool to help you verify that your live site will work as expected. When publish compatibility is reporting an error, most likely there is either a limitation on the remote server or your Publish Settings are not correct.

If you encounter issues outside of what is described above I want to encourage you to go to the forums and tell us about it.

Replacing the built-in Basic Authentication Module to support non-English characters in a HttpWebRequest

yishai g. — Wed, 24 Nov 2010 22:53:01 GMT

A few weeks ago I was trying to deploy a site using Web Deploy and authenticate using a non-English user name. The operation would succeed on some computers but will fail on others. Since I was using the Web Deploy API, I debugged into the .NET framework code and found that the framework encodes the user name using the default code page. That made it work for some computers but not others, depending on what the default code page was on the local computer and the remote server.

Sounds confusing? Let me start from the bottom up.

Basic Authentication

When Web Deploy connects to the remote server it can use basic authentication to authenticate with the server over HTTP/S. That’s the method we chose to authenticate with and since we use SSL it’s reasonably safe to use.

According to RFC 2617 in order to use a basic authentication you have to add something that looks like the following header:

Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==

The highlighted goop of data is simply a base64encoding of: ”Aladdin:open sesame”, where “Aladdin” is the user name and “open sesame” is the password.

Nicely enough the HttpWebRequest class typically takes care of creating this header for us.

Encoding

When HttpWebReqeust creates the header for us it is using what’s called a Default Code Page Encoding, each 16 bit char in .NET is translated to an 8bit byte. If all the characters in the user name (or password for that matter) are recognized by the default code page then that operation succeeds.

But wait, let us say I typed the user name in German. If my local OS language is say German and my server OS language is English, the local translation of German chars will succeed, but when the credentials will arrive at the remote server they will fail to translate back.

If my local OS is English I will not be able to translate the chars at all, and will fail creating the HttpWebRequest.

Fortunately IIS7 supports authentication using the UTF-8 Encoding scheme, with UTF-8 we can encode without relying on the local OS code page.

Writing the new Header

So I thought that since we have direct access to the headers, we can just manually write a header and encode it using UTF-8. But now we have to deal with all sorts of scenarios where we will have to rewrite the headers and make sure they do not get overwritten by the HttpWebRequest code.

Fortunately .NET deals with that issue as well in an elegant way. The AuthenticationManager class exposes the Unregister and register method where we can register a class that will create the authentication headers when needed.

The AuthenticationManager being static (much like the better known sibling ServicePointManager) means that it cannot be directly used in the Web Deploy API level, and has to be part of the end user application.

First you need to create a class that will implement IAuthenticationModule. We will get to what it entails soon.

Somewhere in your app startup code you will unregister the default “Basic Authentication” module:

   1: AuthenticationManager.Unregister(“Basic”);

Then register the new class you just created:

   1: AuthenticationManager.Register(_myAuthenticationModule);

The key to the IAuthenticationModule is the creation of the credentials; we need to support this method on both the PreAuthenticate and Authenticate interfaces.

First we extract the NetworkCredential

   1: NetworkCredential nc = credentials.GetCredential(httpWebRequest.RequestUri, “Basic”);

Then create the basic ticket in plain text:

   1: string domain = nc.Domain;

2:

   3: string basicTicket = (!String.IsNullOrEmpty(domain) ? (domain + "\\") : "") +

   4:                      nc.UserName + ":" + nc.Password;

Now we encode it in UTF8 (this is the key to this whole change).

   1: byte[] bytes = Encoding.UTF8.GetBytes(basicTicket);

And encode it to a base64 string

   1: string header = AuthenticationTypeName + " " + Convert.ToBase64String(bytes);

2:

   3: return new Authorization(header, true);

4:

Summary and more information

Although there are lots of details in this solution, at the end of the day all the end user needs to do it compile the example class below into the existing application without modifying any other code. I thought that was kind of a neat solution.

This code will work for any framework that uses HttpWebRequest—not just Web Deploy—assuming the server side code can work with an UTF-8 encoded string.

I attached a full listing of an Authentication module, albeit a bit simplified for clarity, use at your own risk.

The topics covered in this blog are further expanded on MSDN and RFCs

RFC2617 – HTTP Authentication: Basic and Digest Access Authentication

RFC4648 – The Base16, Base32, and Base64 Data Encodings

Encoding in .NET - http://msdn.microsoft.com/en-us/library/system.text.encoding.aspx

Base64 in .NET - http://msdn.microsoft.com/en-us/library/dhx0d524.aspx

IAuthenticationModule - http://msdn.microsoft.com/en-us/library/system.net.iauthenticationmodule.aspx

A simplified full listing implementation of the AuthenticationModule

   1: using System;

   2: using System.Net;

   3: using System.Text;

4:

   5: namespace YourAppsNamespace

   6: {

   7:     internal class DeploymentAuthenticationModule : IAuthenticationModule {

8:

   9:         private const string AuthenticationTypeName = "Basic";

  10:         private static DeploymentAuthenticationModule _module = null;

  11:         private static object _lock = new object();

12:

  13:         public static void InstantiateIfNeeded()

  14:         {

  15:             lock (_lock)

  16:             {

  17:                 if (_module == null)

  18:                 {

  19:                     _module = new DeploymentAuthenticationModule();

  20:                 }

  21:             }

  22:         }

23:

  24:         private DeploymentAuthenticationModule()

  25:         {

  26:             AuthenticationManager.Unregister(AuthenticationTypeName);

  27:             AuthenticationManager.Register(this);

  28:         }

29:

  30:         string IAuthenticationModule.AuthenticationType {

  31:             get { return AuthenticationTypeName; }

  32:         }

33:

  34:         bool IAuthenticationModule.CanPreAuthenticate {

  35:             get { return true; }

  36:         }

37:

  38:         Authorization IAuthenticationModule.Authenticate(string challenge, WebRequest request, ICredentials credentials) {

  39:             HttpWebRequest httpWebRequest = request as HttpWebRequest;

  40:             if (httpWebRequest == null) {

  41:                 return null;

  42:             }

43:

  44:             // Verify that the challenge is a Basic Challenge

  45:             if (challenge == null || !challenge.StartsWith(AuthenticationTypeName, StringComparison.OrdinalIgnoreCase)) {

  46:                 return null;

  47:             }

48:

  49:             return Authenticate(httpWebRequest, credentials);

  50:         }

51:

  52:         Authorization IAuthenticationModule.PreAuthenticate(WebRequest request, ICredentials credentials) {

  53:             HttpWebRequest httpWebRequest = request as HttpWebRequest;

54:

  55:             if (httpWebRequest == null) {

  56:                 return null;

  57:             }

58:

  59:             return Authenticate(httpWebRequest, credentials);

  60:         }

61:

  62:         private Authorization Authenticate(HttpWebRequest httpWebRequest, ICredentials credentials) {

  63:             if (credentials == null) {

  64:                 return null;

  65:             }

66:

  67:             // Get the username and password from the credentials

  68:             NetworkCredential nc = credentials.GetCredential(httpWebRequest.RequestUri, AuthenticationTypeName);

  69:             if (nc == null) {

  70:                 return null;

  71:             }

72:

  73:             ICredentialPolicy policy = AuthenticationManager.CredentialPolicy;

  74:             if (policy != null && !policy.ShouldSendCredential(httpWebRequest.RequestUri, httpWebRequest, nc, this)) {

  75:                 return null;

  76:             }

77:

  78:             string domain = nc.Domain;

79:

  80:             string basicTicket = (!String.IsNullOrEmpty(domain) ? (domain + "\\") : "") + nc.UserName + ":" + nc.Password;

  81:             byte[] bytes = Encoding.UTF8.GetBytes(basicTicket);

82:

  83:             string header = AuthenticationTypeName + " " + Convert.ToBase64String(bytes);

  84:             return new Authorization(header, true);

  85:         }

  86:     }

  87: }