Scott Hanselman

I got a disturbing email today on Flo's mailing list (of Notepad2 fame). Florian Balmer is the author of the most excellent Notepad2. This is a great "it just works" editor. It's Notepad, but goes one better, I like to say. I've promoted it on my Tools List and in countless talks. Notepad2 has been developed over ten years and is in active, ongoing development. Florian has posted most recently about his adventures in Unicode.

Flo was surfing and discovered http://www.notepad3.org.

This is uncool for a number of concrete reasons.

UPDATE/CORRECTION: I screwed up the licensing so my only complaints to the author of Notepad3 is that the name makes for a tacky fork and that the changes appear to be not significant in their scope. I apologize.

Notepad3 is a fork of a older version of Notepad2, specifically the GPL'ed Notepad2 1.0.12 rather than the BSD Licensed Notepad2 2.1.19. The GPL'ed Notepad2 was released on June 25th, 2004. The BSD licensed version was released on April 7th, 2007.

See, it turns out Netiquette CAN be subtle!

• The distributor of Notepad3 did not include Florian's license. 
  • UPDATE/CORRECTION: The license still is intact in the .c source code files, just not in the main license.txt. The full copy of the original Notepad2 license.txt also appears in Notepad3's source zip in c165/license.txt.
  • Notepad2 is distributed with this license (I snipped the copyright all caps at the end for brevity) as its main license.txt.
• Florian's name doesn't appear anywhere within the Notepad3 root license.txt, which appears to be an aggregate of a number of licenses of the sub-components.
  • UPDATE/CORRECTION: Flo's website is referenced in the license.txt's header.
• The Notepad3 "creator" didn't make any attempts to include his changes in Notepad2 or give Florian a heads-up.

Now, these next reasons are my own opinions, and possibly subtle. You tell me. These are my opinions.

• Mildly Tacky: They made up a new name and registered a new domain for the project. The new source can be only by found by digging around the main site. Can you find it?
  UPDATE/CORRECTION: I think the source should be linked directly to from the main page. Rather, it's under download/src using the navigation on the left of their site.
• Tacky: The new entity, Notepad3, arguably doesn't contain substantive improvements, certainly not enough to be called an entirely new version, and definitely not Notepad3. You can see the sum total of the changed lines on Flo's post.
• Rather Tacky: They took the time to put the new entity has been put up on Softpedia and promote it without a single reference to Florian or Notepad2.

It's not that Florian doesn't appreciate improvements. He has put a number of modified versions his side, including a very minor update by Wesner Moise and I. If he wanted to incorporate these changes into the mainline he could easily. I included a source diff for him, but most importantly I didn't make it look like his work was mine!

Modified Versions of Notepad2

• Notepad2 with Lua syntax highlighting - based on Notepad2 1.0.12.
• Notepad2 with NSIS syntax highlighting - based on Notepad2 2.0.18.
• Notepad2 with Ruby syntax highlighting - based on Notepad2 1.0.12.
• Notepad2 with Ruby syntax highlighting - based on Notepad2 2.0.15.
• NotepadCrypt - Notepad2 2.0.15 with file encryption features.
• Notepad2 MOD - SourceForge project based on Notepad2.

When people do Open Source work, one of the things that is almost universal is the natural human need for appreciation. For attribution. One overarching intent of the whole Creative Commons with Attribution license and most Open Source Licenses is "just don't remove the part that says *I did this!*"

Flo says it well, albeit with some understandable passion:

Nonetheless, the author has chosen the name "Notepad3". Compared with the original Notepad, Notepad2 represents an evolution with new features. "Notepad3" implies the same, but with even less features, without any new development. Seems that the play on words is used to fool users into believing that "Notepad3" is something more advanced. The popularity of Notepad2 is being taken advantage of to attract some attention ― I have no idea what else might be the motivation of the author.

The author justifies the publication of "Notepad3" with the added installation and documentation (which is actually my documentation, and has always been there). Innovation equals zero. This causes confusion about the different versions available, and the reputation of my software is harmed when associated with that kind of sloppy, offending descendants (and, it makes me think how indiscriminate some well-known software sites are concerning additions to their repositories).

