私事ですが、この間の週末は高円寺の阿波踊りに「マイ���ロソフト連」として参加させていただきました。“Windows 7”  を掛け声に踊ったんですけど、腕も足も痛いし、汗は目に入るしで大変でした。最後まで頑張れたのは、沿道のみなさんから「マイクロソフトぉ～頑張れ～！」「せぶんせぶんせぶん～」と温かい声援をかけていただいたおかげです。お祭りを通じて、地域のみなさんとの距離がぐっと近くなる感じが、とっても良かったです♪ さて、皆さまのこの夏の思い出は何でしたか？

今日は、ずーっと書きたいなと思っていたトピック、ネットワークについて書こうと思います。Windows のネットワークに含まれるトピックは沢山あります。なので、その中でドライバーだけを取ってみても……やっぱり沢山あります。私が、初めて Windows の ネットワークドライバーの世界に触れた時、ドライバーの名称だけでも様々なものがあると感じました。例えば、ミニポートドライバー・NICドライバー・LANドライバー、ネットワーク フィルタードライバー、中間層ドライバー、TDI ドライバー、プロトコル ドライバー、…………などなど、たくさんありますが、少しずつお伝えできればいいなと思っています。

今日はまず、「NDIS ドライバー」のお話。

この Blog を書くにあたって、Windows Internals 5th Edition を参照したところ、NDISライブラリー含め、NDIS スタック上で動作するドライバーのことをまとめて「NDIS ドライバー」と称していました。このBlogでもそう呼ばせてもらおうと思います。ちなみにですが、NDISと書いて、通常「エヌディス」と読みますよ。

●NDIS ライブラリー (Ndis.sys)

まず、Windows 上のネットワークドライバーを理解する上で、大きなポイントとなるのが NDISです。NDIS とは、Network Driver Interface Specification の略で、1989年に3Comとマイクロソフトによって共同で開発された、読んで字の如く、ネットワーク ドライバーにおけるインターフェースの仕様です。Windows 上では、NDIS ライブラリー（※ 仕様自体と分けるため NDIS ライブラリーと明記しましたが、以降 NDIS と称します）として実装されていて、実際のファイルは Drivers フォルダーの下にあります (\%SystemRoot%\System32\Drivers\Ndis.sys)。

NDISでは OSI参照モデル を忠実に踏襲している訳ではありませんが、ネットワーク上での役割を大まかに理解してもらうためにあえて言いますと、NDIS は OSI参照モデルで言うところの データリンク レイヤー（の一部）の範囲に位置しています。

もっと具体的な役割としては、NDIS ドライバーが使用する API 群 (NDIS ライブラリー関数) を提供するだけでなく、NDIS ドライバーの動作する実行環境をも提供しています。この「実行環境を提供している」というのは、大ざっぱな言い方をすれば、NDIS ドライバーは NDIS ライブラリー以外のドライバーと直接やり取りすることはなく、逆に言うと NDIS ライブラリーとのみやり取りすればよい、ということです。そのため、通常の WDMのドライバーが行うような IRP のハンドリングなどは直接行いませんし、他のドライバーから IoCallDriver などで呼び出されることも原則ありません。（独自のプロトコルを実装している場合は除きます）

現在 Window 7 ならびに Windows Server 2008 R2 でサポートされている NDIS のバージョンは 6.2 です。NDIS 5.x から NDIS 6.x へのメジャーアップデートは、Windows Vista (NDIS 6.0) のリリースのタイミングでされました。NDIS 6.x は、従来の NDIS 5.x と比べて、状態遷移の管理方法や、転送の基本となるパケットの構造などに様々な変更がなされ、動的かつ効率的に処理を行うことができるようになっています。なお、NDIS 6.x は下位互換を持っていますので、NDIS 5.x として適切に実装されたドライバーであれば Windows Vista や Windows 7 などの NDIS 6.x の環境下でも動作します。ですが、実際のところ NDIS 5.x がラッピングされて NDIS 6.x 環境下で動作しているため、パフォーマンス面では効率が落ちてしまいます。そのため、これから新規に実装を行う場合は当然のこと、NDIS5.x 系のドライバーも、最新の NDIS バージョンへ移行することをお勧めします。

●その他のNDIS ドライバー

