softlogger Latest Articles ::ASP-NET

CurrentCulture, CurrentUICulture and DateTime strings

Kathy Kam — 2008-03-11T00:00:00

There are a lot of blogs out that that tries to explain which is what, and why it is the way it is.

To those of you who just want to know what the results are. I wrote a quick little app to show what happens.

As you can see, DateTime.ToString() formatting is driven purely by CurrentCulture.

You can read more about the reasons and background here:

For other DateTime Format String info, check out my blog post ".NET Format String 102: DateTime Format String".

Silverlight 2 Beta 1 Control Samples

Kathy Kam — 2008-03-05T00:00:00

My sample and its source is now live on http://silverlight.net! It show case a variety of controls we have built for the Silverlight 2 Beta 1. We have quite an good set of controls. It shouldn't surprise my readers to know that we have a DatePicker and a Calendar. :) And yes, I am the PM for those features. So for those of you who are sick of using my Silverlight 1.1 Calendar/DatePicker. Pick up the latest Silverlight 2 Beta 1!

Silverlight Control Demo Sample
Uploaded on March 5
Created by: Kathy Kam

A sample of twenty-four Silverlight 2 controls that can be viewed live together with the source code used to drive the controls.

Check out other samples here:

http://silverlight.net/community/gallerydetail.aspx?cat=5&sort=1#vid1080

Also, as mentioned by ScottGu this morning. You can download the source and unit tests to all the controls here:

http://www.microsoft.com/downloads/details.aspx?FamilyID=ea93dd89-3af2-4acb-9cf4-bfe01b3f02d4&displaylang=en

Love to hear what you think! I am excited to see applications people build with these controls. Tell me what you are building!

Compression Decompression in .NET

Dutts DOTNET Support — 2008-02-12T00:00:00

Learning .NET debugging

If broken it is, fix it you should — 2008-01-30T00:00:00

I often get questions like How do I learn .net debugging? What books should I read? Where can I find more information?

I know everyones learning style is different so this might not be the best way for you, but the way I try to learn things is by "teaching". For example the way I started out with .net debugging was by putting together a really silly .net debugging web cast series with one of my colleagues. Looking back at them now they make me laugh, both because seeing yourself on video is just horrible, and because of how convoluted we made things because of how little experience we had with debugging .net.

The reason learning by teaching works for me is because if I have to explain something to someone else I do a lot more research. If I read a book or go through a course I tend to skip over things and think "yeah, I pretty much know how that works so I won't worry about it" so I never delve into those things. Blogging also makes me have to research a lot more and not leave it at "I have a pretty good idea what the issue is" but instead go deeper and really understand the issues, which gives me knowledge that I can reuse in other situations.

The other obvious and natural benefit from learning by teaching is that you spread the wealth and oftentimes I find that if I really go through with actually presenting it, I also get a lot of feedback helping me understand the issues even further. Sometimes though I just leave it at researching as though I would explain the topic to someone else but never end up doing it (because the issue is really well explained already somewhere else).

The only drawback I see with this for me is that when you're in the learning phase you don't really have the experience that I feel makes a good teacher, and sometimes like in the case of the debugging web casts you do things in convoluted ways in the beginning because you don't know the shortcuts. Still I think it is a worthwhile learning method, especially on topics that are not all that explored and where there is not much good course/training material in existence.

With debugging specifically, I think there is no better way of learning debugging than creating your own issues and debugging them. For example, set up a demo that you know will crash the process or hang the process or cause a memory leak and debug it. It works extremely well for the beginning stages since you know what you are expected to find.

I was thinking of starting a quick series of demos that can be used to practice debugging. Most of them items that I have already posted solutions to here, but with code and "lab" hints. Would that be of interest? if you are interested, just send a quick yes in the comments or contact me by email so I can gauge if it is something that would make sense to do...

Ok, that was a whole lot of rambling about my learning style:) having said this... here are some blogs that I subscribe to with good debugging/asp.net information if you want to learn debugging or keep your debugging skills up to date...

Support blogs with debugging case studies

