I often find myself maintaining open source projects. I’ve contributed to many over the years, even hosting multi-person “source available” projects on this very website in zip files before there were such things as GitHub or Pull Requests or Open Source Software. No matter what mechanism I’m using to manage the project, if it’s popular, I get issues filed against that project. Those issues break down into two categories:

The Consumer Preview of Windows 8 (aka the Win8 beta) is now available for download, along with the matching Visual Studio 11 beta. You can download them both from the Developer Center for Metro style Apps and at least when I did the downloading this morning, it was smooth and worked well. In case you’re interested, I downloaded the ISO, not the setup, and I am currently writing this blog entry in Windows Live Writer running inside a WMWare Workstation 8.0 virtual machine running on the Windows 7 host OS running inside Boot Camp on my MacBook Pro. As someone said to me this morning: “That’s a lot of VMs!” Maybe so, but the Win8 and VS11 betas are running surprisingly well inside of my Inception-box.

Metro/JS Templates for VS11 in BUILD

If you recall from REPL for the Rosyln CTP 10/2011, I’ve been playing around building a little C# REPL app using Roslyn. That version was built as a Console application, but I’ve refactored and rebuilt it as a WPF application:

For years, I’ve maintained a single “main” computer. It was the computer that was the central authority of all of the personal data I’d accumulated over the years and from which it made me uncomfortable to be separated. Because I needed a single computer for everything, it had to work on my couch, on a plane, on a desk and everywhere else I ever needed to go. Also, it couldn’t have a giant monitor or multiple monitors, because it had to go everywhere. All of this was because I needed all of my data with me all of the time.

I don’t know what it is, but I’ve long been fascinated with using the C# syntax as a command line execution environment. It could be that PowerShell doesn’t do it for me (I’ve seriously tried half a dozen times or more). It could be that while LINQPad comes really close, I still don’t have enough control over the parsing to really make it work for my day-to-day command line activities. Or it may be that my friend Tim Ewald has always challenged csells to sell C shells by the sea shore.

I use LINQPad all the time for a bunch of stuff, but most recently and most relevant, I’ve been using it for a personal chore that isn’t developer-related: I’ve been using it to do budgeting.

What is LINQPad?

In the old days, the post-colonial, pre-LINQ days of yore, I’d have written a one-way MD5 encryption like so:

static string GetMD5String(string s) {
  MD5 md5 = new MD5CryptoServiceProvider();
  byte[] hash = md5.ComputeHash(Encoding.ASCII.GetBytes(s));
  StringBuilder sb = new StringBuilder();
  foreach( byte b in hash ) sb.AppendFormat("{0:x2}", b);
  return sb.ToString();
}

One day when I was supposed to be writing, I needed something to do (as often happens). In this particular case, I built a little tray icon app using the new (at the time) tray icon support in Windows Forms (this was a while ago : ). The data I was checking was my gmail account and whenever there was new mail, I’d pop up a notification. All very simple, so to be funny, instead of saying “You’ve got mail,“� my program said “I’s time to check the donuts.”

I was playing around building a tool to let me edit a database table in Excel, so I updated my CvsFileTester project to work in a modern world, including the 32-bit only Jet 4.0 driver you’ve probably go lying around on your HD.

Enjoy.

Joe Albahari, the author of LINQPad, has added support for WCF Data Services to the 1.37.1 version beta of LINQPad. This means that you can point LINQPad at any Open Data (OData) endpoint and do queries interactively just like any other LINQ data source. He even supports HTTP security, in case the endpoint in question requires it. Further, if you have your own custom LINQ to Whatever and you’d like to plug a connection to it into LINQPad, Joe has already added the ability to create a custom data context provider. It is, as they say, a thing of beauty. Enjoy!

Windows 7 took away a feature I use all the time, as shown on the right: Search the Internet.

From the Pex site:

“Pex (Program EXploration) produces a traditional unit test suite with high code coverage. … To do so, Pex performs a systematic white box program analysis. Pex learns the program behavior by monitoring execution traces, and uses a constraint solver to produce new test cases with different behavior. At Microsoft, this technique has proven highly effective in testing even an extremely well-tested component.” [ed: emphasis mine]

Quetzal Bradley is a software development engineer (SDE) on my team with *tons* of experience in all manner of infrastructure stuff including the requirements of real-world software testing from the trenches at Microsoft.

Q gave a talk about what comes after unit testing to my team and I was blown away, so I sent him to tell Scott about it so that you could hear it, too.

Shawn Burke has released the details to set up VS08 to debug into the .NET Framework source code, including the following assemblies:

• mscorlib.DLL
• System.DLL
• System.Data.DLL
• System.Drawing.DLL
• System.Web.DLL
• System.Web.Extensions.DLL
• System.Windows.Forms.DLL
• System.XML.DLL
• WPF (UIAutomation*.dll, System.Windows.DLL, System.Printing.DLL, System.Speech.DLL, WindowsBase.DLL, WindowsFormsIntegration.DLL, Presentation*.dll, some others)
• Microsoft.VisualBasic.DLL

From the Visual Studio home page:

• Learn more about Visual Studio 2008
• MSDN Subscribers: Get Visual Studio 2008
• Download Trial Editions of Visual Studio 2008
• Download Visual Studio 2008 Express Editions (and see Dan’s Top 15 Things to love about Visual Studio 2008 Express)
• Download the .NET Framework 3.5
• Download the Visual Studio 2008 1.0 SDK (includes all kinds of cool stuff for developing against VS itself, including the new Visual Studio Shell).

After programming with MFC (a lot!) and writing the ATL book, it was *very* difficult for me to live in a world without the source code to figure out how something was working. All of us have since moved over to Lutz’s most excellent Reflector, but that’s still no substitute for actually stepping in and now ScottGu has announced that we’ll have the ability to browse and debug with the .NET library source code, integrated into VS2008:

Shawn Wildermuth has prepared a v0.8 release of Genghis that includes a bunch of stuff that the folks that put the v0.6 release together dropped. The v0.8 release has all the good stuff from the v0.5 release and all the new stuff from the v0.6 release in a .NET 2.0 package.

Shawn’s really done all the work for Genghis since I came to Microsoft. Thanks, Shawn.

Show Me The Template is a tool for exploring the templates, be their data, control or items panel, that comes with the controls built into WPF for all 6 themes.

And the hits they keep on comin’:

• What’s New in VS Orcas March CTP VPC image (includes the *long* list of what’s new)
• Virtual PC 2007 (*free* but needed to play w/ the Orcas bits)
• Tim Sneath on Orcas + WPF

• .NET Reflector 5.0
• .NET Reflector 5.0 Add-Ins
• .NET Reflector 5.0 new feature overview (PowerPoint deck)

Need I say more?

A long time ago (2000), I was fascinated with turning a phone number into a time zone so I could tell what time it would be somewhere before I called and woke anyone up (this happened too often : ).

As part of that work, I quickly realized that info in Windows for time zones wasn’t detailed enough, so I began looking elsewhere. I found the Time Zone Map Group, which maintains time zone data for all over the world backward through time. This is an amazing accomplishment, since they have to account for every law change as each tin pot dictator comes to power, e.g. George W.