I have no problem with new versions of my software being released, even with minor changes ― my licensing conditions are fully met. The problem here is that the author made minor changes to the code and branded it in a very disingenuous and deceiving manner.

Perhaps this is just a faux pas, a minor misunderstanding. However, I would encourage Readers who are interested in getting into Open Source to think about these issues when getting involved in projects.

My Own Experiences in Open Source

I've had a lot of great experiences and one speed bump.

WatirMaker

When I wrote WatirMaker and released the source, I had written it from scratch. Each time it got forked or written again or modified, the folks who did it let me know! They asked for help! I offered help! It was a lovefest - the kind of lovefest that I think Open Source should be.

The email conversations usually went like this:

Dude, heads up, I want to do _____

Sweet! Rock on, let me know if you want help with ____ or if/when/how we can put _____ back into the source. Wanna join the project!

Sweet! Dude! Rock on!

Yay! <Hugs.>

And the results were cool.

• Michael Kelly and John Hann wrote WatirMaker.rb, and command-line script in Ruby. Sweet.
• Rutger Smit overhauled the app and we re-released it as WatirRecorder++ and put it up at http://watir-recorder.openqa.org/ 
• My English buddy Richard Griffin not only fixed a bunch of my sloppy bugs but created WatinRecorder++ (Yes, that's WATIN, not WATIR!) and blogged about some cool design patterns using Wati*Recorder as a jumping off point.
• Alex Elder emailed me to refactor WatirRecorder. I said rock on. You can see there's a burst of work happening over there with checkin's just last months.

Notice how everyone is genial, chatting, and attributing? Even in Richard's WatinRecorder post, by now likely a complete re-write of my stuff, was thoughtful enough to thank a bunch of folks.

DasBlog

DasBlog, now the work of dozens, originally came from Clemens Vasters, who originally got it from Chris Anderson's BlogX had a similar issue happen when a gentleman forked our Source Code and created an entirely different project out of it with an all new name. This happened two years ago and he's since changed/refactored the project pretty substantially, but it still felt crappy at the time and the team was rightfully torqued. At the time, all that had been done was a recompile under VS2005 and a check-in as a new project with a new name.

Justice Gray blogged about it soon after:

Saying that "in the long term, ThinkJot will move away from the original dasBlog source code",  implies that all you've done is make some minor project ports, throw in a new DatePicker and call this your own project.  For sure, it's probably legally fine given the terms of the open-source license, but it leaves a bad taste in my mouth.  How would you feel if you worked on something for a long time and then someone just took all the work you did, rebranding it and called it their own?  I mean, c'mon!

Fortunately the author posted about this later and admitted this most important point:

"My biggest mistake has been that I never talked to the dasBlog team previously about this. I admit it, and apologize."

And I give him full credit for that simple admission. Folks that copy/fork are rarely evil or malicious. We're all just trying to move the ball forward, and perhaps that's the same in the case of Notepad3. However, that doesn't change the fact that talking to folks up front can make all the difference.

Unfortunately, at this point, this issue has soured Florian considerably:

I have been working on Notepad2 over more than 10 years, altogether. The above hacks may have been done in a few minutes.

There have been similar cases in the past, already, but this one really beats everything. I'm not sure if I'm going to release any more open source versions of Notepad2, in the future. Ain't fun like that.

Let's encourage Florian to keep up the great work and as we go about our lives as members of the Open Source community, let's remember to appreciate all the hard work that folks put into their various projects and that just because Copy/Paste is easy doesn't make it right.

My Tips? When in Doubt...

If you're doing Open Source and you're unclear about Netiquette, then:

• Just ask.
  • Ask someone working on a project how they do it.
• Err on the side of attribution.
  • You can't attribute or thank too many people, especially if you've copy/pasted something.
• Reach Out.
  • Email the authors. Talk to people, join mailing lists and for goodness sake, avoid working in a vacuum.
  • I still get emails about GlucoPilot, a shareware app I wrote almost 8 years ago. If I had the rights to the source, I'd give to the world. (Still working on that, actually)
• Appreciate your peers and everyone that contributes to the community.
  • Jeffrey Blankenburg has a clever idea, declaring July 3rd, "Contribupendance Day," while slightly ethnocentric ;) it's a great idea where Jeff is going to tell 5 people in his peer group how much he appreciates what they do and how they contribute by writing compliments and recommendations on their LinkedIn and Plaxo or Facebook pages. I think I'll do the same!