Speaking of which... (Johan Straarup) http://blogs.msdn.com/johan
A developers stayings (Carlo Cardella) http://blogs.msdn.com/carloc
Notes from a dark corner (Doug Stewart) http://blogs.msdn.com/dougste
Cheshire's blog (Jim Cheshire) http://blogs.msdn.com/jamesche
ASP.NET debugging (Tom Christian) http://blogs.msdn.com/tom
Nico's weblog (Nicolas Dietrich) http://blogs.msdn.com/nicd
Solving the world's problem, one support incident at a time... (Lucas Canavan) http://blogs.msdn.com/lucascan
Todd Carter's weblog (Todd Carter) http://blogs.msdn.com/toddca

Other debugging related blogs:

Debugging toolbox - http://blogs.msdn.com/debuggingtoolbox
Dotnet debug - http://dotnetdebug.net
NT Debugging - http://blogs.msdn.com/ntdebugging
John Robbin's blog - http://www.wintellect.com/cs/blogs/jrobbins/default.aspx

Other ASP.NET blogs:

ASP.NET Team blog - http://weblogs.asp.net/aspnet-team
Scott Gu's blog - http://weblogs.asp.net/scottgu

CLR Blogs:

CLR, Architectures and stuff - http://blogs.msdn.com/patrick_dussud
Maoni's weblog - http://blogs.msdn.com/maoni

and dont forget the Debugging Microsoft .NET 2.0 Applications book by John Robbins

Laters,

Tess

Strongly Typed Datasets (.NET 2.0) - Course Notes

VB & .NET Blogs @ vbCity.com — 2008-01-24T00:00:00

This course was created for the VBCity Academy where you can take online courses for free. Unfortunately, the material I wrote is something I constantly want to keep linking to - so I've decided to place the course up as a flat article.

I fully recommend that the take the course through the Academy where the structure and flow of the course should make a little more sense - however, if big long documents are your thing - check out the article at http://blogs.vbcity.com/drydo/articles/8959.aspx.

It's .Net Source Day! Let the Source Loose.... Today is the day you can configure VS2008 to grab the actual source code to the .Net Framework and step into it as you debug...

Gregs Cool [Insert Clever Name] of the Day — 2008-01-20T00:00:00

ScottGu's Blog - .NET Framework Library Source Code now available

"Last October I blogged about our plan to release the source code to the .NET Framework libraries, and enable debugging support of them with Visual Studio 2008. Today I'm happy to announce that this is now available for everyone to use. Specifically, you can now browse and debug the source code for the following .NET Framework libraries:

.NET Base Class Libraries (including System, System.CodeDom, System.Collections, System.ComponentModel, System.Diagnostics, System.Drawing, System.Globalization, System.IO, System.Net, System.Reflection, System.Runtime, System.Security, System.Text, System.Threading, etc).

ASP.NET (System.Web, System.Web.Extensions)

Windows Forms (System.Windows.Forms)

Windows Presentation Foundation (System.Windows)

ADO.NET and XML (System.Data and System.Xml)

We are in the process of adding additional framework libraries (including LINQ, WCF and Workflow) to the above list. I'll blog details on them as they become available in the weeks and months ahead.

Enabling Reference Source Access in Visual Studio 2008

Enabling .NET Framework source access within Visual Studio 2008 only takes a few minutes to setup. Shawn Burke has a detailed blog post that covers the exact steps on how to enable this in more depth here. .

.."

Shawn Burke's Blog - Configuring Visual Studio to Debug .NET Framework Source Code

"It's finally here - the launch of the .NET Reference Source project. This post (hopefully!) contains everything you need to know. Over the past few weeks, we ran a pilot of this feature and collected lots of great data that helped us work through some issues and understand where people were likely to have problems.

First, though, if you have any problems, please make sure you've followed all of the steps exactly as described. If you're still having problems, please check the FAQ/Troubleshooting section at the bottom. If that doesn't work, post a comment below and I'll look into it.

Basic Setup

..."