I knew that the J# libraries in .NET had zip file support, but I couldn’t find any samples that showed how to decompress the files into memory. The hard part, of course, is that the J# stream objects aren’t the same as the .NET stream objects. If you’re a Java programmer looking for a familiar library, that’s great, but I’m not, so I had to do a little finagling.

The first thing you need to do is to add a reference to the vjslib assembly, which brings in .NET classes in Java namespaces, e.g. java.io. The one we care most about is java.uti.zip, which includes ZipFile and ZipEntry. We also need java.util for the Enumeration class and java.io for the InputStream class. With these in place, we can enumerate a zip file:

Charlie Kindel of COM fame (he’s wrote the foreword to Don’s seminal work “Essential COM”) is the Product Unit Manager (softie-speak for “butt on the line”) for the new Windows Home Server team. If you haven’t heard about it, Home Server is a Windows server box for the rest of us. I don’t know about you, but I’ve got file, print and media servers all over the house in a confusing mess and I look forward to being able to consolidate it. According to the enthusiastic beta tester I talked to, Windows Home Server is the way to do that.

Yesterday, Charlie announced the Windows Home Server Blog. Enjoy.

Capturing screenshots for a book used to be a piece of cake. Alt+PrintScreent and you were golden. However, sometimes I wanted to get the cursor, too, and neither Alt+PrintScreen nor PrintScreen does that, so I got myself a copy of SnagIt. Unfortunately, if I wanted to capture multiple screens, I was putting a maximized copy of Notepad in the backgrand, using PrintScreen and PBrush to do the cropping (although SnagIt has slightly more seamless multi-window selection).

Still, this all worked ’til Vista came along and Alt+PrintScreen left the shadows out! I was fine with that, but Ian correctly pointed out that the screenshots with the shadows looks *so* much better that I could hardly say “no.” And I discovered the Snipping Tool in Vista, which let me do a selection on any part of the screen I wanted to, except that now instead of just doing Alt+PrintScreen, even for a single window, now everything is a selection, which means that somebody (hopefully not me!) has to trim the extra whitespace to make sure the pictures layout OK in the book.

When it comes to Web 2.0 apps, online maps are easily the thing I use the most. I don’t go anywhere these days w/o first pulling up the map on MapQuest, Google maps or, for a coupla years now, local.live.com (starting back when it used to be called MapPoint). I generally use Google for my search engine, so don’t think it’s just the MS employee thing pushing me — I genuinely like local.live.com better.

Google and MS have been in an arms race for years on the maps stuff, doing fancy stuff like 3D globes and other goo that looks good in demos, but that I don’t need. However, in this war of the world (so to speak : ), today MS fired a decisive shot across the bow, I think — the “Send” menu. This is huge for me, because I can send the directions to my phone, either via SMS or via email, and I get a great display clearly optimized for my smartphone. Not only does it have a great mini-map, but the directions are easy to read (saving me from printing the directions for just a single trip) and it has a link to reverse the directions (the one thing I never remember to do).

“Through further advancement and feedback, Service Pack 1 … provides over 70 improvements for common development scenarios including:

• New processor support (e.g., Core Duo) for code generation and profiling
• Performance and scale improvements in Team Foundation Server
• Team Foundation Server integration with Excel 2007 and Project 2007
• Tool support for occasionally connected devices and SQL Server Compact Edition
• Additional support for project file based Web applications
• Windows Embedded 6.0 platform and tools support

Oh, man, I *so* want to write a game that runs on my Xbox 360! Now I can (and so can you). Enjoy!

P.S. Impeach!

and if it’s any good, we hear about it. Really, I’m just posting this link to Scott Hanselman’s 2006 Ultimate Developer and Power Users Tool List for Windows here so I can find it later, but feel free to browse the list yourself, broken up into several interesting categories:

• Top 10 (+ 5) Life/Working-Changing Utilities
• A Developer’s Life
• COM is Dead [ed: if only]
• XML/HTML Stuff
• Regular Expressions
• Launchers
• Stuff Scott Digs
• Low-Level Utilities
• Websites/Bookmarklets
• Tools for Bloggers
• Smart People’s Utility Pages
• Alt.Lang
• Browser Add-Ins
• Things Windows Forgot
• Outlook Add-Ins and Life Organizers
• Ultimate Registry Tweaks
• Windows Explorer Integration (and other integratey things)
• Continuous Integration
• TablePC Indispensables
• ASP.NET Must Haves
• Visual Studio Add-Ins

To capture the work that Doug and I did to make Indigo (WCF) and Avalon (WPF) work together, I tore up our PDC sample application into a set of simpler technology samples. To make it fun for myself, as part of these samples, I built a little library for converting numbers into strings of English words, e.g.

I updated the SDK RegistrySettingsProvider to implement IApplicationSettings and built a sample to demonstrate how to integrate it (or any .NET 2.0 custom settings provider) with the settings designer-generated code. Enjoy.

Discuss

To capture the work that Doug and I did to make Indigo (WCF) and Avalon (WPF) work together, I tore up our PDC sample application into a set of simpler technology samples. To make it fun for myself, as part of these samples, I built a little library for converting numbers into strings of English words, e.g. 4 is “four:”

Imagine your vacation photos displayed in 3D and linked together, both around a space and zooming in and out. Now imagine everyone’s photos linked together in this way. What you get is PhotoSynth:

• PhotoSynth Demo and Overview Videos
• PhotoSynth architect interview on Channel9
• PhotoSynth on 10

I’ve been hearing a lot about functional programming lately (and the circle of life continues); I found Functional Programming For The Rest of Us to be a nice summary. Here’s what I got from it:

Atoms of FP:

″CodePlex functionality, built on Microsoft Visual Studio® 2005 Team Foundation Server, provides source control, issue tracking, discussion forums and RSS feeds in and out of each project so that members can stay up to date on the development issues most important to them. Microsoft Visual Studio Team Foundation Server enables developers to collaboratively develop, share, discuss and consume source code and build software.”

Enjoy.

In using the most excellent Web Application Project support for ASP.NET 2.0 in VS05 from Mr. Guthrie and co, I ran into what was first an intermittent and then a constant problem that actually made it’s way onto my live site (it worked on my machine!). The error looked like this against several classes in my app, i.e. when I’d comment out one, I’d get another class that showed the same problem:

Compilation Error

Top-notch tools at rock-bottom prices. Enjoy.

Believe it or not, Microsoft is always trying to improve its products and to do so, I find we do our best work when we actually ask our potential customers what they think.

In this case, I’d like to know what “pain points” you experience when configuring, deploying and maintaining distributed .NET applications. That can be any kind of app, whether it’s a client-side app that phones home for code or data updates or whether it’s a fully distributed grid or anything in between. Please be as specific as possible and, if you’d like one of our courteous technical people to follow-up, make sure to include contact info.

Genghis has been updated for .NET 2.0 and is available from the Genghis workspace. Enjoy.

Update: The following controls have been added to Genghis in the .NET 2.0 version:

I fell in love w/ the potential of monad a while ago w/ Jeffrey Snover’s original Channel9 video, but I was too lazy to download it onto all of my machines. However, after seeing Jeffrey’s talk at TechDays 2006 in Switzerland (and remembering that monad is installed by default w/ the WinFX SDK, so it was already on all my machines), I took the dive (starting with kiping Jeffrey’s personal copy of “Monad,” from ORA, Andy Oakley’s most excellent monad intro) and I’ve been doing it pretty much non-stop on the train and on the plane all the way home. Like Scott, I’m loving it.