What do you think?

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By

A number of folks have asked me how to "implement the ASP.NET File Upload Control" except using ASP.NET MVC. This is a really interesting question for a number of reasons and a great opportunity to explore some fundamentals.

First, ASP.NET MVC is different since we don't get to use ASP.NET Server Controls as we're used to them. There's no "server controls" in the way that we're used to them.

Second, it'd be important to write Unit Tests for something like File Upload, and since ASP.NET MVC tries to be Unit Test friendly, it's an interesting problem to do tests. Why is it interesting? Well, ASP.NET MVC sits on top of ASP.NET. That means ASP.NET MVC didn't do any special work for File Upload support. It uses whatever stuff is built into ASP.NET itself. This may or not be helpful or interesting or even easy to test.

It seems then, that this is a good exercise in understanding a number of things:

• HTTP and How File Upload works via HTTP
• What ASP.NET offers for to catch File Uploads
• How to Mock things that aren't really Mock Friendly
• And ultimately, How to do File Upload with ASP.NET MVC

Here we go.

HTTP and How File Upload works via HTTP

It's always better, for me, to understand WHY and HOW something is happening. If you say "just because" or "whatever, you just add that, and it works" then I think that's sad. For some reason while many folks understand FORM POSTs and generally how form data is passed up to the server, when a file is transferred many just conclude it's magic.

Why do we have to add enctype="multipart/form=data" on our forms that include file uploads? Because the form will now be POSTed in multiple parts.

If you have a form like this:

<form action="/home/uploadfiles" method="post" enctype="multipart/form-data">
    <label for="file">Filename:</label>
    <input type="file" name="file" id="file" /><br />
    <input type="submit" name="submit" value="Submit" />
</form>

The resulting Form POST will look like this (slightly simplified):

POST /home/uploadfiles HTTP/1.1
Content-Type: multipart/form-data; boundary=---------------------------7d81b516112482
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; WOW64)
Content-Length: 324

-----------------------------7d81b516112482
Content-Disposition: form-data; name="file"; filename="\\SERVER\Users\Scott\Documents\test.txt"
Content-Type: text/plain

foo
-----------------------------7d81b516112482
Content-Disposition: form-data; name="submit"

Submit
-----------------------------7d81b516112482--

Notice a few things about this POST. First, notice the content-type and boundary="" and how the boundary is used later, as exactly that, a boundary between the multiple parts. See how the first part shows that I uploaded a single file, of type text/plain. You can interpolate from this how you'd expect multiple files to show up if they were all POSTed at once.

And of course, look at how different this would look if it were just a basic form POST without the enctype="multipart/form=data" included:

POST /home/uploadfiles HTTP/1.1
Content-Type: application/x-www-form-urlencoded
UA-CPU: x86
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; WOW64)
Content-Length: 13

submit=Submit

See how the content type is different? This is a regular, typical form POST. Perhaps atypical in that it includes only a Submit button!

The point is, when folks add a ASP.NET FileUpload Control to their designer, it's useful to remember that you're buying into an abstraction over something. In this case, you're using a control that promises to hide the whole multipart MIME way of looking at things, and that's totally cool.

Back To Basics Tip
Know what your library is hiding from you and why you chose it.

As an aside, if you looked at an email of yours with multiple attached files, it would look VERY similar to the body of the first HTTP message as multipart MIME encoding is found everywhere, as is common with most good ideas.

What ASP.NET offers for to catch File Uploads

The FileUpload control is just a control that sits on top of a bunch of support for FileUploads in ASP.NET, starting with the classes Request.Files and HttpPostedFile. Those are the things that actually do the hold on to the parsed Files from an HTTP Request. You can use them to get a hold of a stream (a bunch of bytes in memory that are the file) or just save the file.