Following Shawn's directions, it takes 5-10 minutes (or less) to configure your VS2008 (all editions except Express) to go to a MS site, download the symbols for the .Net Framework, which then leads to the magic of downloading the actual .Net source (if it's available).

We're talking source source... Comments and all. And everything "works." Watches, debug visualizers, etc, etc.

Wow. That's just COOL.

Thanks to Scott (scottisafool) for the second head's up of the day...

Writing a custom ASP.NET Profile class

JonGalloway.ToString() — 2008-01-20T00:00:00

We made heavy use of the ASP.NET membership and profile system for Video.Show (a Silverlight 1.0 video community website system, available on CodePlex). In addition to storing basic profile information, we created a custom profile with some additional fields. It's a really easy way to add add some additional personalization to your site without having to add a bunch of tables to your database.

This is really simple if you're using a Website Project - you can just add additional properties to the profile section of your web.config, and a custom profile class is generated on the fly when you rebuild your application. That makes things ridiculously easy. First, we'd define the property in web.config:

<!-- In web.config -->
<profile >
  <properties>
    <add name="FavoritePasta" />
  </properties>
</profile>

Then you can refer to the Profile.FavoritePasta profile setting anywhere in your web application, and it's automatically mapped to the current user:

Profile.FavoritePasta = "Pumpkin Ravioli";

And you can access the data just as you would a session property:

<span id="user-favorite-pasta"><%= Profile.FavoritePasta %></span>

Not so fast, I'm using a Web Application Project

Yeah, here's the catch. If you're using the Web Application Project model, the custom build handling for the profile doesn't kick in, so those custom properties you've lovingly crafted in your web.config aren't going to be compiled into a custom profile class.

There's a Visual Studio 2005 add-in called WebProfile that reads your custom profile and creates a custom class for you. That's handy, but I passed on it. For one thing, I haven't heard that there's a VS 2008 version of this. Additionally, I don't like to require a custom add-in in order to get my code to work in case I want to add a new profile property - especially when I'm working on a project that's going to be distributed on CodePlex.

Fortunately, it's not very hard to implement a custom profile. First, we'll write a class that inherits from System.Web.Profile.ProfileBase. I added a few static accessors, too:

using System.Web.Profile;
using System.Web.Security;

namespace VideoShow
{
    public class UserProfile : ProfileBase
    {
        public static UserProfile GetUserProfile(string username)
        {
            return Create(username) as UserProfile;
        }        public static UserProfile GetUserProfile()
        {
            return Create(Membership.GetUser().UserName) as UserProfile;
        }

        [SettingsAllowAnonymous(false)]
        public string Description
        {
            get { return base["Description"] as string; }
            set { base["Description"] = value; }
        }

        [SettingsAllowAnonymous(false)]
        public string Location
        {
            get { return base["Location"] as string; }
            set { base["Location"] = value; }
        }

        [SettingsAllowAnonymous(false)]
        public string FavoriteMovie
        {
            get { return base["FavoriteMovie"] as string; }
            set { base["FavoriteMovie"] = value; }
        }
    }
}

Now we need to hook that up in the profile section of web.config - notice that I've included inherits="VideoShow.UserProfile" in the profile declaration:

<profile inherits="VideoShow.UserProfile">
  <providers>
    <clear />
    <add name="AspNetSqlProfileProvider" type="System.Web.Profile.SqlProfileProvider" connectionStringName="VideoShowConnectionString"/>
  </providers>
</profile>

With that done, I can grab an instance of the custom profile class and set a property:

//Write to a user profile from a textbox value
UserProfile profile = UserProfile.GetUserProfile(currentUser.UserName);
profile.FavoriteMovie = FavoriteMovie.Text;
profile.Save();

Part of the reason for the accessor is to allow display of profile information for users other than the current user - for instance, a public profile page which displays information about other users in the system.

//Write to a user profile from a textbox value
UserProfile profile = UserProfile.GetUserProfile(displayUser.UserName);
Response.Write(profile.FavoriteMovie)

And of course, I can still databind to it as well:

<span id="user-favorite-movie"><%= VideoShow.UserProfile.GetUserProfile().FavoriteMovie %></span>

A few disclaimers:

This isn't news, it's been out since ASP.NET 2.0 shipped. Still, it's pretty handy to know about, and if you're like me you may have forgotten or never really dug into some of the ASP.NET 2.0 goodies.
This isn't the ultimate solution in terms of entity modeling. Custom profile information is stored in two columns in the aspnet_Profile table (delimited strings in one column, another column for binary serialized objects). That means that the only real way to read or write custom property values is via the profile API. That's not a real problem unless you need to query or join on information stored in a custom profile setting.

Further information:

Profiles in ASP.NET (K. Scott Allen)

Essential ASP.NET 2.0, Chapter 5 (Fritz Onion)

.NET Framework Library Source Code Available - Browse ASP.NET, Winform, and ADO.NET Production Code

David Hayden - Florida .NET Developer - C# and SQL Server — 2008-01-19T00:00:00

.NET Framework Library Source Code Available - Browse ASP.NET, Winform, and ADO.NET Production Code

by David Hayden, Microsoft MVP C#

Scott Guthrie mentions the release of the .NET Framework Library Source Code.

You can now browse and debug the source code for the following .NET Framework libraries:

.NET Base Class Libraries (including System, System.CodeDom, System.Collections, System.ComponentModel, System.Diagnostics, System.Drawing, System.Globalization, System.IO, System.Net, System.Reflection, System.Runtime, System.Security, System.Text, System.Threading, etc).
ASP.NET (System.Web, System.Web.Extensions)
Windows Forms (System.Windows.Forms)
Windows Presentation Foundation (System.Windows)
ADO.NET and XML (System.Data and System.Xml)

The .NET Framework source is being released under a read-only reference license.

Talk about the ultimate way to learn best practices in .NET Development when looking at other people's code :)

Learn more here.

Some behind-the-scenes details about .NET Framework 2.0 SP1 and 3.0 SP1 setup

Aaron Stebners WebLog — 2008-01-18T00:00:00

Since the .NET Framework 3.5 shipped, I've written a few blog posts about some of the setup and deployment issues that can affect this product. Behind the scenes, the installer for the .NET Framework 3.5 has some architectural differences from previous releases of the .NET Framework that I've alluded to in a few of those previous posts, and I wanted to take a little time to describe these differences in a bit more detail.

How the .NET Framework 2.0, 3.0 and 3.5 fit together

The .NET Framework 3.5 is essentially an add-on that introduces new features to the .NET Framework 2.0 and 3.0 products but continues to run on the version of the common language runtime (CLR) that shipped in the .NET Framework 2.0. This is similar to the model introduced in the .NET Framework 3.0, which is essentially an add-on for the .NET Framework 2.0 but did not introduce a new version of the CLR. As a result of this add-on model, the .NET Framework 3.0 setup requires the .NET Framework 2.0 as a prerequisite, and the .NET Framework 3.5 requires both the .NET Framework 2.0 and the .NET Framework 3.0 as prerequisites. This is sometimes called a "nesting doll" model for creating a product.

.NET Framework 3.5 setup includes service packs for both the .NET Framework 2.0 and 3.0. These service packs install as prerequisites because some of the new features introduced in the .NET Framework 3.5 require updates to the originally released versions of both the .NET Framework 2.0 and 3.0.

When the .NET Framework 3.5 project first got started, the service packs for the .NET Framework 2.0 and 3.0 were being built as a series of Windows Installer patches (MSP files). It quickly became clear that the number of files being changed by these service packs was going to lead to the service packs being nearly as large as the original versions of the products. This would mean that any customers needing to redistribute the .NET Framework 3.5 with their products would have to include the original versions of the .NET Framework 2.0 and 3.0 and nearly equal-sized service packs for each of them, which would have caused the overall size to grow even larger than it already has.