I’ve built several scripts, including start-process (to act like cmd.exe’s “start” command — invoke-item doesn’t work on URLs), find-file, find-filebytext, find-dir and format-notepad. So far, no luck on format-clipboard, i.e. dropping the results of an operation into the clipboard, but I’m having a blast trying.

If you’re having trouble with ClickOnce while using FireFox as your default browser, then this post is for you. Thanks, Saurabh!

I was building some code to access Index Server’s results via .NET and I got this:

// Catalog specified in connection string
string query = “select Path from Scope() where FREETEXT(‘foo’)”;
using( OleDbConnection conn = new OleDbConnection(“Provider=MSIDXS.1;Data Source=MyCatalog”) ) {
  conn.Open();
  OleDbDataAdapter cmd = new OleDbDataAdapter(query, conn);
  DataSet ds = new DataSet();
  cmd.Fill(ds, “SearchResults”);
  DataTable table = ds.Tables[0];
  ds.Tables.Remove(table);
  return table;
}

Holy User32 in a browser window, Batman!

I don’t know what it’s like to use an app built this way, but looking at the samples blows me away…

The nice folks at GotDotNet have decided in their infinite wisdom to move all of the workspaces to a new hierarchy w/o forwarding the URLs and then leaving a message behind indicating that such a thing is temporary to keep users on their toes:

It looks like my old friend Nenad Stefanovic is up to his old tricks with a new version of my favorite native framework, the Windows Template Library. This will go nicely with ATL Internals, 2e, which Chris Tavares is finishing up for Brent and me.

[via Shawn Wildermuth]

The Windows Forms team has posted .NET 2.0 versions of their UI clone apps, including:

What’s the best way to implement the following semantic (feel free to change the signature)?

bool ConvertFromStringToT(string in, ref T out) {…}

If you read the ReadMe.htm from the Visual Studio 2005 setup, you’ll see a detailed list of up to 23 things to uninstall in the right order (plus 2 notes if you have trouble).

To solve this problem, Dan Fernandez posts about a VS05 uninstall tool that worked wonderfully for me.

As MS releases new frameworks, folks always ask “Does MS use this?” Of course, MS has tons of existing apps that would be silly to rewrite, but when we build new stuff, we generally use the latest frameworks that make sense.

Towards that end, John Gosman continues his history of Expression Interactive Designer aka Sparkle, mentioning the percentage of managed code in  (100%) and the number of P/Invoke calls (1 — HtmlHelp) to get what is probably the most amazing app I’ve seen in years, whether managed or not.

This is an interesting, and free, service that you hook your app up to and when it throws an exception, it’ll log it w/ the service so that you can track it from afar.

These kinds of services are exactly what web services are wonderful for. Does anyone know of any other such services? I’m embarrassed to say that I don’t actually know, but does MS provide one in this space or other developer-oriented web services for other than development?

.NET 2.0 has the idea of a “nullable” type built right in, e.g.

Nullable x = null; // legal

Imagine I’ve got some “metadata” that describes some functionality of my system, e.g. the command line parameters to a tool:

I don’t know if Eric understands the ISV industry or not, but certainly seems to. Luckily, I’m on a real product team now, so I get to try to channel Eric into my work.

Eric’s latest writing is The Game is Afoot, in which he describes various games and then draws lessons from them for ISVs. It’s fabulous. He concludes by apologizing for the length and then teasing us with the analogies he left off. It wasn’t too long, Eric! I wanted more! (I also want your blog to have comments, but that’s another thing entirely…)

The session list for the Portland Code Camp, July 23-24, has just been posted. I’m especially looking forward to the following:

• .NET Windows Forms Tips & Tricks
• Forensic Development
• Implementing Creature AI
• Introduction to Inform
• Introduction to Python
• Introduction to Ruby
• Ruby on Rails
• MonoRail - ASP.NET on Rails
• Web Unit Testing with Ruby and Watir

I was helping a colleague work through a .NET COM interop issue. He’d found my article on the topic (“Hosting Windows Forms Controls in COM Control Containers”), but couldn’t get it to work. He’d set the Register for COM Interop setting and adding the Guid attribute to his .NET type, but nothing was registered at build-time.

The problem was that, unlike VS03, the wizard-generated AssemblyInfo.cs has the assembly-wide ComVisible attribute set to “false” which causes regasm (the command-line version of what VS is doing to register your .NET assembly with COM at build-time) to skip the registration of all of the .NET types in your assembly, defeating the purpose of the Register for COM Interop option pretty thoroughly.

Scott Guthrie says:

“What we’ve set out to do is to make it dramatically easier for anyone to build AJAX-style web applications that deliver rich, interactive, and personalized experiences. Developers should be able to build these applications without great expertise in client scripting; they should be able to integrate their browser UI seamlessly with the rest of their applications; and they should be able to develop and debug these applications with ease.

“For this work, we’ve been working on a new project on our team, codenamed ‘Atlas.’ Our goal is to produce a developer preview release on top of ASP.NET 2.0 for the PDC this September, and then have a website where we can keep updating the core bits, publishing samples, and building an active community around it.

This is fabulous! Let me give you a taste:

“We use words like L2, swaps, and working set. We use these words as the backbone of a life spent defending something. You use them as a punchline.”

I saw code that looked like this today:

class Class1 {
  static void Foo(object @this) {
    Console.WriteLine(@this);
  }

  static void Main(string[] args) {
    Foo(“hi”);
  }
}

Congrats to the VC++ 2005 team for a write-up like this!

“The truth is that this new development in C++ seriously undermines the justification for C# as a language. C++ programmers yet to learn C# simply don’t need to now. What’s the point? They will find the full productivity of Visual Studio 2005 right there at their fingertips supporting the language they know and love. Why should they move to something that is slower and less feature rich?”

Apparently in Whidbey, “dumpbin” (and some other tools that were merely wrappers around link) has been dumped. To get to it now, do “link -dump -dumpbin_options” e.g. “link -dump -exports” does what “dumpbin -exports” used to do. In fact, if you just do “link -dump” the usage you get is labeled as the dumpbin usage. : )

BTW, it looks like “lib,” while still there, is also “link -lib” and “editbin” becomes “link -edit.”

Imagine the following C program:

// cmdio.c
#include <stdio.h>

void main() {
  char s[256] = "";
  printf(">");
  scanf("%s", s);
  printf("%s\n", s);
}

First there was case-correction, now VB programmers in VS 2005 beta 2 get grayed out members in intellisense if they set their ClickOnce properties below FullTrust. Cool!

I was paving a box this weekend with the March Avalon/Indigo CTP and I needed the matching Feb CTP of VS05, so I installed the Feb CTP of VC# Express. I have to say, I’m impressed. Avalon integrated w/ no trouble. I have all the Intellisense, key bindings, options, code formatting and generics support that I went looking for (although I did have to find the Show all settings option in the Options dialog).

Only two things bug me about Express. The first is minor: I’m used to starting VS with Start->Run: devenv [Enter] and now I have to start VC# Express with Start->Run: vcexpress [Enter]. Given that I can install a bunch of Express products, it makes sense to me to need to learn a new EXE name for each of them (especially if I slip Asynch COM out of long-term storage… [dumping]… there, plenty of room!).