Since we can't use ASP.NET Server Controls in ASP.NET MVC, we'll use these classes instead. Here's how you usually grab all the files from an upload and save them:

foreach (string file in Request.Files)
{
   HttpPostedFile hpf = Request.Files[file] as HttpPostedFile;
   if (hpf.ContentLength == 0)
      continue;
   string savedFileName = Path.Combine(
      AppDomain.CurrentDomain.BaseDirectory, 
      Path.GetFileName(hpf.FileName));
   hpf.SaveAs(savedFileName);
}

Of course, you might want to change the directory and filename, maybe check the mimeType to allow only certain kinds of files, or check the length to limit your uploads, but this is the general idea.

Note that Request.Files has been around since 1.x and isn't a strongly typed collection of anything, so the GetEnumerator() of .Files that we're using in the foreach returns strings that are then used as keys into the Files[] indexer. It's a little wonky as it's old.

However, don't let me get ahead of myself, let's write the tests first!

How to Mock things that aren't really Mock Friendly

After creating a new ASP.NET MVC Project and making sure to select a test framework, I'll drop into a Controller Test and make a new TestMethod that kind of looks like I expect my method to be used.

[TestMethod]
public void FakeUploadFiles()
{
   HomeController controller = new HomeController();

   ViewResult result = controller.UploadFiles() as ViewResult;
   var uploadedResult = result.ViewData.Model as List<ViewDataUploadFilesResult>;
   Assert.AreEqual(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "foo.doc"), uploadedResult[0].Name);
   Assert.AreEqual(8192, uploadedResult[0].Length);
}

This is incomplete, though, as I'm writing the tests before I the implementation exists. I need to think about how this should be implemented, and as I learn what should be mocked, I need to go back and forth between the tests and the implementation.

If we tried to compile this test, it won't, until I add a few types and methods. Once it actually compiles, but before I write the method itself, I'll want to see it FAIL. If you get a test to PASS on the first try, you don't really know yet if it CAN fail. Making it fail first proves that it's broken. Then you get to fix it.

Back To Basics Tip
Remember, in TDD, if it ain't broke, you don't get to fix it.

There's a bit of a chicken and the egg because it's unclear what will need to be mocked out until I start the implementation. However, this draft method above generally says what I want to do. I want to my controller to have a method called UploadFiles() that will grab the uploaded files from Request.Files, save them, then put a type in the ViewData saying which files were saved and how large they were.

Ok, take a breath. The following code may look freaky, but it's really cool actually. You can use any Mock Framework you like, but I like Moq for it's fluency.

We're having to "mock" things because we need to lie to our controller, who's expecting an HTTP Post, remember? It's going to go and spin through Request.Files and try to save each file. Since we want to test this without the web server or web browser, we'll want to tell the Moq framework about our expectations.

Back To Basics Tip
Be careful to mock context and assert outputs but don't mock away the whole test!

I've commented the code to explain...

[TestMethod]
public void FakeUploadFiles()
{
   //We'll need mocks (fake) of Context, Request and a fake PostedFile
   var request = new Mock<HttpRequestBase>();
   var context = new Mock<HttpContextBase>();
   var postedfile = new Mock<HttpPostedFileBase>();

   //Someone is going to ask for Request.File and we'll need a mock (fake) of that.
   var postedfilesKeyCollection = new Mock<HttpFileCollectionBase>();
   var fakeFileKeys = new List<string>() { "file" };

   //OK, Mock Framework! Expect if someone asks for .Request, you should return the Mock!
   context.Expect(ctx => ctx.Request).Returns(request.Object);
   //OK, Mock Framework! Expect if someone asks for .Files, you should return the Mock with fake keys!
   request.Expect(req => req.Files).Returns(postedfilesKeyCollection.Object);
   
   //OK, Mock Framework! Expect if someone starts foreach'ing their way over .Files, give them the fake strings instead!
   postedfilesKeyCollection.Expect(keys => keys.GetEnumerator()).Returns(fakeFileKeys.GetEnumerator());

   //OK, Mock Framework! Expect if someone asks for file you give them the fake!
   postedfilesKeyCollection.Expect(keys => keys["file"]).Returns(postedfile.Object);

   //OK, Mock Framework! Give back these values when asked, and I will want to Verify that these things happened
   postedfile.Expect(f => f.ContentLength).Returns(8192).Verifiable();
   postedfile.Expect(f => f.FileName).Returns("foo.doc").Verifiable();

   //OK, Mock Framework! Someone is going to call SaveAs, but only once!
   postedfile.Expect(f => f.SaveAs(It.IsAny<string>())).AtMostOnce().Verifiable();
   
   HomeController controller = new HomeController();
   //Set the controller's context to the mock! (fake)
   controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);

   //DO IT!
   ViewResult result = controller.UploadFiles() as ViewResult;

   //Now, go make sure that the Controller did its job
   var uploadedResult = result.ViewData.Model as List<ViewDataUploadFilesResult>;
   Assert.AreEqual(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "foo.doc"), uploadedResult[0].Name);
   Assert.AreEqual(8192, uploadedResult[0].Length);

   postedfile.Verify();
}