As a result, the decision was made to create slipstream releases for both the .NET Framework 2.0 SP1 and 3.0 SP1. These slipstream releases include the original payload plus all of the fixes that are a part of the service packs. They will successfully install on systems that had the original releases of the .NET Framework 2.0 and 3.0 as well as on systems that did not yet have either version installed (whereas, standalone service packs only install if the original version of the product was previously installed).

.NET Framework 2.0 SP1 and 3.0 SP1 slipstream behind-the-scenes details

Typical slipstreams for MSI-based products are produced by building a layout that is identical to the original release, but with updated binary content. However, the slipstream releases of the .NET Framework 2.0 and 3.0 are constructed differently behind the scenes than a typical slipstream release.

The .NET Framework 2.0 SP1 and 3.0 SP1 setup packages consist of the following payload:

A base MSI that contains no files of its own - it only writes some registry values used for product-level detection
A series of MSPs that contain the file payload for .NET Framework features, divided up logically into sub-features that will likely need to be updated as a unit in the future

The .NET Framework 2.0 SP1 and 3.0 SP1 setup packages include logic to do the following:

Detect the processor architecture and install the base MSI and the appropriate set of MSPs during the initial installation transaction. The ability to install multiple patches in a single transaction like this is a new feature available starting in Windows Installer 3.0.
Use the Windows Installer major upgrade feature to automatically uninstall the original version of the .NET Framework 2.0 or 3.0 during SP1 setup if they are present on the system. This ensures that all systems are baselined at the new service pack level after installing the slipstream package.

Each of the MSPs installed during .NET Framework 2.0 and 3.0 SP1 setup is marked to not allow uninstall, which is why you see a series of updates that do not have Uninstall buttons listed in Add/Remove Programs for each of these products (if you check the Show updates box at the top of the Add/Remove Programs control panel).

Implications of this slipstream design

There are a few interesting results that fall out of this slipstream design that warrant a bit more in-depth discussion:

Because all of the files that are a part of the .NET Framework 2.0 SP1 and 3.0 SP1 are installed via patches, the source files are cached automatically by Windows Installer so they will be available for repair and uninstall scenarios. The original releases of the .NET Framework 2.0 and 3.0 had to include specific logic to cache the source files for repair scenarios, but this logic is no longer needed in the slipstream service packs.
The original version of the .NET Framework 3.0 consisted of multiple MSIs with payload for different features (Windows Communication Foundation, Windows Presentation Foundation, Windows Workflow Foundation). The slipstream 3.0 SP1 release consolidates this payload down to a single MSI with a set of associated MSPs. This means that repairing or uninstalling the .NET Framework 3.0 SP1 only requires interacting with one MSI instead of several.
The .NET Framework 2.0 and 3.0 both support installing on 32-bit and 64-bit platforms. In the original releases, the 64-bit packages were separate from the 32-bit packages and carried both 32-bit and 64-bit payload. This meant that customers who needed to redistribute both the 32-bit and 64-bit versions had to carry the 32-bit payload twice - once in the 32-bit setup package and a second time in the 64-bit setup package. Splitting the payload of the .NET Framework 2.0 SP1 and 3.0 SP1 into MSPs allows the .NET Framework 2.0 SP1 and 3.0 SP1 to use the same 32-bit source files for both 32-bit and 64-bit setup. This will reduce the overall package size for customers who need to redistribute both the 32-bit and 64-bit versions of 2.0 SP1 and/or 3.0 SP1.
Partitioning the payload of the .NET Framework 2.0 SP1 and 3.0 SP1 into a series of patches allows for more easy creation of future slipstream packages that include updates to a subset of the collection of patches. It becomes as simple as building the patches that include updated payload and then packaging them with the MSI and the rest of the MSPs that are included with SP1. These future patches could also be delivered as standalone hotfixes that can be independently uninstalled if desired.

Additional information

If you are interested, there are links in this blog post to more detailed information about the fixes included in the .NET Framework 2.0 SP1, 3.0 SP1 and 3.5 and the install locations of each version.

It is also interesting to note that the Silverlight 1.0 installer uses a similar packaging scheme behind the scenes. It includes an MSI that does not have any files of its own, and an MSP that includes the file payload.