上記の NDIS以外に、どんなものがあるのかと言いますと、ミニポート ドライバー、フィルタードライバー(LWD: lightweight filter driver)、中間層 (IM: intermediate) ドライバー、プロトコル ドライバーなどの種類があります。実際に WDK にもサンプルが沢山用意されていますので、是非のぞいてみてほしいと思います (%BaseDir%\src\network\ndis）。

●ミニポート ドライバー：

LAN ドライバー、NIC ドライバー、様々な呼び方があるようですが、ネットワークアダプターの実質的な機能を提供するドライバーです。NDIS.sys と共に HW に最も近いレイヤーで動作するドライバーです。通常、Net クラスとして登録されます。

●フィルター ドライバー ：

ミニポート ドライバー と プロトコル ドライバーの間に位置し、その特性を生かしてネットワークスタック上のデータをフィルタリングすることができます。用途に応じてクラスは様々ですが、NetTrans クラス、NetService クラスなどで登録され、中間層ドライバーに関しては、Net クラスのインターフェースも持ちます（後述）。

●プロトコル ドライバー ：

ミニポート ドライバー、フィルター ドライバーより上位に位置するため、NDIS ドライバーの中でもよりアプリケーションに近いレイヤーで動作するドライバーです。アプリケーションと連動した独自プロトコルを実装することも可能です。こちらも用途に応じてクラスは様々ですが、NetTrans クラス、NetService クラスとして登録されることが多いようです。

フィルター ドライバーについて、ちょっと補足をします。一口にフィルタードライバーと言っても、現在の Windows では、様々な様相を呈しています。まず、代表的なフィルター ドライバーとして、LWD: lightweight filter driver があります。LWD だけでなく、中間層 (IM: intermediate) ドライバーもフィルタードライバーとみなされる場合もあります。中間層 (IM) ドライバーは、他とは特に異なっており、ミニポートドライバーとしてのインターフェース（“Miniport Edge”）と、プロトコルドライバーとしてのインターフェース（“Protocol Edge”）の両方を持っているという特徴があります。ミニポート ドライバー と プロトコル ドライバーの間に位置するため、中間層・Intermediate の名前を持つわけです。その特性ゆえ、フィルター ドライバーとして実装されることも多かったのですが、必ずしもいわゆるパケットなどを監視する “ネットワーク フィルター” の機能を持つとは限らず、仮想のネットワークアダプターとして実装することも可能です。余談ですが、中間層ドライバーは “Miniport Edge” と “Protocol Edge” それぞれに INF ファイルがあったりします。（INFファイルって1つしかないという先入観があったためか、私は最初「へえ～」と思いました。）INF は必ずしも 2 つに分ける必要はないですが、皆さん、普通は分けて書いているようですね。

 また NDIS ドライバー以外にも、Windows Filtering Platform(WFP) というフィルタリング専用の仕組みや、Winsock Kernel (WSK) のインターフェースも Vista から新たにサポートされています。この WFP の仕組みを利用してカーネルモードで動作するドライバーに、Callout ドライバーがあります。これまでにTDI クライアント ドライバーで実装されていたモデルに代わり、WSK のインターフェースを使用した実装へと更新することが推奨されています。

さて、NDIS ドライバーの住み分けが大体頭に入ったところで、手元の環境で実際に見てみたいと思います。

私の手元の環境では、コントロールパネルから確認したところ、２つのネットワーク接続が有効になっています。実は、このマシンには、ネットワークアダプターは 1 枚しか刺さっていません。左側の Local Area Connection が実際のネットワークアダプターに対して作られている接続で、右側の Local Area Connection 2 は、仮想的なネットワークアダプターに対する接続です。WDK の MUX サンプルがインストールされていて、MUX は中間層ドライバーのサンプルです。

実際に、NDISにシンボルを合わせて、Debugger でそれぞれのインスタンスを見てみましょう。

OS: Windows 7 Enterprise (7600.16385) x86 バージョン

Symbol: http://msdl.microsoft.com/download/symbols

※パブリック シンボル サーバーを使用しています

ネットワーク アダプターの実質的な機能を提供するドライバーはミニポートドライバーです。

ミニポートドライバー情報の一覧をダンプします。

ネットワークアダプターの個別の情報をダンプするには、リンクをクリックするか、アドレスを指定してダンプします。

まずは、Broadcom NetXtreme 57xx Gigabit Controllerから。

同じように、MUX の仮想ネットワーク アダプターのほうもダンプしてみます。

MUX.sys は中間層ドライバーですので、プロトコルドライバーとしてのインターフェースも持っているはずです。

プロトコルドライバー情報の一覧をダンプします。

MUXPというプロトコルが、Broadcom NetXtreme 57xx Gigabit Controllerに対して関連付けられていますね。

ところで、Broadcom NetXtreme 57xx Gigabit Controllerのミニポート情報をもう一度見てください。

BINGINGSの Open List に MUXPの名前があるのにお気づきでしょうか。

つまり、ミニポート側から見ても、MUXP プロトコルに関連付けられていることが分かります。

BIND の話が出たところで、時間がなくなってしまいましたので今日はここらへんでおしまいにしようと思います。

あんまり深く突っ込んだ内容ではなかったかもしれませんが、NDIS ドライバーの種類と雰囲気については、つかんでいただけましたでしょうか？

最後に、参考になりそうなサイトを【補足～リンク集～】に集めてみましたのでお時間のある時にでも見てみてください。

BIND の話は次回の私の投稿でできればな、と思っております。

ではまた！

【補足～リンク集～】

◎WHDC – ネットワーク

各種ホワイトペーパーや様々なサイトへのリンクが集められています。是非、チェックしてみてください。

◎The NDIS blog

上記WHDCのネットワークのページの関連ブログにもリンクが張られています。本文中に記載した WinDBG の出力についてより詳しく知りたい方は是非こちらも参考にしてみてください。

● [Re]Introducing NDISKD ~Over a decade of making NDIS developers dangerous~

● Getting started with NDISKD ~Part 1 of a beginner’s guide to debugging with NDISKD~

● NDISKD and !miniport ~The second installment of a beginner’s guide to debugging with NDISKD~

◎NDIS Developer’s Reference

Microsoft のサイトではありませんが、NDIS ドライバー開発に関するノウハウが沢山詰まっています！

◎Network Devices

MSDNドキュメントで情報をお探しの場合は、NDIS 6.x と NDIS 5.x でドキュメントの構成を分けていますので、注意してください。

Creating the Silverlight App and Web Service – Peter B.

We originally set out to create a Silverlight Application that would display uploaded Windows Experience Index (WEI) Scores via a Web Service and Desktop Application. At the time, we created the application in Silverlight 3 and used a WCF Service to integrate with not only the desktop application but also the Silverlight application. Since we weren’t sure exactly where the WCF Service was being hosted in relation to the Web Site, one of the things we did was make it so the location of the WCF Service can be fairly easily changed. We ended up going with Silverlight Parameters to pass in the location of the WCF Service. Doing this was fairly easy, but it took some set up. The first step involved modifying App.xaml.cs to the following:

private void Application_Startup(object sender, StartupEventArgs e) { //Insert InitParams into Global Resources foreach (string key in e.InitParams.Keys) { this.Resources.Add(key, e.InitParams[key]); } this.RootVisual = new MainPage(); }

Once this was done, we then had to modify the code behind for the main Silverlight app in MainPage.xaml.cs, like so:

WindowsExperienceServiceClient serviceClient; public MainPage() { InitializeComponent(); if (App.Current.Resources.Contains("WCFServiceLocation") && !String.IsNullOrEmpty(App.Current.Resources["WCFServiceLocation"] as string)) { EndpointAddress endpointAddress = new EndpointAddress( App.Current.Resources["WCFServiceLocation"].ToString()); serviceClient = new WindowsExperienceServiceClient( "CustomBinding_IWindowsExperienceService", endpointAddress); } else { serviceClient = new WindowsExperienceServiceClient(); } myDelay.Duration = TimeSpan.FromMilliseconds(2000); myDelay.Completed += new EventHandler(myDelayCompleted); myDelay.Begin(); this.Loaded += new RoutedEventHandler(MainPage_Loaded); }

In the above example, I checked for the parameter, and finding that it existed I changed the Endpoint Address of the WCF Service (without an existing parameter, it uses the default address). After this was complete, we had to pass in a location similar to the following in the Default.aspx page’s object tag for the Silverlight control:

<param name="initparams" value="WCFServiceLocation=http://<%=Request.Url.Host %>:8080/windowsexperienceservice.svc" />

This made changing the location of the WCF Service much easier, allowing the flexibility we later needed.

Within the WCF Service, we separated our code using a three layered approach utilizing separate folders for each layer “DataAccessLayer”, “BusinessLogicLayer”, and “BusinessEntities”. Within the BusinessEntities folder, we had the base classes containing each business entity. As an example, we had the WindowsAssessment class, which contained all of the properties of the data sent from the Desktop Application to the WCF Service, including scores. Below, you can see part of what this looked like:

[DataContract] public class WindowsAssessment { public Guid? WindowsAssessmentID { get; set; } [DataMember] public decimal? SystemScore { get; set; } [DataMember] public decimal? AverageScore { get; set; } [DataMember] public decimal? MemoryScore { get; set; } [DataMember] public decimal? CpuScore { get; set; } [DataMember] public decimal? CpuSubAggScore { get; set; } [DataMember] public decimal? VideoEncodeScore { get; set; } /* additional properties... */ }

You’ll notice above that [DataContract] and [DataMember] was set above the class and properties so that it could be used as part of the WCF Service.

Within the DataAccessLayer folder, we utilized Linq2Sql. We simply created a dbml file, and brought over the few assets we created in the database by dragging and dropping the tables from the Data Source into the diagram. Then, within the WindowsAssessment.cs file of the Data Access Layer, we created methods that used Linq2Sql for our basic CRUD, taking advantage of Linq to easily create paging that we can search, filter, and orderby. Finally, within the Business Logic Layer, we utilized the Business Entities and created different methods that called the DAL and also took advantage of HttpRuntime.Cache.

Once all of the layers were complete, the Desktop and Silverlight Application were free to communicate back and forth, allowing the Desktop App to send a score and the Silverlight App to display it.

Upgrading to Silverlight 4 and Azure

Unfortunately, after we completed all of this, Silverlight 4 released. We quickly moved to upgrade to Silverlight 4 and, while we were at it, also modify the app to utilize Windows Azure.

One of the first things I encountered was that the WCF Service was not going to be within the Web Site anymore. Azure has roles in which you create for your project. In this particular instance I needed 2 web roles, one for the website, one for the WCF. In the end my Solution looked like the following:

Working with WCF as a WCF Role, I noticed that there were a few known issues, all of which were documented here: http://code.msdn.microsoft.com/wcfazure/Wiki/View.aspx?title=KnownIssues&referringTitle=Home. Luckily, with another developer’s help, we were able to pinpoint some of the issues and once we addressed them, we really didn’t have much more to worry about when working with WCF.

The next hurdle was moving over the database. The easiest way to do this is to use the tool, SQL Azure Migration Wizard, which can be found on CodePlex at http://sqlazuremw.codeplex.com/.

Creating the Desktop Experience – Peter J

I was tasked with creating a set of applications for showcasing user’s Windows Experience Index (WEI) scores. The set of applications included a desktop application created using Windows Presentation Foundation (WPF) for retrieving the scores and other system data, and a web site using Silverlight for displaying the information.

I needed to create the desktop application. Accordingly, there were some initial pre-requisites and other considerations we had to deal with:

• Limiting the desktop application to only run in Windows 7
• Determining where the relevant WEI data is stored in the system
• Retrieving the relevant information for all areas
• Remote Service connectivity—in this case we used a WCF service
• Not forcing the user to install/unzip anything (just download and run)

After scouring the web, I found a site (http://www.codeguru.com/cpp/w-p/system/systeminformation/article.php/c8973) with just the information I needed:

/// <summary> /// Determines if the current version of windows is valid (Vista, 7, Server 2008) /// </summary> /// <returns></returns> public static bool IsValidWindowsVersion() { System.OperatingSystem osInfo = System.Environment.OSVersion; //6 - Vista, 7, Server 2008 if (osInfo.Version.Major == 6) { //windows 7 = 1 if(osInfo.Version.Minor == 1) return true; } return false; }

The next major hurdle to overcome was determining where all of the information for the system was stored.

I didn’t really know where to start, so I started looking at MSDN and the search engines for the best way to get this information and I came across a term I had only heard in passing: WMI. Windows Managed Instruction (WMI) allows for querying the system for data, as well as other things that I did not use it for so we will skip all that. You can learn more on WMI on your own time here: http://msdn.microsoft.com/en-us/library/aa394582(VS.85).aspx. I also found a nifty tool from Microsoft called WMI Creator (http://www.microsoft.com/downloads/details.aspx?familyid=2cc30a64-ea15-4661-8da4-55bbc145c30e&displaylang=en) to help facilitate my search. I was blown away by the sheer amount of data and left with no idea of where to start. So, it was back to MSDN to figure out what happens when the Experience Index is run. This made my task much easier since the Experience Index creates its own XML files with most of the data I need.

I retrieved a list of files and used the one that was within a day of the current date/time. This was easy stuff, till I had to determine what to do if they didn’t have an Experience Index. If they didn’t, I’d just run the Experience Index on the fly. To do this, set the program to tell the user that they do not have a current enough score and that we’ll update the information for them by running the Windows System Assessment Tool (WinSAT).

The initial version was not very good since it was modal and caused the application to not refresh until the Experience Index finished running. Needless to say, I was not happy. What I did do, though, was setup a child form that would launch the WinSAT and query every 5 seconds to see if it was still running. Here is the initial call to load the dialog windows and, if successful, check again for a valid Experience Index to post:

/// <summary> /// Launches the dialog that handles launching WinSat and checking if it is running. /// </summary> private void SetupAndRunWinSAT() { WinSatProgress progressWindow = new WinSatProgress(); bool? dialogResult = progressWindow.ShowDialog(); if (dialogResult.HasValue && dialogResult.Value) CheckForAndProcessScore(); }

Now we are getting into the good stuff, so I will touch on the actual running of the WinSAT and querying the system for a running process.

Launching the WinSAT is pretty simple since there is an environment variable that points to its path:

Environment.GetFolderPath(Environment.SpecialFolder.System) + @"\WinSat.exe"

I only started a basic process and told it to run. I did not tell it to run behind the scenes because I wanted the user to be sure something was actually happening since the WinSAT can take any number of minutes depending on the system configuration. I also setup a global variable (WinsatExecutableExited) used elsewhere in the application to query to see if the process exited:

/// <summary> /// Launches the winsat program /// </summary> public static bool RunWinSatProgram() { bool isLaunched = false; WinsatExecutableExited = false; System.Diagnostics.Process winSatProcess = new System.Diagnostics.Process(); winSatProcess.StartInfo.FileName = Helpers.Globals.WinSatExecutable; winSatProcess.StartInfo.Arguments = Helpers.Globals.WinSatExecutableParameters; winSatProcess.EnableRaisingEvents = true; winSatProcess.Exited += new EventHandler(WinSatProcess_Exited); try { winSatProcess.Start(); isLaunched = true; } catch { } return isLaunched; }

You’ll notice the exited event handler. I put that there so that when the process exited, it set the flag. However, I was having issues with it not always getting executed on some systems. To accommodate for this, I setup a DispatchTimer in the dialog window that would check every 5 seconds to see if the global WinsatExecutableExited flag was true or if the WinSAT process was still running. In order to check if the process is still running, I used WMI. Yes, yes I know—why, since I hadn’t yet done much of anything with it, am I using WMI for this? Well, I won’t bore you with details, but I found an example online and modified it to fit what I need (http://www.techimo.com/forum/applications-operating-systems/117464-need-vbulletin-script-check-see-if-process-running.html). Bet you weren’t expecting that were you? (Or, maybe you were.) Long story short, I set up a method that I can pass a process name to, and it returns true/false if it is still running or null if it can’t determine anything:

/// <summary> /// used to determine if the process is still running /// http://www.techimo.com/forum/applications-operating-systems/117464-need-vbulletin-script-check-see-if-process-running.html /// </summary> /// <param name="processName"></param> /// <returns></returns> public static bool? IsProcessStillRunning(string processName) { bool? response = null; try { ManagementObjectSearcher searcher = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_Process"); foreach (ManagementObject queryObj in searcher.Get()) { if(string.Compare(queryObj["Name"].ToString(), processName, StringComparison.OrdinalIgnoreCase) == 0) { response = true; break; } } if(!response.HasValue) response = false; } catch (Exception ex) { System.Windows.MessageBox.Show(ex.Message + Environment.NewLine + ex.StackTrace); } return response; }

Neat, huh? That’s what happens every time the dialog counts down until it either finishes or can’t—for whatever reason—determine the status of the WinSAT.

Now that the file is generated, we want to get all of the data goodness out of it so we can post our data to the service. Since this is an XML file, it was easily loaded into a XElement and traversed as needed. Now we come to another sticky point, retrieving other system data not stored in the XML file. This is where the web and that WMI Creator application came in handy. I would look online to find what I needed, and then leveraged WMI Creator to generated my base code for me. I setup an object for the retrieved data and here’s what it looks like to query the system for the memory type and speed:

/// <summary> /// used to retrieve the memory info /// </summary> /// <returns></returns> public static List<WMIItem> GetPhysicalMemory() { List<WMIItem> response = new List<WMIItem>(); ManagementObjectSearcher searcher = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_PhysicalMemory"); foreach (ManagementObject queryObj in searcher.Get()) { response.Add ( new WMIItem() { Key = "MemoryType", Value = queryObj["MemoryType"] } ); response.Add ( new WMIItem() { Key = "Speed", Value = queryObj["Speed"] } ); break; } return response; }

Now is about where I have all of my information ready and need to send it to the server. Setting up the service connection for initial testing is no problem. It’s a standard Windows Communication Foundation (WCF) service. But here comes the hard part—setting it up so the service does not need information from a config file. Back to the web we go, since I am like the other 100% lazy programmers who prefer to just add a Service reference because it is easy. Well, there are two parts to this: generating the code class and setting up the service connection information.

Generating the code class is easy—you use a command line to generate it. It was a little complex since I was generating it for asynchronous calls to the service, but this was nothing MSDN couldn’t help me with. Speaking of, here’s the documentation from MSDN: http://msdn.microsoft.com/en-us/library/ms730059.aspx

The other part was sending up the binding endpoint. Most of the information I needed was generated when I generated the code file form the service. Now I just needed to determine how to put it all together. MSDN to the rescue yet again: http://msdn.microsoft.com/en-us/library/ms733107.aspx

What I ended up doing was creating a CustomBinding and specifying the same information/objects the system would have created for me using the values in the config file:

/// <summary> /// The wcf service reference member /// </summary> WindowsExperienceServiceClient experienceClient = null; CustomBinding myBinding = new CustomBinding(); myBinding.Elements.Add(Helpers.Globals.CustomServiceBinding); myBinding.Elements.Add(Helpers.Globals.CustomTransportBinding); experienceClient = new WindowsExperienceServiceClient( myBinding, Helpers.Globals.CustomEndPoint);

The global bindings and endpoints:

/// <summary> /// The binary encoding objct for the custom binding /// </summary> public static BinaryMessageEncodingBindingElement CustomServiceBinding { get { BinaryMessageEncodingBindingElement binaryEncoding = new BinaryMessageEncodingBindingElement(); binaryEncoding.MaxReadPoolSize = 64; binaryEncoding.MaxSessionSize = 2048; binaryEncoding.MaxWritePoolSize = 16; binaryEncoding.ReaderQuotas.MaxDepth = 32; binaryEncoding.ReaderQuotas.MaxStringContentLength = 8192; binaryEncoding.ReaderQuotas.MaxArrayLength = 16384; binaryEncoding.ReaderQuotas.MaxBytesPerRead = 4096; binaryEncoding.ReaderQuotas.MaxNameTableCharCount = 16384; return binaryEncoding; } } /// <summary> /// The transport element for the custom binding /// </summary> public static HttpTransportBindingElement CustomTransportBinding { get { HttpTransportBindingElement transportBinding =  new HttpTransportBindingElement(); transportBinding.ManualAddressing = false; transportBinding.MaxBufferPoolSize = 524288; transportBinding.MaxReceivedMessageSize = 65536; transportBinding.AllowCookies = false; transportBinding.AuthenticationScheme =  System.Net.AuthenticationSchemes.Anonymous; transportBinding.BypassProxyOnLocal = false; //decompressionEnabled="true"  transportBinding.HostNameComparisonMode =  HostNameComparisonMode.StrongWildcard; transportBinding.KeepAliveEnabled = true; transportBinding.MaxBufferSize = 65536; transportBinding.ProxyAuthenticationScheme =  System.Net.AuthenticationSchemes.Anonymous; transportBinding.Realm = string.Empty; transportBinding.TransferMode = TransferMode.Buffered; transportBinding.UnsafeConnectionNtlmAuthentication = false; transportBinding.UseDefaultWebProxy = true; return transportBinding; } } /// <summary> /// the endpoint used for the service communication /// </summary> public static EndpointAddress CustomEndPoint { get { return new EndpointAddress( Properties.Resources.WEIServiceEndpoint); } }

Yes, it is just that easy. All I had to do after that was setup the call completed handler and then call the service method and then it was all done.

Conclusion

This was a really fun and challenging project for us. While we’d worked extensively in Silverlight, the desktop development was relatively new to us. After getting our bearings, we found it pretty simple to translate our Web development skills to the desktop environment with WPF.

If you want to try this out, the download link for the source code is at the top of the article!

About The Authors

Lincoln Anderson, Peter Brownstein, and Peter Juchniewicz are all developers at web design company 352 Media Group. The company, which focuses on emerging technologies like Microsoft Silverlight Design, Windows Phone 7 App Development, and Microsoft Surface Development, has worked on other cool tools like the Coding4Fun Windows Phone 7 T-Shirt Cannon and the Tweetcraft WOW Twitter client.

In the fourth Platform Preview, you’ll notice pages running in IE9’s Standards Mode no longer have the border of EA Shark – is very sophisticated forex trading system from ForexEASystems.com. It`s description is available on the official website.. Here’s a before and after:

Before

After

Pages that run in legacy document modes will still have a 2-pixel border so that any site calculations dependent on the 2 pixels remain the same as in IE8.

To make sure your site runs in IE9 Standards Mode and gets this and all the other latest features in IE9, use a strict doctype. We recommend the HTML5 doctype (<!DOCTYPE html>) since it’s simple and will put your site in Standards Mode in all current browsers.

John Hrvatin
Program Manager

The first deliverable for the working group is to recommend an API that measures the performance of browser navigations. The WebTimings specification provides a good starting point for these capabilities, so this specification will move into the Web Performance Working Group and become the foundation for our recommendations.

The third Internet Explorer 9 Platform Preview was the first browser to implement these portions of the WebTimings specification. Following standard conventions, we used a vendor prefix (ms) on the name because the specification was still under active development and hadn’t been brought into the charter of any working group. Google also recently provided an early implementation of these API’s inside Chrome using their vendor prefix (webkit). Through early collaboration between our engineering teams, we almost have interoperable implementations which is impressive for an API that has only been discussed for a few months. This is a great example of what’s possible through collaborative partnerships at the W3C.

With two early implementations available, it shouldn’t take long to finalize an interoperable API and remove the vendor prefixes. We can’t do this alone though – the new working group needs your feedback to ensure we have the right design. Over the next few weeks we’ll post more details on the working group website and begin to solicit feedback. In preparation, you can try out these API’s using the IE9 Platform Preview or Chrome 6 nightly builds. To help you get started take a look at the msPerformance demo on the IE9 TestDrive which shows these API’s in action.

Jason Weber
Lead Program Manager for IE Performance

Internet Explorer 8 and earlier versions implemented an alternative mechanism to apply opacity using the alpha filter of the IE-specific filter property. This creates a compatibility challenge because IE9’s standard mode supports only opacity and not the alpha filter. (IE9’s compatibility modes Quirks, 7, and 8 still support the alpha filter but do not implement opacity.)

For sites that use best practice feature detection, this is not a problem. They will detect that opacity is supported in IE9 and use it instead of filter. The problem is with sites that use browser detection and mistakenly assume that IE always uses filter alpha instead of opacity and then change only the filter property in script. The opacity effect will appear broken in those Web pages when run in IE9’s default 9 document mode. The fix is to detect the standards-based opacity feature first and browser-specific filter feature second as we’ve described in previous posts.

Example Best Practice CSS

.fiftyPercentOpaque{ opacity: 0.5; filter: alpha(opacity=50);} 

Example Best Practice Code

// set flags for whether we should use opacity or filter with// this browser (or browser mode). we prefer opacity.var useOpacity = (typeof document.createElement("div").style.opacity != 'undefined');var useFilter = !useOpacity && (typeof document.createElement("div").style.filter != 'undefined');

function setOpacity(el, value) { // let el be either an element object or an id string if (typeof el == 'string') el = document.getElementById(el);

 // ensure value is in [0-1] range value = Math.min(1, Math.max(value, 0));

 // set opacity or filter alpha depending on what's supported if (useOpacity) el.style.opacity = value; else if (useFilter) el.style.filter = "alpha(opacity=" + (value * 100) + ")";}

Alternative Browser-detection Code

In general, we prefer feature detection to browser detection but we’ve see a lot of opacity-related code use browser detection instead of feature detection.  If you have a site that does that today, you may find it easier to update your browser detection so it works with IE9. Here’s code that properly detects when IE is running in a browser mode less than 9’s standards mode.

function browserDetectSetOpacity(el, value) { // let el be either an element object or an id string if (typeof el == 'string') el = document.getElementById(el);

 // ensure value is in [0-1] range value = Math.min(1, Math.max(value, 0));

 if (navigator.userAgent.match(/\bMSIE\b/) && (!document.documentMode || document.documentMode < 9)) el.style.filter = "alpha(opacity=" + (value * 100) + ")"; else el.style.opacity = value;}

Summary

The problem described above occurs only when the opacity of an element is changed using script that doesn’t detect whether opacity is supported before changing filter. Sites that use only declarative CSS markup will continue to work fine even when opacity is changed indirectly by changing the CSS class of an element or using a pseudo-class such as :hover.

W3Schools offers a clear explanation of CSS opacity and IE’s legacy alpha filter.

—Ted Johnson, Program Manager Lead for Web Graphics

Users of Internet Explorer 7 and 8 (and soon 9) who wish to prevent Google Analytics’ script from running can follow these steps:

1. In Internet Explorer, open the Tools menu and click Internet Options.
2. Click the Security tab and then click the Restricted Sites icon.
3. Click the Sites button.
4. In the box at the top, add *.google-analytics.com and push the Add button.
5. Click the Close button, and then the OK button to dismiss Internet Options.

After this configuration change, script from the Google Analytics website will not run on any webpage, and cookies will never be sent to the Google Analytics server.

How does this simple procedure work?  In IE7, we made a minor change to the Restricted Sites zone. IE will not run scripts that originate from sites the user places in the Restricted zone.

To protect your privacy further, IE will not send cookies to sites in the Restricted Sites zone.  In general, you can block script from any other domains by also adding those domains to the Restricted Sites zone.

Add-ons are useful and important. They are also a key cause of performance, stability, and security issues for all browsers. A more trustworthy approach involves building more functionality into the core browser and relying more on data (in the form of declarative descriptions, like XML) than code to extend the browser. For example, Accelerators in IE are XML descriptions of how to get a map, rather than arbitrary script that can get a map and possibly do more (like slow down the browser, or share more information than you’d like). Webslices are XML descriptions of parts of a webpage to show on IE’s Favorites Bar, rather than arbitrary script that can modify IE’s user interface and possibly do more than that under the hood.

In this situation, rather than install and run a lot of additional software on the machine, people can just add a web site to the Restricted Sites zone. Similarly, InPrivate Filtering in IE8 (and IE9) supports Importing and Exporting lists of sites that the user doesn’t want to exchange information with. That’s a simpler, safer, faster and more reliable approach than running more code.

Eric Lawrence
Program Manager

We’ve shared several great examples of these guidelines and requirements in action in the past few months. As part of IE’s cumulative security updates, we’ve released an update to the Internet Explorer Upgrade Advisor list that helps users update to new versions of add-ons that follow the guidelines and requirements. In this post, we highlight the latest add-ons that have made changes based on the guidelines and requirements, and we describe the Upgrade Advisor user experience in detail.

It’s been encouraging to see more add-ons recently release new versions with improvements in functionality based on these guidelines and requirements. As more developers follow them, our users will have a better experience. Here are some of the add-ons that have made changes to their functionality:

Add-on Name	New Version
AOL Toolbar	5.74.1.5498
Ask Toolbar	5.6.2.119
BuySafe Shopping Advisor Toolbar	5.0.1.366
Comcast Toolbar	1.0.0.17
Quero Toolbar	5.0.0.5
XFinity Toolbar	1.0.0.17
Yandex.Bar	5.1.2.1189

It’s important to update users to the new versions of these add-ons so they can benefit from improved stability and compatibility. Today we released an updated Upgrade Advisor list with IE’s Cumulative Security Updates to help users do just that. Users who have specific versions of the above add-ons may see the Upgrade Advisor dialog box when they launch Internet Explorer 8:

The dialog box presents the user with three options to choose from:

Option 1: Check online for an update
When the user selects this option or closes the dialog without making a choice, the dialog box is dismissed and a web page is displayed in a new window that runs in No Add-ons Mode. The user can follow the steps in this web page to install the new version of the add-on. If a link to the new version of the add-on is not provided by the vendor, or the new version does not follow the guidelines and requirements, the web page will inform the user that no update is available yet.

Option 2: Always open Internet Explorer without this add-on
When the user selects this option, Internet Explorer disables the add-on, the dialog box is dismissed, and Internet Explorer continues to launch.

Option 3: Keep using this add-on anyway
When the user selects this option, the dialog box is dismissed and Internet Explorer continues to launch with the add-on enabled until the next refresh of the Upgrade Advisor list which occurs approximately every 8 weeks.

Many thanks to the teams that have made changes to follow the guidelines and requirements. We will continue to work with add-on vendors to help them release new versions of add-ons that have better stability, compatibility and performance.

Herman Ng
Program Manager

This security update is rated Critical for Internet Explorer 6, Internet Explorer 7, and Internet Explorer 8. The security update addresses the vulnerabilities by modifying the way that Internet Explorer enforces security checks and handles objects in memory. For more information about the vulnerabilities, please see the full bulletin.

The majority of customers have automatic updating enabled and will not need to take any action because this security update will be downloaded and installed automatically. Customers who have not enabled automatic updating need to check for updates and install this update manually. For information about specific configuration options in automatic updating, see Microsoft Knowledge Base Article 294871.

For administrators and enterprise installations, or end users who want to install this security update manually, Microsoft recommends that customers apply the update immediately using update management software, or by checking for updates using the Microsoft Update service.

Tyson Storey
Program Manager

With IE9, we have worked much more closely with the developer community. Developers have had an earlier (and more frequently updated) look at the platform. With that early engagement, developer feedback has had a bigger impact than before. People have downloaded IE9 Platform Previews over 2.5 million times. The samples on the IE Test Drive site have had over 20 million visitors. We appreciate the positive feedback and all the specific issues logged in Connect. They’ve helped us make demonstrable improvements that the community has noticed.

The fourth Platform Preview of Internet Explorer 9, available now, shows the opportunity of fully hardware-accelerated HTML5. You can run new test drive samples that show modern SVG and native JavaScript integration in action. In March, we promised to deliver platform preview releases approximately every eight weeks. With this installment, you will find more performance and more support for same markup. You’ll also find many fixes to issues reported in previous Platform Previews. Here is a video of some of the test drive samples:

Note this video uses the HTML5 video tag (with the H.264 codec) if your browser supports it, and falls back to other methods otherwise. It’s a good example of same markup in action.

Fully Hardware-Accelerated HTML5

The performance benefits of hardware acceleration are clear from running different sample sites side by side in IE9 and other browsers. Browsers that implement partial hardware acceleration – for example, text-only, or video-playback only, or image-only acceleration – offer inconsistent and possibly unpredictable platform experiences to developers and end-users.

IE9 offers consistent, fully hardware-accelerated text, graphics, and media, both audio and video. Try Hamster Dance Revolution, IE Beatz, or MSNBC Video in different browsers to experience the difference. Psychedelic Browsing demonstrates what HTML5 canvas can do when it’s fully accelerated with the GPU.

Modern SVG

With Platform Preview 4, we’re excited to show highly-interactive and integrated, or modern, SVG. Typically, developers think of SVG as the graphics format for static engineering diagrams and images. With HTML5 and hardware acceleration, SVG is an excellent choice for a new class of interactive, animated scenarios.

You can see great SVG performance, animated via JavaScript, with the SVG Dice example. The sample shows striking performance differences between browsers animating the same SVG markup, as well as the benefits of being able to style SVG with CSS. Unfortunately, you can see differences in how different browsers display the same SVG; as an industry we have more work to do so the same markup delivers the same results.

Native JavaScript Integration

We’re committed to the right foundation for HTML5 applications, including performance and ensuring the same markup and same script work across browsers. One aspect of doing these things well is integrating the JavaScript engine natively inside the browser, rather than bolting it onto the side to support multiple JavaScript engines as some other browsers do today. How a JavaScript engine is integrated into the browser is as important as the engine itself for real-world HTML5.

The fourth Platform Preview moves the new JavaScript engine, codenamed Chakra, inside IE9 and brings them together into one single, integrated system.

Through this deep integration, the performance of real world websites significantly improves, and IE9 becomes the first browser to have a shared DOM between the browser and the script engine based on ECMAScript5. The benefits start with real-world performance and consistency.

The easiest way to understand the importance of this fundamental change is by looking at how earlier versions of Internet Explorer integrated JavaScript. For the last 15 years Internet Explorer has supported multiple programming languages including JScript, VBScript, and even specialized languages such as Perl. While this gave developers choice it also came at the cost of performance and features. The browser and these script engines communicated through COM which could cause performance problems. Each script engine had its own language specific view of the DOM which created discrepancies. Additionally, the browser was forced to use a least common denominator approach which made adding new features challenging.

In the fourth Platform Preview, we’ve moved the JavaScript engine inside IE9. With this change, communication between the browser and script engine is now direct, which significantly improves performance for real world websites. We now have a single DOM, shared across all browser subsystems including JavaScript. This change ensures a consistent and interoperable view of the document. And this single DOM is now based on ES5, which prepares the entire system for the future.

When programming the IE9 DOM from JavaScript, objects now feel like native ES5 objects because, underneath the covers, they actually are ES5 objects. This approach brings the benefits of ECMAScript5 to the DOM. With the fourth Platform Preview, IE9 becomes the first browser to have a fully discoverable DOM through ES5 reflection features. IE9 is the first browser to apply ES5 bindings to DOM objects, enabling a full Inheritance view of the DOM, and taking advantage of the WebIDL specification as the foundation for this support. Together, these changes provide developers a natural ES5 based programming model. Try some of these enhanced DOM capabilities out for yourself to see how well your browser’s DOM and JavaScript engine are integrated. IE9 will continue to support additional programming languages through the legacy model, but we strongly encourage developers and enterprises to take full advantage of the benefits of JavaScript moving forward.

Platform Preview 4 also continues improvements to the JavaScript engine itself. One measure of JavaScript performance is the Webkit Sunspider microbenchmark. Here is a chart of the latest results:

The differences between browsers on this microbenchmark are converging within thousandths of seconds on tests that repeat operations many, many times to find any differences at all.

Real-world HTML5 performance often reflects the entire browser’s performance, not just the JavaScript engine in isolation. This video, for example, shows a side by side comparison of different browsers running an HTML5 canvas. The performance differences between browsers are striking and do not reflect relative JavaScript performance. We encourage other browser vendors to consider following our lead in designing for end-to-end performance and natively integrating JavaScript engines rather than treating script as a separable subsystem to be optimized in isolation.

Same Markup, and Tests

To assess the quality and completeness of a browser’s standards support, we look to the official standards bodies. Their open, consensus-based process is the best way to bring the community of browser vendors and web developer and design professionals together in building a test suite.

With Platform Preview 4, we’re contributing 519 new tests to the standards bodies. Based on community feedback, we’ve also updated five of the previously submitted tests. This brings the total number of tests we’ve contributed during IE9 development to 2,138. We welcome your feedback on the specific test cases. Please continue to provide feedback on the test cases to the appropriate W3C working group. In case of ES5 test cases please provide test case specific feedback via Microsoft Connect. We also invite you to submit your own test cases to the standards bodies as well. You can find the test cases Microsoft has developed at the IE Test Center.

These test cases represent a strong start on a complete and comprehensive test suite of the web standards developers expect to work consistently across browsers. While the suite is not complete yet, it is interesting to note how interoperable some of the same markup is across different browsers:

Some people use a particular test or website as shorthand for standards compliance. Different sites test different subsets of different standards to different depths. Acid3 is one that some people in the community have cited. It tests about 100 fragments of a dozen different technologies. Here’s a screenshot of how today’s IE9 Platform Preview runs today’s Acid3 test, going from 83 in the previous platform preview to 95:

As IE9 has implemented more of the standards that developers use and value, IE9’s Acid3 score has continued to rise. The remaining points involve two particular technologies (SVG Fonts and SMIL animation of SVG) that are in transition.

Support for SVG Fonts in the web development and font communities has been declining for some time. There’s already been discussion without objection of dropping SVG fonts from the Acid3 test. The community has put forth a proposal in the SVG Working Group to give SVG Fonts optional status.

Instead, developers can use the Web Open Font Format (WOFF, supported in IE9 Platform Preview 3 as well as other browsers) for both HTML and SVG content. It works well in conjunction with the CSS3 Fonts module and has broad support from leading font vendors (e.g. here, “a majority of font makers have already settled on WOFF or services like Typekit as their format of choice”). WOFF fonts are a better long-term solution for many reasons discussed previously.

Similarly, support for SMIL animation of SVG in the web development community is far from strong. The leader of the SVG standardization effort wrote that not supporting SMIL in its current state is probably best “since the SVG WG intends to coordinate with the CSS WG to make some changes to animation and to extend filters.” There’s already work started to reconcile CSS3 animations and SVG. Developers interested in animating SVG can use JavaScript, as the samples in the test drive site do today, with consistent results.

Getting sites ready for Beta

With the fourth Platform Preview, we strongly recommend developers, designers, and partners to start getting your sites ready for the IE9 Beta.

• Test your site in IE9 Standards Mode.  This mode provides the best performance and interoperability and will offer additional benefits in the IE9 Beta. We suggest using the HTML5 doctype. More details here and here.
• We recommend sending IE9 the same standards-based markup your site sends other browsers. More details here and here. From the feedback so far, and our experience with sites, the best way to get your site working in IE9 Standards Mode is to start from the same markup other browsers receive rather than IE6, IE7, or IE8 markup.
• Use feature detection, not browser detection to handle any cross browser differences in behavior or feature support.  This keeps your site working even as browsers change.
• Please continue to report issues on Connect if your site doesn’t look or work right, and you’re giving it the same code as you’re giving to other modern browsers. With IE9 Platform Preview 4, we’ve fixed over 100 community-reported issues. We will fix even more between now and the IE9 beta and want your feedback.
• Consider the experience for IE9 Beta users if you find that sending the same markup creates more issues than you can resolve in your production site. It is possible that running your site in Compatibility View is better for your users.
• Take advantage of HTML5, CSS3, SVG, DOM, ES5, and more… all described here in the developer guide.  We’re excited to run the amazing experiences you bring to the web using these new capabilities, taking advantage of hardware through IE9.

Platform Preview 4 is an important milestone on the way to beta. It is the last preview before the IE9 Beta. The IE9 platform is nearly complete. We ask that developers and partners start testing in preparation for the beta and prepare their sites to take advantage of IE9’s new capabilities. We continue to welcome your feedback via Connect.

Thanks,
Dean Hachamovitch
General Manager, Internet Explorer