How to do File Upload with ASP.NET MVC

Now, what is the least amount of code in our Controller do we need to write to make this test pass? Here we get to use the Request.Files method that ASP.NET (not ASP.NET MVC) has had for years, and use it as advertised. It works in the tests and it works in production.

Important Note: We have to use the HttpPostedFileBase class, rather than the HttpPostedFile because every Request, Response, HttpContext and all related ASP.NET intrinsic abstractions are one layer farther way in ASP.NET MVC. If you get an HttpRequest in ASP.NET, then in ASP.NET MVC at runtime...

• you'll get an HttpRequestWrapper while running under a Webserver
• you'll get a dynamically generated derived Mock of an HttpRequestBase while running outside a Webserver (like inside a test) when you've made your own ControllerContext.

In each case, the instances you'll get are both (ultimately) of type HttpRequestBase, but it's this extra layer of abstraction that makes ASP.NET MVC easy to test and ASP.NET WebForms less so. I hope these Wrappers will be included in a future release of WebForms. The fact that they live in the System.Web.Abstractions.dll and not System.Web.Mvc.Abstractions.dll tells me someone has their eye on that particular ball.

At any rate, here's the Controller that takes File Upload requests:

public class ViewDataUploadFilesResult
{
   public string Name { get; set; }
   public int Length { get; set; }
}

public class HomeController : Controller
{
   public ActionResult UploadFiles()
   {
      var r = new List<ViewDataUploadFilesResult>();

      foreach (string file in Request.Files)
      {
         HttpPostedFileBase hpf = Request.Files[file] as HttpPostedFileBase;
         if (hpf.ContentLength == 0)
            continue;
         string savedFileName = Path.Combine(
            AppDomain.CurrentDomain.BaseDirectory, 
            Path.GetFileName(hpf.FileName));
         hpf.SaveAs(savedFileName);

         r.Add(new ViewDataUploadFilesResult() 
            { Name = savedFileName, 
              Length = hpf.ContentLength });
      }
      return View("UploadedFiles",r);
   }
}

At the bottom where I ask for the "UploadedFiles" view, and I pass in my list of ViewDataUploadFilesResults. This will appea in the ViewData.Model property. The View then displays them, and that's ALL the View does.

<ul>
<% foreach (ViewDataUploadFilesResult v in this.ViewData.Model)  { %>
       <%=String.Format("<li>Uploaded: {0} totalling {1} bytes.</li>",v.Name,v.Length) %>
<%   } %>    
</ul>

Conclusion

I always encourage people to take the little bit of time to use Fiddler or SysInternals or look at your call stack or just to take a breath and remind oneself, "so how is this supposed to work?" Otherwise, one is just cargo-cult programming.

This post was a long answer to the question "How do I do FileUpload with ASP.NET MVC?" but I feel better having written in this way.

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By

My one-hundred-and-nineteeth podcast is up. In this episode, I chat with Ken Schwaber. Ken bends my reality by helping me define the word "Done." In the process, I learn more about the right questions to ask when managing an Agile Project.