Stepping into base class libraries of .NET Framework while debugging

Marco Dorantes WebLog — 2008-01-18T00:00:00

Here are some pieces of information about stepping into base class libraries of .NET Framework while debugging:

Firefox and the FileUpload control in ASP.NET

.NET slave — 2008-01-17T00:00:00

I’ve been pretty annoyed about the fact that FireFox ignores the width property of the ASP.NET FileUpload control. It doesn’t matter if you set it by CSS or even in JavaScript, Firefox always ignores it and that results in a crippled layout since you have no control over the width of the upload input field. This actually has nothing to do with the FileUpload control, but with the rendered output of that control, which is just a standard <input type="file"...> field.

Here the width is set to 400px. The FileUpload control renders the Width attribute to the correct CSS style value of 400px at runtime.

<asp:FileUpload runat="server" ID="txtUpload" Width="400" />

But as mentioned, Firefox totally ignores that. Then I remembered a forum thread I read some years ago about a size attribute. The only thing I could find was this list of available HTML attributes, but I gave it a try.

This is what I ended up with. The size attribute actually works in Firefox and IE ignores it, but adheres to the Width attribute instead.

<asp:FileUpload runat="server" ID="txtUpload" Width="400" size="50" />

The size attribute determines the number of characters should be visible and then adjusts the width accordingly. It is not the same as setting a maximum length of the file name, so it doesn’t break anything.

You should think that since a size of 50 generates the same width as 400px that you could always just divide the width in pixels with 8 to find the equivalent size. That is not the case. You have to manually adjust every time until you find the right size value that matches the pixel width.

Don’t you just love these kinds of obscure browser differences?

Web Authoring Component can fail during VS 2008 setup if Program Files has a trailing backslash

Aaron Stebners WebLog — 2008-01-14T00:00:00

I heard from a customer who ran into an interesting issue during Visual Studio 2008 setup that I hadn't seen until now. I wanted to post a description of the issue, how we diagnosed it and how to work around the issue in case anyone else runs into a similar issue in the future.

Description of this issue

On this customer's system, the Web Authoring Component prerequisite component failed to install and Visual Studio 2008 setup failed as a result. There are many possible causes for this type of failure, so we need to dig deeper to try to find the exact cause of the failure.

How to diagnose this issue

Visual Studio 2008 setup runs the Web Authoring Component setup package in silent mode, so the next step is to take a look at the log file for the Web Authoring Component to narrow down the issue further. This issue will cause the following information to be written to the log file for the Web Authoring Component (named %temp%\SetupExe(*).log):

Catalyst valid path check failed: The path c:\Program Files\\Microsoft Web Designer Tools is invalid

Notice that there is an extra backslash between Program Files and Microsoft Web Designer Tools in this log file. I had the customer check their registry and we found that the path to the Program Files folder was being stored there with a trailing backslash, but Windows typically stores the path to Program Files and other system folders without trailing backslashes.

In this scenario, it is also possible to run Web Authoring Component setup directly from <VS install path>\WCU\WebDesignerCore\WebDesignerCore.exe in order to see a specific error message instead of looking at the log files.

How to work around this issue

To work around this issue, you can change the value that Windows uses for the Program Files directory on your system by doing the following:

Click on the Start menu, choose Run, type regedit and click OK
Locate the following registry value:

Remove the trailing backslash from this ProgramFilesDir registry value
Close regedit and reboot the computer
Re-run Web Authoring Component setup from <VS install path>\WCU\WebDesignerCore\WebDesignerCore.exe
Look at %temp%\SetupExe(*).log and verify that installation succeeded this time
Re-run Visual Studio 2008 setup to complete installation

One note about this issue - the Web Authoring Component setup package uses the same setup wrapper as the Office 2007 family of products. It appears that other Office 2007 products may have similar installation errors if the ProgramFilesDir value has a trailing backslash like this.

Correct using Cache in ASP.NET

Dmytro Shteflyuks Home — 2008-01-12T00:00:00