Are you unhappy with how MSDN arranges content on our site? Would you like to host the content you’ve written on your own site in your own chrome? You can’t do it with everything, but for the content with which it works, Duncan Mackenzie has posted code that pulls content out of MSDN’s current content management system* and hosts in in your own chrome. For those of you that don’t like how MSDN arranges its content, you now have the technical means to arrange it to suit your own tastes.

* DISCLAIMER: Microsoft’s copyright still applies. The internal details of our content management system are going to change without notice. Use at your risk. No warranties extended. Void where prohibited. Some assembly required. blah, blah, blah…

I’ve been digging into .NET application extensibility lately, discovering the various pieces discussed here. And then, just when I’d despaired of finding a resource that covered the issues in depth, a copy of “Customizing the Microsoft .NET Framework Common Language Runtime,” by Steven Pratscher, showed up at my door (that happens sometimes, but I’ve never quite figured out how…).

Steven’s a PM on the CLR team and his book has wonderful chapter titles like:

If you follow the link to the subtext demo that Preston Bannister mentions, you’ll see my idea of hell, i.e. manipulating code primarily with a mouse. Have you ever seen those guys — you know who I mean — those guys that want to copy a chunk of code and reach for the mouse, almost select the text, almost select the text again, finally select the text they want, go to the Edit menu, choose Copy, click on the place near where they want the code to be, click again, finally click in the right place, go to the Edit menu and choose Paste and by that time, you’ve died of old age? It’s all I can do not to tackle these people so I can use the combinations of Ctrl, Shift, Alt and the arrows to select the text and move the cursor to the spot where it belongs, using Ctrl+C and Ctrl+V, never touching the mouse, like BillG intended.

So, watching the subtext demo, which was nearly all copy and paste using the mouse made me want to tackle the guy doing the demo, especially since I couldn’t run it at a higher speed (my very favorite WMP feature).

Jim Hubbard gives Thinstall a ringing endorsement:

“This solution will take your executable (.Net, VB or C++) and all of its dependencies and wrap them all into a single executable. The neat thing is that it even includes the portions of the .Net framework needed to run your executable inside the executable it creates. So, there’s no need to distribute the whole .Net framework.”

Mathew Nolton has posted a GUI front-end to my XmlSerializerPreCompiler that you might find useful. Thanks, Matt!

According to Rich Salz’s reading of the WSDL 2.0 spec (Rich makes a living selling hardware to make XML smoke, so I think he knows), the following is legal WSDL 2.0:

#include "wsdl.h"
extern void hello_world(const char* text);

I’ve been wanting an easy way to capture screen demos and audio for a while and after stumbling across Jon Udell’s post on Movies of Software, I thought I’d give Windows Media Encoder a try. Here’s what I learned:

• I really like giving short little vignettes imagining an audience; I didn’t think I would
• The preparation for recording a screen demo is the same as a real demo, i.e. I want to make sure I know what I’m going to demo before I do it
• The preparation does not include lighting or another person to run a camera or a microphone, which means that I can do it on a whim at 5am on a Saturday morning
• My built-in mic at normal speaking volume works great
• Capturing a particular screen doesn’t work very well because I’m likely to move between windows without knowing that I will ahead of time. Instead, I should capture a region of the screen, ideally something not too large so that it fits well in a video window
• Medium quality may not be good enough. I did 13 minutes at medium quality, which resulted in a 3MB file and good audio, but the screen itself was nearly unreadable. Maybe the screen itself was too big?
• Stop other apps before capturing a screen, otherwise you’re bound to get slowdowns in the capture, particularly in the audio
• Talking in my kitchen at normal volume for 13 minutes will waken my wife (sorry, sweetie)

When I first read about MaxiVista, the thing that really got me interested was that it gave me two things that I really want from my Tablet PC. The 1st is to be able to use a slate-only Tablet as a 2nd monitor for my laptop so that I can continue my addiction to keeping my whole life on a laptop, but still be cool like the other kids (I’ve so far avoided multi-monitor setups because I love my laptop too much and I was afraid of the conflicting addictions).

The 2nd thing I get is a result of the first, i.e. if I’m going to use the Tablet as an adjunct to my laptop, then I shouldn’t worry about a generation sometime in the future where Tablet convertibles can replace my laptop, but just get the best slate I can find and enjoy it as a remote viewer/editor of info via file sharing and terminal services.

Today Ralph Loizzo asked me what tool I use to outline my objects, to which I replied:

The tool I use most often to design my systems is a text editor. I write my client code first against the objects I wish I had to obtain the first order of functionality I’m after, then implement those classes and refactor ’til I’ve reached a state of happiness between the clients and the object model.

For the last few months, I’ve been doing some really cool work with a group of folks whose only task is to build apps that exercise the WinFX technologies so that we can make sure stuff works the way we want it to and give feedback to the product teams when it doesn’t. Because we’re still in preview technology land, various features that we want to test are in various builds of each part of WinFX, so we’re constantly fooling around with new combinations of the bits, which we bring together in VPC HD images and that I then have to download. Since I’m downloading the 7+ GB images from my house over VNC and since the internal VNC connection software isn’t quite as robust as the VNC software we ship to the rest of the world, that means that I’m constantly being kicked off of my connection and reconnecting, sometimes 2 or 3 dozen times over the 2 days it takes me to download the image. I just finished downloading another build today.

Unfortunately, when setting the Administrator password, I managed to enter the wrong thing twice, which meant that I had no way to log into my new VPC image after 2 days of hard labor getting it to my house. So, instead of re-downloading it again, I googled for a utility to reset the Administrator password. The first link was a knowledge base article from MS that didn’t help me because I hadn’t yet logged in to make myself a password reset diskette (which, frankly, I never do anyway). The second link was a list of completely unsupported, possibly illegal, tools to reset the Administrator password. The first one on that list worked like a charm in several orders of magnitude less time than downloading a new VPC image.

DNR goes up and down like every other media outlet (it’s not unlike this very web site in that way), but I’ve really been enjoying it muchly lately. Not only did I get to hear someone besides my normal brethren talk about CAS in a way that didn’t make my flinch (Don Kiely on developing with least privilege), but I also got to listen to Mark Miller talk (at break-neck speeds) about my Dad freaking out when the jelly got into the peanut butter at the same time he was enthusing about CodeRush and telling Rory that he didn’t need counseling to deal with his relationship problems, he needed penicillin. Fabulous.

Lately, I’ve been running Virtual PC a lot to test various versions of WinFX on various platforms. To save me for locking any valuable code into a VPC HD, I use VPC shares, mapping Z to the D HD on my VPC host PC. That’s all well and good ’til I try to load a project from Z which, according to the OS, is a mapped network drive (in spite of the fact that it’s just the other partition on the very same PC), and Visual Studio complains that since I don’t have FullTrust on that drive, things may not work out the way I’d hoped (and for whoever decided to write the code and put up that message box, thank you!):

The project location is not trusted.

Running the application may result in security exceptions when it
attempts to perform actions which require full trust.

A friend of mine IM’d me just a few moments ago and asked, “When you’re sitting in front of a code editor and you have no motivation, what do you do?”