"Ken Schwaber co-developed the Scrum process with Jeff Sutherland in the early 1990s to help organizations struggling with complex development projects. One of the signatories to the Agile Manifesto in 2001, he subsequently founded the AgileAlliance, a nonprofit organization dedicated to the creation of Agile software. He then founded the ScrumAlliance, a nonprofit organization dedicated to expanding the understanding of Scrum."

• Ken Schwaber speaking on Scrum at Google (Video)
• Agile Project Management with Scrum (book)
• The Agile Manifesto
• Control Chaos
• Agile Alliance

Subscribe:

• Download: MP3 Full Show
• Torrent: Download via µtorrent
• ACTION: Please vote for us on Podcast Alley! Digg us at Digg Podcasts!

If you have trouble downloading, or your download is slow, do try the torrent with µtorrent or another BitTorrent Downloader.

Do also remember the complete archives are always up and they have PDF Transcripts, a little known feature that show up a few weeks after each show.

Telerik is our sponsor for this show.

Telerik's new stuff is pretty sweet, check out the ONLINE DEMO of their new ASP.NET AJAX suite. RadGrid handles sorting, filtering, and paging of hundreds of thousands of records in milliseconds, and the RadEditor loads up to 4 times faster and the navigation controls now support binding to web services on the client.

As I've said before this show comes to you with the audio expertise and stewardship of Carl Franklin. The name comes from Travis Illig, but the goal of the show is simple. Avoid wasting the listener's time. (and make the commute less boring)

Enjoy. Who knows what'll happen in the next show?

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By

I posted a little rant against the Northwind Database a few weeks back, and suggested that we, the community, create a better demo database than Northwind.  I proposed the name NotNorthwind.

There were some varied and interesting responses.

From Scott Mitchell:

Yes, it is far from perfect and could use some updating with regards to the date/time values and the category pictures, but those warts aside, it does a good job at what it was designed to do.

From Brian Sullivan:

I feel the same way. I have to stifle a groan whenever I hear the word "Northwind" come out of presenter's mouth. I've even jokingly said that Microsoft ought to have an internal metric for new technologies called "TTN", "Time to Northwind." In mathematical terms:
Product Coolness = 1 / TTN

From Duncan Smart:

We don't a need a new one! Pubs FTW! :-)

Steven Smith says Whither Northwind?

Enter NorthWind, the HTTP standard of databases, understood by virtually all Microsoft developers without need for preamble.  It just works.  With the words, "I'm using Northwind for my database." I now have the complete understanding of 95% of the people in the room - we're all on the same page - and I can continue with the actual point of the presentation or demo, which is not, has not, and probably will never be, "why this database isn't Northwind."

And Jeff Atwood from Twitter ;)

@shanselman rejects the standard MSFT Northwind database. What next? "Hello World" isn't good enough for you? Snob!

There were also a lot of great comments and ongoing discussion the CodePlex site's Discussions tab and project comments. We brainstormed alternative domains like Medical, Insurance, Media, and many others. Others suggested that AdventureWorks was a fine replacement.

ASIDE: Some folks suggested just updating the dates in Northwind to the present, but as attractive as the idea of adding ELEVEN YEARS to these columns is, I just didn't feel like doing this (Thanks to the folks on Twitter for their ideas, though!).

use Northwind
update Employees set BirthDate = dateadd(yy, 11, BirthDate)
update Employees set HireDate = dateadd(yy, 11, HireDate)
update Orders set OrderDate = dateadd(yy, 11, OrderDate)
update Orders set ShippedDate = dateadd(yy, 11, ShippedDate)
update Orders set RequiredDate = dateadd(yy, 11, RequiredDate)

We had a SkypeCast call today at noon and it was agreed that Northwind does have some redeeming qualities. It's simple, it works, it's understood and there's a pile of demos written against it. We rethought the requirements.

As a small group, we've decided to extend Northwind. We'll still call it NotNorthwind (although Super Northwind 2000 and "Microsoft Visual Northwind Enabler SP2 RC0 Beta1 July Refresh Plus Pack" were also possibilities), though, but we want to add a bunch of features that should make it a more interesting database for demos/prototyping/experimenting.