Often in ASP.NET application we see a code which looks like this one:

if (Cache["SomeData"] != null)

{

    string name = ((SomeClass) Cache["SomeData"]).Name;

    //.....

}

Experienced developer, even if he is not a paranoiac, will find possible problem immediately — NullReferenceException. That’s because of caching implementation in ASP.NET. In ideal case an object, that has been cached, will stay there up to application restart, but in real world it could be deleted between two calls: by the garbage collector when memory is over (because cache uses weak references WeakReference); by another thread to refresh cached data.

So the code I have mentioned before works in 99% of all cases, but sometimes you will get errors in your log, which can not be reproduced easily. Here is right cache usage approach:

SomeClass someClass = Cache["SomeData"] as SomeClass;

if (someClass != null)

{

    string name = someClass.Name;

    //.....

}

Do not relax your vigilance, it’s exactly what they are waiting for! (about bugs)

asp.net, caching

Getting your Control to Function, and putting your Function in Control

Sorting It All Out — 2008-01-11T00:00:00

From the recently pre-recorded blogs collection...

The other day, Rob asked me via the Contact link:

I'm trying to find a way to fix the function key on the Mac Book Pro I got to run Vista on. Yes, seems a bit silly to run Vista on a computer tuned for Mac, but it's a fast laptop.

One of the issues which has me stuck is that I want to swap the Control and Function Keys (apple made them backwards for people who are familiar with windows). I'd just get used to it, but I have more than one computer and my brain isn't as flexible as it used to be.

So the question is, all of the keyboard mapping programs I've looked at don't recognize it when I press the function key on this keyboard. It seems like almost every other key is recognized.

Your name popped up on a few webs about containing programs like these, so I though I might email you and see if you understood the innerworkings of keyboards enough to shed some light on the situation.

Thanks much,
Rob

The good old Function or Fn key has been around laptops for a while, with a true purpose of doing all manner of "special" operations. One on my Dell Latitude D800:

and on my MacBook Pro:

show the difference that Rob is talking about, and wanting to switch them makes a whole bunch of sense, in either direction -- because if the main goal is consistency, then as long as you can just choose one or the other, you can all it a day.

Let's see what this key gives us for our programs in terms of scan code, say using that bit of code from Handling [Unicode] input in the console.

If you test with this key, it gives you nothing back at all on either machine, unless you combine it with one of the assigned combinations. The key simply does not exist to the operating system and appears to be entirely hardware mediated. Which means that in order to switch it you would need some kind of assistance/tool from the OEM to switch them.

There seem to be helpful hints for some remappings like this one, but the same technique does not appear to help with the Fn key.

However there is a thread over on the apple site here that in answer to this very question pointed to a tool called DoubleCommand that seems to solve this problem nicely via a kernel extension. The same tool is apparently used to make other swap so that their Mac keyboard can be more Windows-ey....

This post brought to you by ? (U+3399, aka SQUARE FM)

Large file uploads in ASP.NET

JonGalloway.ToString() — 2008-01-08T00:00:00

Uploading files via the FileUpload control gets tricky with big files. The default maximum filesize is 4MB - this is done to prevent denial of service attacks in which an attacker submitted one or more huge files which overwhelmed server resources. If a user uploads a file larger than 4MB, they'll get an error message: "Maximum request length exceeded."

Increasing the Maximum Upload Size

The 4MB default is set in machine.config, but you can override it in you web.config. For instance, to expand the upload limit to 20MB, you'd do this:

<system.web>
  <httpRuntime executionTimeout="240" maxRequestLength="20480" />
</system.web>

Since the maximum request size limit is there to protect your site, it's best to expand the file-size limit for specific directories rather than your entire application. That's possible since the web.config allows for cascading overrides. You can add a web.config file to your folder which just contains the above, or you can use the <location> tag in your main web.config to achieve the same effect:

<location path="Upload">
    <system.web>
        <httpRuntime executionTimeout="110" maxRequestLength="20000" />
    </system.web>
</location>