I hereby dub this “programmer’s block” and since I’ve never had it (which I’m just now realizing is pretty weird), I wondering if you can offer my friend some advice. Thanks!

I really love Mitch’s idea for a “Builder” in the Visual Studio Code View:

Have you got opinions about how information is arranged on MSDN? Do you have issues with the Table of Contents? Are you just looking for some way to fight back against the machine? If so, check out Paula Land’s blog.

Paula is MSDN’s Chief Information Architect and she’s provided a sneak peak at MSDN’s new TOC. If you’ve got comments, now’s the time.

Tim Ewald, one of my closest friends and the guy I think deserves to be much more famous (the first chapter of his criminally under-selling Transactional COM+ is worth the price of a Hawaiian honeymoon and is just as fulfilling) is blogging.

In fact, he’s been blogging for a few weeks now, but he’s teased me before, so I didn’t want to point people his way if he was just going to break my heart again. Still, he seems to be on a roll. My most favorite post is XmlSerializer sans XSD, but his recent post on why he cares about the angle brackets on the wire pushed me over the edge.

MSDN shipped their part of Visual Studio 2005 Beta 1 at about 12:30am on Tuesday morning. Sara has a nice summary of the new MSDN Product Feedback Center that I think folks will find particularly satisfying:

“At the MSDN Product Feedback Center, you can submit bugs and suggestions. You can search through other people’s submitted bugs and suggestions. You can vote for your favorites. You can share workarounds. And, you can see feedback and details directly from folks on our product teams. Oh, and you can get notified when the status of an issue you’re interested in changes.”

Joe Nalewabau, a Lead PM on the Visual C# team, admitted today that he was responsible for the VC# keyboard randomization process for Visual Studio 2005 and describes the thought process that he went through to get there. I admit that Joe makes a good case for changing the key bindings, but I hate the idea of learning a whole new set (especially since, because I’m a keyboard boy, I’ll be crippled until I learn the new bindings). If Joe would swear on a stack of user manuals that the key bindings would never, ever change again, I’d be happier about it. (Rocky: “Again? That trick never works!” Bullwinkle: “This time fur shure!“)

Of course, what I think doesn’t matter (it stopped mattering when I signed that damned employment contract : ). It’s what you think that matters and you should feel free to let him know what you think about the new VC# 2005 key bindings.

The great thing about multiple language teams in .NET is that each team can provide tools specific for their audience, like this leaked image of the Visual Basic 2005 context menu.

[via Don Box]

Lately, when the subject about how to actually secure a .NET app or component comes up, a magic phrase is uttered: “threat modeling.” Apparently, this is the thing that tells you how folks could use your well-intentioned code to do bad things. And on a mailing list with a fairly select membership (although not too select — I’m on it : ), the Swiderski, Snyder book Threat Modeling was recommended. And the free threat modeling tool that goes along with the book is hosted right on microsoft.com, which I take as a sign of quality. Model those threats towards a happier, healthier you!

[via Pierre Nallet]

After spending a bunch of time with various partial IBindingList implementations, I just stumbled onto a brand new one in the Visual Studio 2005 Community Technology Preview: BindingList. It’s not done yet, e.g. sorting doesn’t work, but the model is certainly what you’d want, e.g. you create a BindingList, bind it to something smart, like a DataGrid or a DataGridView, and you’re able to edit instances of your custom type or add or remove instances, as well as search or sort instances, just like you’d need a custom implementation of IBindingList for today. Very nice.

I find that in the process of learning about something, I often dig through a lot of places before I come up with what I’m looking for.

In the case of Visual Studio 2005 Team System (aka “Burton”), I wanted to know a lot more about the features that MS was building into VS for teams, including much more flexible source code control integration, web site functionality and stress testing, static code analysis like FxCop and perf. analysis built right into the build system and stats recording as part of the normal workflow for project management reporting.

Chad says:

“You are important to me! You spend your money and time on VS, and you expect VS to help you make more money and time. You will be using Whidbey to make your living, paying for braces and college and retirement, buying coffee and beer and cigarettes, contributing to political and social causes, paying income taxes and mortgage interest, ordering pizza and books and flowers.”

After posting a few sets of free Windows Forms controls, now I’m a magnet for the “but you forgot my favorite free controls site” emails, which I feel compelled to share with you. This time, it’s the vbAccelerator site, which is a mix of VB6 and .NET controls, code and tools. The .NET stuff is here. Enjoy.

In his June ’03 Bugslayer column, John Robbins made a sideways comment when discussing Son of Strike (SOS), a debugging extension from Microsoft for doing all kinds of low-level, mixed native and managed code debugging.

Rob Mensching, an MS SDE, has finally released his WiX tools for building MSI files from XML. I say “finally,” because I’ve been using his tools for months to build the MSI files that MSDN puts up on microsoft.com/download. All of our downloads have to be wrapped in an MSI so that you have to agree to the EULA before you get the files. Plus, we need to bundle some descriptive text and author name in there, along with the code that pops open the install folder after the files have been installed. Instead of using VS.NET to create the MSI files for each set of folks, I built a tool and the best programatic interface to creating MSI files that I could find was easily Rob’s. Check it out.

I swear I only stopped reading blogs for a coupla days, but interesting news has just surged! For example, I just found out that MSDN has an entire web site dedicated to extending VS.NET. This includes the legendary VSIP and a set of extensions that lets you build VSIP packages in managed code. Very cool.

[via Visual ActiveKent Sharkey .NET SE 3.11]

It’s well hidden, but Jason Olson points out that VS.NET Whidbey finally has a command shell built right in. Now if only it changed folders with my solution and support completion via the tab key, support F7 and F8…

I knew Mindreef had cool testing tools, but I just found one today on their web site that I ended up using all afternoon. You feed it a WSDL URL and it generates a form, allowing you to see the SOAP request and response packet in several formats include raw XML, to pseudo-code, pretty-printed XML and tree. It’s much more flexible then the built in one that ASP.NET provides and the price is right.

Mark Parks, a PM on the Visual C# Debugger QA team, has posted ways to fix common VS.NET debugger problems. He’s even got a fix for why I can’t debug the localhost version of my site. Thanks, Mark!

[via Duncan Mackenzie]

After much delay (man, this Microsoft gig keeps a person busy), I’m happy to announce Genghis v0.5:

In early 2000, Mike Woodring moved Heaven and Earth to write a tool that would inject a DLL into a process’s memory for purposes of finding the command line with which the process was launched. While hanging around Don and Tim this week, Don was all hot on WMI, so we fired it up in .NET and rebuilt Mike’s tool like so:

For those folks asking, another drop of Genghis is on the way, which includes an HTML link class that handles links for you, a user-sizeable panel, a gradient progress bar, a completely revamped FileDocument and a host of fixes and enhancements, including stacking support and terminal server support for toast windows. However, before that can come, Mike Marshall, the Genghis build-master, stopped to email me about the impending arriving of his first child. Now *that’s* dedication! I doubt if I’d stop to email any of the folks in charge of the shared source projects I’m involved with on the way to the hospital… : )

Given Aaron’s wonderful set of .NET XML tools, I don’t know why Tony Malandain found my little xmlValid tool for checking XML well-formedness and schema validness, but he did and then added the ability to take XML input from stdin (he apparently uses it to check compressed SVG files).