It's worth pointing out that I (and we) are not interested in showcasing the shiniest, latest new thing in SQL2008 with this small effort. We're just trying to have a little fun, while updating a very old database with some interesting and fun features in the hopes that our demos/prototypes/experiments/whatever that use Northwind could possibly become more interesting.

• Product Reviews and Ratings
• This new area should introduce a number of interesting, but easily understood concepts that can be used to showcase everything from whatever cool AJAX toolkit you're demoing to how flexible your CodeGenerator or ORM is.
• Perhaps extending reviews to "x people found this review helpful" as well. Also, wish-lists, etc.
• Tagging
• In parallel to, and juxtaposed against the existing Product/Category relationship, tagging, and social tagging, introduces some interesting DB issues as we'll want to tag anything not just products, resulting in a many-to-many heterogeneous situation.  It also makes for some potentially interesting User Interfaces.
• Compatibility
• We're going to pretend that the existing database can't be changed, but only extended.  This way folks with existing Northwind Demos will "just work" against NotNorthwind. This plug-ability should also encourage people with demos to extend their existing those of things like web frameworks but are just using the database as a place to find scenarios.
• We'd like it to support (either via creative SQL or multiple versions) multiple databases like mysql, SQLite, Oracle, etc.
• We'd like it to be an existing "legacy" database that ORM tools could each build on top of so we could compare apples to apples.
• Sample Data
• At some point it'd be cool to make the database REALLY HUGE to test the scale of both it, and the things folks build on top of it.
• We'd like pluggable Sample Data, so we'll make the structure file separate from the sample data. Basically Database "Themes" as not everyone wants the standard Microsoft "scrubbed" names.
• Alternate Domains
• We also think that the Northwind world could be explored with more "Vertical" things like these. These could also be done without changing the core database.
• Expense Tracking and Approval
• Accounts Receivable and Payable and Payroll
• Business Intelligence - Warehousing, Sales, Trends

That's about it. I'll update the Issue Trackers and we'll try another SkypeCast same time next Thursday around noon. I'll announce the SkypeCast URL on Twitter. (AYNABTU)

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By

Someone said today after seeing the C# var operator for implicitly typed variables, "Oh, now C# has Dim." Well, not exactly. Not even close.

I like what this C# tutorial says about var.

...[var is] a new keyword that means, "I want to declare a variable, but I’m too lazy to write out its type."

One way to look at the power of VB's Dim operator is to say,

Dim kind of means, "I want to declare a variable but I can't tell you much about how it behaves until much later."

Dim lets you do actual late-binding while in C# (today) you do late-binding with reflection. I wanted to find a way to clearly express this in a very visceral sample.

A friend wanted to change a value in the CustomDocumentProperties in Word and see that change reflected in an updated field. In the document properties dialog below, you can see there's a "CustomProperty1" that has the value of "Scott" in it. Then in the document, there's a Field that is bound to that property. It's not meant to be a mail merge, but more of a MadLibs kind of a thing for writing applications that update forms and templates within Word or Excel documents.

His language of choice is C#, so he started off in C#. He added a reference to the Microsoft.Office.Interop.Word PIA (Primary Interop Assembly) and fought with the  system for some hours. After a while, I got enlisted, and after I figured out that the specific COM interface he needed was a late-bound IDispatch interface, we were able to crack with the Reflection.

I'm starting to think of Reflection much the way I think about Regular Expressions. If you have to solve your Problem with Reflection, you may just end up with Problems, plural!

Notice a few things. First, the need for some of those obvious strings and booleans to be of type Object. Notice all the System.Reflection.Missing.Values passed by reference. Most of all, notice the custom GetCustomPropertyValue and SetCustomPropertyValue that had to use Reflection.

  ApplicationClass WordApp = new ApplicationClass();
  WordApp.Visible = true;
  object missing = System.Reflection.Missing.Value;
  object readOnly = false;
  object isVisible = true;
  object fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\NewTest.doc");
  Microsoft.Office.Interop.Word.Document aDoc = WordApp.Documents.Open(
      ref fileName,ref missing,ref readOnly,ref missing,
      ref missing,ref missing,ref missing,ref missing,
      ref missing,ref missing,ref missing,ref isVisible,
      ref missing,ref missing,ref missing,ref missing);

  aDoc.Activate();

  string propertyValue = GetCustomPropertyValue(aDoc, "CustomProperty1");
  SetCustomPropertyValue(aDoc, "CustomProperty1", "Hanselman");

  foreach (Range r in aDoc.StoryRanges)
  {
     r.Fields.Update();
  }
}