What Happens When I Upload A File That's Too Big?

While expanding the upload restriction is a start, it's not a full solution for large file uploads. Milan explains one of the biggest problems with large file uploads in The Dark Side Of File Uploads:

It gets really interesting if someone uploads a file that is too large. Regardless of what your maxRequestLength setting mandates, IIS has to guzzle it, and then ASP.NET checks its size against your size limit. At this point it throws an exception.

As Milan explains, you can trap the exception, but it's trickier than you'd expect. He talks about overriding Page.OnError and checking for HTTP error code 400 when the error is HttpException, which as he says is less than ideal.

At Least Give Me A Warning

If we've got a set limit on file upload sizes, we should at least tell our users what it is. Since this is a configurable value which we may change later, the best is to make our file size warning read directly from web.config setting. The best way to do this is to pull back the httpRuntime section as a HttpRuntimeSection object, which isn't too hard given:

System.Configuration.Configuration config = WebConfigurationManager.OpenWebConfiguration("~");
HttpRuntimeSection section = config.GetSection("system.web/httpRuntime") as HttpRuntimeSection;
double maxFileSize = Math.Round(section.MaxRequestLength / 1024.0, 1);
FileSizeLimit.Text = string.Format("Make sure your file is under {0:0.#} MB.", maxFileSize);

A Real Solution: an HttpModule to Handle File Uploads

There are better solutions to handling large file uploads in ASP.NET. A custom HttpHandler can provide a better user experience by displaying upload progress and allowing you to handle a file size problem in a more controlled fashion. Here's a summary from a cursory search:

FileUploader.NET (MediaChase, $310 and up)
RadUpload (Telerik, $249)
NeatUpload (Free, LGPL license)
Which others did I miss?

One of the longest running threads on the ASP.NET Forums (going back 5 years): HttpHandler or HttpModule for file upload, large files, progress indicator?

A Better Solution: a RIA upload component

The project which caused me to look into this, Video.Show, was based on ASP.NET and Silverlight 1.0, so we weren't able to take advantage of RIA platforms which would support more advance upload handling. In most cases, though, I'd recommend replacing the FileUpload component with a Silverlight or Flash based file upload control. In addition to a better upload experience, these controls generally look better than the the generic button displayed for the <input type="file"> element which is rendered by the FileUpload control. The input / file element doesn't allow for CSS formatting, although smart CSS hackers always seem to find a way around these things.

Although there doesn't seem to be a project / component to support Silverlight uploads yet, Liquid Boy has a nice sample of a Silverlight 1.1 (oops, 2.0) based upload control. I've heard good things about SWFUpload, a Flash and JavaScript based upload system. Developers are responsible for handling a few JavaScript events as well as accepting the file on the server. That can be done pretty easily, as you can see from this ASP.NET sample implementation. Here's a screenshot from one of the SWFUpload online demos:

What About IIS7?

Oh, and there's more thing to worry about. IIS7 has a built-in request scanning which imposes an upload file cap which defaults to 30MB. Again, this is a good feature, but it gets in the way if you're looking to upload files larger than 30MB. Steve Schofield posted about how to change this from the comandline:

appcmd set config "My Site/MyApp" -section:requestFiltering -requestLimits.maxAllowedContentLength:104857600 -commitpath:apphost

Why is this such a pain?

Browsers, and HTML in general, were never designed to handle large uploads gracefully. Jeff Atwood and I discussed this back in September, and he summed up the issue pretty well in his post asking Why Are Web Uploads So Painful? It's disappointing that browser standards have failed us to the point that we need to use browser extension technologies like Flash and Silverlight as a band-aid here. Browsers should support uploads over both HTTP and FTP (it is the file transfer protocol, after all), and should manage the upload in a side or toolbar that allows us to continue browsing without breaking the upload. The Firefox Universal Upload add-on is an example of how this should work out of the box.

Historical trivia: In ASP.NET 1.0 and 1.1, the entire file was loaded into memory before being written to disk. There were improvements in ASP.NET 2.0 to stream the file to disk during the upload process.