Plenty of folks have asked for updates to my IM client classes to support the new MSNP8 protocol, but only Robert M. Wagner Jr. made the changes and sent them to me. Thanks, Robert!

I used to brag that, unlike most C++ programmers, I learned C++ directly from the CFRONT 2.0 release notes and not from Stanley Lippman (his C++ Primer is a key part of C++ canon law). That boast came to a screeching halt when I had Stan in one of my COM courses and he revealed that he’d written the CFRONT 2.0 release notes.

And as if teaching the world C++ wasn’t enough, now that he works at Microsoft on the new Visual C++ and it’s new support for the .NET Framework in “Whidbey,” he’s started a blog to teach the world now only how VC++’s new tracking handle syntax (aka “hat”) but more importantly to point out *why* the VC++ went in this new direction.

CsvFileTester is a tool inspired by Shawn Wildermuth’s ExcelFileTester, which he wrote ’cuz I kept asking him how to do queries on .xls files. However, because the Excel query language has no where or order by clauses, I gave that up in favor of comma-separated text files.

FormatDesigner is an application to experiment with the format strings used to format data in String.Format and various type’s ToString functions.

Tired of the XmlSerializer’s generic “File or assembly name ctewkx4b.dll, or one of its dependencies, was not found” exception? The XmlSerializerPreCompiler tools checks to see if a type can be serialized by the XmlSerializer class and if it can’t, shows the compiler errors happening behind the scenes so that the type can be modified. Enjoy.

This just in: Mathew Nolton has posted a GUI front-end to my XmlSerializerPreCompiler that you might find useful. Thanks, Matt!

The fact that Windows XP Find in Files only searches files with known file extensions drives me crazy because it skips, among other things, .cs  files. Every time I set up a new system, I have to re-figure out how to fix this. To facilitate that, I put together a .reg file that will search all unknown file extensions as text files. Enjoy.

Sorry for the long wait. There’s been two whole books written between the last release of Genghis and this one. Here’s the list of new features:

• Everything works under .NET 1.0 and 1.1 (except HandleCollector)
• MSN Messanger-style popup window
• UI Type Editor for use with ImageList index selection
• AppBar implementation
• Text file search
• Themed controls
• Single instance application support, including passing command line args from other instances
• Multiple top-level window support
• Many enhancements and fixes to the command line parser
• Splash screen class
• Improved WebCommandLineHelper class which now works with .NET 1.0 and 1.1, includes URL decoding and requires no additional permissions (although it does require a server-side HTTP handler, included as the ConfigFileHandler class that maps requests for foo.exe?bar=quux.config to the foo.exe.config file)
• WizardSheet updates
• Status Bar Extender for mapping status messages to Windows Forms controls

I’m probably jumping into this topic a bit late but it doesn’t seem to end. I admit I haven’t read all article in this thread but I think I have an implementation solution for multiple dual interfaces on one class. And I would like opinions on it from others as well, and as to whether or not it displays proper COM implementation.

The implementation is very much like one that has been posted earlier, which I’ve seen different variations of many times before. However, I feel the one I am presenting allows all dual interfaces to be on one object and accessible via scripting without explicitly asking for a piece. No new interface definitions will be necessary with this technique. However, there may be one flaw. It will work ideally when none of the dispid’s of any of the dual interfaces collide, and when none of the named functions collide.

This page represents an attempt to capture the collective consciousness of the COM community. Of course, thoughtful feedback is welcome and encouraged (who the hell am I to voice the collective opinions of the entire COM community?). Once this is all sorted out, I anticipate never implementing IDispatch again (“Get COM+ now, I’ll show you how!“).

This page attempts to answer the question:

In writing the resources chapter of my WinForms book, I found that there was no single utility for displaying the resource contents of assemblies, .resx files and .resource files (even embedded .resources files) in a way that made sense to me. So, I built one and called it ResourceExplorer.

Scancode Mapper is a GUI tool for setting the Scan Code Mapper for Windows Registry settings for Win2K+:

I built the TAPI Explorer (tExplorer) to allow me to understand the various capabilities of the telephony devices installed on my system when I was developing TAPI applications and writing my TAPI book. It grew into a utility for showing all line, address and phone capabilities as well as other TAPI settings, e.g. country codes, telephony locations, service providers, etc. If you’re running into TAPI errors that you don’t understand, TAPI Explorer will help you work through them.

What’s new in Genghis v0.3:

• Screen shots for everything.
• Source available via CVS repository.
• MRU support, including both in-menu and sub-menu support.
• A much more robust set of validation components modeled along the lines of the ASP.NET validation components, including required, regex, range and comparison validators.
• FileDocument component for document/dirty bit handling.
• Wizard support, including changing page groups on the fly!
• Custom state treeview so that you can set and show all three checkbox states.
• A class to expose the WinForms HandleCollector so that you can put your own custom resources into it.
• A Screen Saver class.
• A bunch of file utility classes, including retrieving mapped drives, retrieving shares and path resolution.
• A cursor changer class that works with the using block.
• A WebCommandLineHelper class to parse command line arguments from the URL used to launch href-exes.
• Update to the FileNameDialog to include newish flags.

Thanks to all of the *very* active contributors, Genghis has doubled in size! This update includes:

• an automated nant build
• a framework for nunit tests
• an almost complete .NET implementation of SimplePad
• an imagelist combo box
• a preferences and window position serializer
• an MRU sample
• a custom state treeview class for doing tri-state checkboxes
• an update to ListViewSorter to make it declarative
• an expanded trace class for common tracing operations
• various other bug fixes

“The Typed DataSet that Microsoft generates from Visual Studio.NET (or from the XSD.exe tool), does not support derivation directly. In order to allow us to derive from Typed DataSets, Chris Sells and I created this tool that fixes the couple of issues with inheriting from Typed DataSets.”

“An obfuscator only delays the inevitable. With unlimited resources (time and money) and physical access to code, all code can be reverse engineered. This was true for native x86 binaries and it’s true for .NET Framework applications. What an obfuscator does is increase the cost of the effort required to reverse engineer obfuscated code. Hopefully, it increases the cost enough to make reverse engineering your code unpractical.”

“It’s easy to put Visual Build Pro to work doing all that manual labor for you so you can focus on more important things. Visual Build Pro is a powerful but affordable build management solution that will automate the build process without a huge commitment of time, and it works with the tools you’re using today.”

Eric Eric Friedman has submitted code to support namespaces and uninstall. The former fills the biggest hole in XsdClassesGen (thanks Eric), but why would anyone need the latter?!? : )

XsdClassesGen is a Custom Tool Add-In to VS.NET 2002 & 2003 to generate type-safe wrapper classes for serializing to and from XML documents. It takes as input an XSD and produces the C# or VB.NET code to do the serialization using the XmlSerializer. This is really just the output of running xsd.exe /classes, but integrated directly into VS.NET.

If you’d like to know more about what a custom tool is and how to build your own, check out CollectionGen.