public string GetCustomPropertyValue(Document doc, string propertyName)
{
  object oDocCustomProps = doc.CustomDocumentProperties;
  Type typeDocCustomProps = oDocCustomProps.GetType();
  object oCustomProp = typeDocCustomProps.InvokeMember("Item",
        BindingFlags.Default |
        BindingFlags.GetProperty,
        null, oDocCustomProps,
        new object[] { propertyName });

  Type typePropertyValue = oCustomProp.GetType();
  string propertyValue = typePropertyValue.InvokeMember("Value",
       BindingFlags.Default |
      BindingFlags.GetProperty,
      null, oCustomProp,
      new object[] { }).ToString();

  return propertyValue;
}

public void SetCustomPropertyValue(Document doc, string propertyName, string propertyValue)
{
  object oDocCustomProps = doc.CustomDocumentProperties;
  Type typeDocCustomProps = oDocCustomProps.GetType();
  typeDocCustomProps.InvokeMember("Item",
        BindingFlags.Default |
        BindingFlags.SetProperty,
        null, oDocCustomProps,
        new object[] { propertyName, propertyValue });
}

There's a great article from 7 (yes SE7EN) years ago on Dr. Dobb's about Invoking COM Components from C# that provided me this diagram. The RCW (Runtime Callable Wrapper) sits in front of the COM Object and makes my reflection calls work.

Sure, I could have created some IDL and laid out an IDispatch implementation for these CustomDocumentProperties, but that's getting REALLY involved. Actually, there's supposed to be an implementation for CustomDocumentProperties but the MSDN Sample fails with this:

"Unable to cast COM object of type 'System.__ComObject' to interface type 'Microsoft.Office.Core.DocumentProperties'. This operation failed because the QueryInterface call on the COM component for the interface with IID '{2DF8D04D-5BFA-101B-BDE5-00AA0044DE52}' failed due to the following error: No such interface supported (Exception from HRESULT: 0x80004002 (E_NOINTERFACE))."

Competing with that non-working MSDN sample is this KB article from 2007 that provided the bulk of the yucky, but straightforward reflection code.

Why is this a Back to Basics post? Well, two fold. First, COM is Old and it's Basic. Seriously, though, the secondly (and only) reason is that, in my opinion, C# 3.0 is lousy for this kind of late-bound, COM-interop, Office Automation work.

Don't believe me? Here's the same code in VB. See the named parameters on the Open()? Notice the late-bound COM stuff just works without Reflection? (I've got Option Strict to Off for this code)

Dim WordApp = New Microsoft.Office.Interop.Word.ApplicationClass
WordApp.Visible = True

Dim fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\..\..\NewTest.doc")
Dim aDoc As Document = WordApp.Documents.Open(FileName:=fileName, ReadOnly:=True, Visible:=True)
aDoc.Activate()

Dim PROP = "CustomProperty1"
Dim propertyValue = aDoc.CustomDocumentProperties(PROP).Value
aDoc.CustomDocumentProperties(PROP).Value = "Hanselman"
For Each r As Range In aDoc.StoryRanges
   r.Fields.Update()
Next

VB.NET is really well suited for this kind of thing, and my buddy will likely use it in this scenario.

I hear this big difference in dynamism will change for the next version of C#. I'll talk to the team and try to get some details or rewrite my C# sample in C#.Next. I've also asked John Lam to help me write this sample in IronRuby. I suppose it'd look nice in PowerShell also.

The Point is, and until some future date, var != Dim.

The Back to Basics thing to remember is that the language you know might not always be suited for the problem you have. Just because you CAN solve a problem in a certain language doesn't mean that you should. If something REALLY doesn't feel right in a certain language, ask around, perhaps there's another that makes more sense for what you're trying to do.

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

About   Newsletter

Hosting By