Are you building and deploying .NET applications in a secure environment, e.g. over the intranet or the internet? If so, they you’ve probably mourned the loss of the binary and SOAP formatters that can automatically serialize a graph of objects that are marked as [Serializable] and that may also implement ISerializable and IDeserializationCallback. Both of these formatters are dependent on reflection, which will not be available in a more restrictive security environment. Likewise, even ISerialization.GetObjectData is verboten if you wanted to do this kind of thing yourself. As far as that goes, [Serializable] and ISerialization should be forbidden in a secure environment, as it allows a client to get and set the private variables of an object, potentially causing harm.

Still, security is the enemy of usability, to paraphrase Keith Brown. So, in the spirit of a balancing the design need for objects that can serialize themselves with the goal of complete disclosure in a secure world, I’ve built my own “safe” formatter. It only uses facilities of the runtime that work in the most secure environment of the default settings for the internet zone. So that objects can guard themselves against malicious data, I define a new interface called ISafelySerializeable that they need to implement to support this serialization facility. The protocol is exactly the same as ISerializable, so if that interface is already being implemented, the implementation of GetObjectData can be shared between both interfaces.

USE THIS FILE WITH CARE. It causes problems with image lists for .NET EXEs that don’t also use the same manifest file.

Just drop this devenv.exe.manifest file next to devenv.exe in your VS.NET install directory and the next time you start VS.NET under XP, it’ll look mostly the same! (well, maybe a little different : )

[Note: As of 5/5/03, the functionality of CollectionGen has been sucked into Eric Smith’s CodeSmith. I asked Eric to take on these features because CodeSmith does all of what CollectionGen does and more. All new feature requests/bug reports should go his way.]

CollectionGen is a Custom Tool Add-In to VS.NET 2002 & 2003 to generate type-safe collections. As it turns out, I did almost none of the work. Jon Flanders figured out how to add a custom tool. Shawn Van Ness implemented the template for type-safe collections. I just put it together.

RegexDesigner.NET is a powerful visual tool for helping you construct and test .NET Regular Expressions. When you are happy with your regular expression, RegexDesigner.NET lets you integrate it into your application through native C# or VB.NET code generation and compiled assemblies (usable from any .NET language).

Inspired by my need to know who was calling without hauling my butt off the couch to look at the caller ID on the phone across the room (my father always said that “laziness is the mother of invention”), I built a couple of C# classes for managing an IM connection and an IM session. The test client is a console application that just sends messages and dumps whatever it gets from the IM server to the console, but I think it would serve as the code is the beginnings of a real IM client. It does the MD5 stuff properly and handles being redirected to another IM server, so the hard part of the protocol is already implemented. The sample itself is a handy little program that logs in as an IM user, sends a message to another IM user and logs back off again. Perfect for annoying your office mates. Enjoy.

BTW, Harry Pierson has made a number of updates to this core code to support his full-blown  .NET IM client application. Check it out!

Welcome to Genghis

Genghis is a set of extensions built on top of .NET and integrated with WinForms to provide application-level services in the same flavor as the Microsoft Foundation Classes. Genghis gets its name as the functional heir to Attila, a similar set of functionality built on top of ATL.

If you haven’t seen it yet, check out the VS.NET Fun Facts piece that started as praise and bitching about VS.NET, but turned into something pretty useful if you’d like to get the most out of VS.NET.

Oct 10, 2001

I’ve updated CorPub to show *all* managed AppDomains by initializing the COR debugging sub-system prior to enumerating them. Thanks to Atif Aziz for the tip.

Aug 8, 2001

xmlValid is simple command line utility that will check an xml file for well-formedness and, optionally, will validate it against a supplied XML schema file (xsd). I built it to check that my site’s HTML files were well-formed (and therefore XHTML-compliance), but it’s got all kinds of other uses, including checking .NET .config files. Source is included. Enjoy.

Aug 7, 2001

Whenever I set up a new machine (which happens a lot as WinXP and .NET go through their beta & RC cycles), I always need to manually set up the completion character (to TAB, of course) in the Registry. Shawn VanNess posted a .rgs file that would set this up without the lengthy search through the Registry. Inspired by Shawn, here’s my own completionChar.reg that doesn’t require a program to parse .rgs files (which doesn’t come with Windows).

Wow. I’m impressed as all get out. Hugh Brown has reverse-engineered Gen as one of the tests of his NullScript implementation. I wish I would have had this when I started Gen a couple of years ago. It would’ve saved me figuring out how ASP did it.

My thinking along these lines years ago led me to go the opposite way, i.e. I built a front-end ASP parser that generated script for VBS. I called it TextBox (which, as a Win32 programmer, I should’ve realized was a terrible name…).

Here’s my moniker wizard that includes the framework used by the Basic Monikers.

The great and powerful Tim Ewald (author of Transactional COM+: Building Scalable Applications and personal friend of mine) put together a handy little set of COM+ classes and utility functions in a concise header file that he has graciously allowed me to host. Among my favorites are IsInActivity, IsInTransaction, IsSecurityEnabled, GetCallersName,  IsCallerInRole, and parameterized versions of CoGetObjectContext and GetAspObject (which is even cooler than my CAspPtr). Download the code! Buy the book! Feed your brain!

I got tired of not having getopt under Win32 and the best version to port doesn’t handle slashes (as per the Windows standard) or @files for arguments and it requires you to give away the source for every app that uses it, so, inspired by my friend Josh Gray,  I built my own. It supports typed flags and params, @file support and building full usages on the fly.

I’ve seen lots of interest lately in expando objects, e.g. objects that can add methods and properties on the fly. Joe Graf wrote a piece on IDispatchEx in MIND that was pretty interesting. My own implementation of IDispatchEx is available here. It supports expando objects that have no static properties or methods as well as those that do. Check out the DispExTest.js for a demonstration, dispeximpl.h, dynamemlist.h and dynamemlist.cpp for the implementation and MyExpando.h for the usage.

• WTL is, spiritually at least, what the MFC team would’ve come up with had they started with the C++ language as it is today. It’s an extension to ATL and available as a download from Microsoft.

• If you have trouble downloading WTL, see Petr Prikryl’s “Easy Installation of WTL” post on the Code Project site.

• WTL is pretty much completely undocumented, but you can read about it in a 2-part series by Chris Sells, Dharma Shukla and Nenad Stefanovic (chief engineer on WTL at Microsoft):

  1. WTL Makes UI Programming a Joy, Part 1: The Basics

  2. WTL Makes UI Programming a Joy Part 2: The Bells and Whistles

• You can also read about WTL on iDevResource: WTL Architecture by Dr. Richard Grimes. 

• WTL is officially unsupported, but the ATL mailing list has lots of coverage of WTL.

• The CodeProject is gathering a set of WTL resources at www.codeproject.com/wtl.

• Yahoo has a WTL newsgroup.

• WTL Quick Reference from Bryan K. Ressler

CComBool is a class to prevent the misuse of the VARIANT_BOOL type. VARIANT_BOOL is a problem because its legal values are -1 and 0 instead of 1 and 0, making converting back and forth between bool, BOOL and VARIANT_BOOL problematic. CComBool supports the constructors and operators needed to convert between the three C++ Windows Boolean types. It also supports operator& and CopyTo for common COM client and server usage. CComBool is available here.

The following table lists the various prices you pay for using the CRT and the default Win98 support in VC6. The builds were done with VC6, SP3, ATL COM in-proc server, no classes, no MFC, no merged p/s:

Dharma Shukla and I wrote “Extending ATL3.0 Containment to Help You Write Real-World Containers” in the 12/99 issue of MSJ detailing how to add much-needed features to ATL’s support for control containment. Dharma wrote the sample code that accompanies the piece and has already made improvements to the code based on feedback. He’s maintaining the history and bits here.

Attila stands for “ATL for Applications.” Attila is a set of extensions built on top of ATL to provide application-level services in the same flavor as MFC. Towards that end, Attila uses a lot of the same notions as ATL, e.g. heavy use of templates, static binding and reliance on the compiler and the linker doing their job.  Also, in the flavor of ATL, Attila is under-documented and requires a lot of user investment to make use of it. However, once you do, we think you’ll find the flexibility and efficiency worth it. If you don’t, you haven’t lost much, ’cuz Attila is free. Enjoy.

The Simple Object II ATL ObjectWizard Extension (whew — I’ve got to come up with a shorter name…) provides the following features:

I got tired of not having a smart type for SAFEARRAYs, so I built one. It’s limited to one dimension (does anyone use multi-dimentional SAFEARRAYs?) and provides one class for the SAFEARRAY and another for the data itself (the lock is a resource, too), but the usage is pretty nifty. See comvector.h for the what and the how.

This zip provides two classes for use with dates and times under Windows:

If you’d like to know about how to expose multiple IDispatch implementations from a single COM object, check out this extensive treatment of that very topic.

At atlmdi.zip, please find Charles Petzold’s famous raw Win32 MDI application, MDIDemo, ported to ATL. See atlmdi.h for a set of base classes for building MDI applications in ATL and mdidemo.cpp for an example of their use.

Are you getting this: “Error: object doesn’t support this property or method” when you try to call a method on your ATL HTML Control exposed external dispatch (accessed via window.external in the HTML of the control)? Did it used to work with IE4 and now it doesn’t with IE5? That’s because the ATL boys played fast and loose with the identity laws of COM and, while it took the COM police a while to catch up with them, catch up with them they did.

TraceHook is a member function call tracing delegator hook based on Keith Brown’s most excellent universal delegator. It allows you to write:

If you’ve ever had to write the code to pull the ASP intrinsic objects from the MTS context, you might appreciate CAspPtr, which allows the following:

STDMETHODIMP CJon::DoIt() {
  CAspPtr<IResponse> spResponse;
  if( spResponse ) {
    spResponse->Write(CComVariant(OLESTR("Baby got <b><i>Response</i></b>.")));
  }  
  return S_OK;
}

Visual Basic and its variants (sic) use IEnumVARIANT to implement the For-Each statement. Unfortunately, they only ask for 1 element at a time, leading to terrible performance across apartments. I propose two solutions. One allows you to wrap any collection in a CollectionBuffer object and set the buffering yourself, e.g.

Dim collBuffer As Object
Set collBuffer = CreateObject("SmartEnumSvr.CollectionBuffer")
collBuffer.Collection = coll ' coll is an interface on any collection
collBuffer.BufferSize = 1024 ' How many items would you like buffered?

c = 0
For Each v In collBuffer ' Uses SmartEnumVARIANT to buffer items
    c = c + 1
Next v
MsgBox "Counted " & c
	

The Problem

Not too long ago, Jonathan Borden, jborden@MEDIAONE.NET, posted a nifty class called IMarshalByValueImpl that implemented IMarshal for objects interested in being marshaled by value . It was built in the ATL style, i.e. it used fun template tricks, and depended on the COM class also implementing either IPersistStream or IPersistStreamImpl. And, in fact, ATL provides an implementation of IPersistStreamInit called IPersistStreamInitImpl. However, IPersistStreamInitImpl has one fatal flaw: it implements GetSizeMax by returning E_NOTIMPL. This breaks Jonathan’s IMarshalByValueImpl, which depends on a sane implementation of GetSizeMax from the class.

There are three kinds of ways to declare a dispatch-based interface in IDL, but ATL (as of version 3.0), only supports the implementation of 1.5 of them (duals and a raw dispinterfaces for handling events).  The ATL Dispatch Sampledemonstrations the use of three ATL-based classes, one for implementing each type of dispatch-based interface. The header file that defines these classes, dispimpl2.h, is provided for use in your own projects.

If you’re into COM Monikers, here’s one that I like.

• A brief description of the purpose and the implementation of the MeowMoniker.
• MeowMoniker.zip

Wish there was a moniker that did CoCreateInstance just like the Class Moniker calls CoGetClassObject? Wish you were able to compose the Class Moniker with a host name? Then you’ll want the BasicMonikers project, which bundles together the New moniker and the Host moniker. Sample syntax follows:

dm.newmk.1:Excel.Application
dm.newmk.1:00024500-0000-0000-C000-000000000046:
dm.hostmk.1:frodo:!dm.newmk.1:00024500-0000-0000-C000-000000000046:
dm.hostmk.1:frodo:!clsid:00024500-0000-0000-C000-000000000046:

regsvr.reg is a regedit script file that adds Register COM Server and Unregister COM Server to the context menu for DLLs, OCXs and EXEs under Win95+ and NT4+. In addition, it’s also been updated to add Register TypeLib and Unregister TypeLib commands to .tlb, .odl, .dll, .ocx and .exe files, using VC6′s new regtlib tool.

I’ve developed a set of macros to support implementing interfaces using nested composition in ATL (the one common way of implementing interfaces they neglected). The benefit of composition is that it is easy to implement multiple interfaces with methods with the same name but that require different behavior, e.g.

Have you ever been jealous of the VB programmer who could write this:

Have you ever been jealous of the VB programmer who could write this:

sub EnumVariants(col as Collection)
    dim v as variant for each v in col
        ' Do something with v
    next v
end sub

githelp.hdefines a set of wrappers for implementing inter-thread marshaling using the GIT instead of streams. githelp.cpp provides the non-inline implementation. For another spin on GIT usage, check out Don Box’s GitLip.

The Need for Code Generation

Have you ever wanted to generate code like the wizards do, i.e. start with a template, mix in some symbols and boom, out comes the code? If you’re building a custom AppWizard, you define code like so:

These are the outputs of my attempts to translate the native tz data into XML for easier parsing for applications other than implementations of the standard C routines related to time.

This is the first step in a project to merge time zone and map data by the Time Zone Map Group, lead by Chuck Ellis.

Genghis is a set of extensions built on top of .NET and integrated with WinForms to provide application-level services in the same flavor as the Microsoft Foundation Classes. Genghis gets its name as the functional heir to Attila, a similar set of functionality built on top of ATL.

Mon, 26 Jun 2000

To deal w/ the number of wrapped URLs I get in my email box, I built UrlRun. It checks the clipboard for an URL, no matter how broken, strips spaces, newlines and greater thans out of it and runs IE. To handle an URL as show above, select it, copy it to the clipboard and launch UrlRun.exe. I keep it on my QuickStart toolbar.

Attila GDI sample
(Jim Murphy likes Attila and GDI a little too much…)

Overview

MeowMoniker and Feline are COM objects designed and built by Chris Sells, with a great deal of input from Don Box and Tim Ewald. The MeowMoniker is a custom moniker derived from the CComMoniker class implemented by Don Box, Tim Ewald and Chris Sells.