This is an odd change on a Microsoft "best practice..." For .NET Framework v1.x, it was recommended that you always inherit from ApplicationException when creating custom exception classes for your application.

But for Framework 2.x, they have revoked this recommendation, as you can see here...

For most applications, derive custom exceptions from the Exception class. It was originally thought that custom exceptions should derive from the ApplicationException class; however in practice this has not been found to add significant value.

I'm not sure why they made this distinction? ApplicationException is inherited from Exception anyway, and I can't imagine there is significant performance issues there? Anyone? Bueller?

web.config Encryption
"Can't I encrypt portions of my web.config so people can't just pop that file open and find my db passwords and other sensitive stuff?" ASP.NET 2.0 has expanded support for config section encryption, and this article gives a good overview of using aspnet_regiis to do just that.

Drawing Primitives using JavaScript
After all the iterations of the web browser, isn't it funny how we still can't do things like draw simple shapes?! Don't worry, there is always a kluge. Until Vector Markup Language is supported in more browsers, we can use this LGPL javascript library to draw simple shapes.

Here are a couple of notes for the VB.NET class I instructed at this week...

(1) Creating a global exception handler for WindowsForms (.NET 1.1):  This is a multistep process (note that in .NET 2.0 they give you a global exception handler in Project properties which is nicer). Create a Sub Main module that creates your main form and adds a handler for the Application.ThreadException. In Project Properties, change your startup object to Sub Main. (code below)

Module SubMain

    Public Sub main()

        Try
            AddHandler Application.ThreadException, AddressOf HandleExceptionEvent

            Dim frmMain As New Form1
            Application.Run(frmMain)

        Catch ex As Exception
            HandleException(ex)

        End Try

    End Sub

    Private Sub HandleExceptionEvent(ByVal sender As Object, ByVal e As System.Threading.ThreadExceptionEventArgs)

        HandleException(e.Exception)

    End Sub

    Private Sub HandleException(ByVal ex As Exception)

        MsgBox("Sorry, an error has occurred:" & ex.Message)

    End Sub

End Module

(2) Creating a TextBox class that handles Enter as Tab key:  some users prefer hitting ENTER on each WindowsForms field to "tab" to the next field. We can do this by creating an inhertied textbox and handling its KeyPress event. First create a new Class and then implement as follows

Public Class TextBoxEnterTab
    Inherits TextBox

    Private Sub TextBoxEnterTab_KeyPress(ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEventArgs) Handles MyBase.KeyPress

        If e.KeyChar = Chr(13) Then

            SendKeys.Send("{TAB}")
            e.Handled = True

        End If

    End Sub

End Class

(3) Code Generation Tools: Check out MyGeneration dOOdads and CodeSmith

(4) Miscellaneous tools and utilities for development
VBCommenter - generates comment blocks for VB.NET  http://www.gotdotnet.com/team/ide/

NDoc - generates documentation automatically form XML comments  http://ndoc.sourceforge.net

NET Reflector - used to disassemble assemblies  http://www.aisto.com/roeder/dotnet/

REGEXLIB - an online Regular Expression library to use with the Regular Expression Validator controls http://www.regexlib.com

Enterprise Library - Microsoft's Application Blocks for handling common development tasks http://www.microsoft.com/downloads/details.aspx?familyid=5A14E870-406B-4F2A-B723-97BA84AE80B5&displaylang=en
   http://msdn.microsoft.com/library/?url=/library/en-us/dnpag2/html/EntLib2.asp

Atlas   http://atlas.asp.net - Microsoft's AJAX library, including Behaviors

So you've created a cool new WindowsForms Smart Client Application that uses the ReportViewer control, and it's time to deploy it. There is an article here that explains how to use the ReportViewer.exe redistributable.

But what if you don't want to distribute that funky ReportViewer.exe? Maybe you just want to throw the files on a PC and let a prototype tester have at it?   

Sure, you can do that - first snag these two files from C:\Program Files\Microsoft Visual Studio 8\ReportViewer

Microsoft.ReportViewer.Common.dll
Microsoft.ReportViewer.WinForms.dll

And now the tricky part, you need to snag Microsoft.ReportViewer.ProcessingObjectModel.dll from the GAC. It will be located in a directory something like C:\WINDOWS\assembly\GAC_MSIL\Microsoft.ReportViewer.ProcessingObjectModel\8.0.0.
0__b03f5f7f11d50a3a

...but remember, you'll need to use the Command Line to get at this file, because of the cool Explorer add-in for the GAC.

Put the three ReportViewer assemblies in your app's BIN folder and you should be good to go!

With all the neat-o AJAX and Atlas sites showing up, one of the recurring things I've noticed is groovy, shadowy tooltips. What am I talking about? If you haven't tried Netflix yet, at least visit their site and try hovering over a movie image. You'll see a nice popup flash up with title details. I really like the shadows that show up around this popup, it really adds a professional touch.

So how is this done? Well, it should be possible to use PNG images to define an alpha channel that supports transparency. Most browsers except Internet Explorer support this. But in order to support the most browsers, you have to use a klugey method that uses an AlphaImageLoader Filter in IE. I'll show some code that implements this kluge, but first let's look at how we can create a PNG file that has this nice alpha channel...

I'll be using Paint.NET because it's free and it does a fine job of managing layers and transparency for PNG's!

(1) Create a new image by selecting File/New. Be sure to input your desired height and width.

(2) Set the image background to transparent by selecting Layers/Layer Properties and setting the Opacity to 0.

(3) In this step we will create the shadow layer
Select Layers/Add New Layer. Select the “Draw filled shape with outline” option button on the toolbar.

(4) Set both the foreground and background colors to a dark gray

 

(5) Draw out a rectangle (or other shape) for the background shadow.

 

 (6) Next, blur the shadow by selecting Effects/Blurs/Gaussian. Note how the “shadow” gets blurred out!

(7) Next, we add the “real object” that is casting the shadow. Overlay another rectangle or other object that is casting the shadow.

That's it! We now have a nice PNG file that can implement alpha transparency. But in order to get this to work cross-browser, we need to do a couple of dirty, kludgey things.

First, we need to have a "bogus proxy image" that is at least 1x1 pixel and completely transparent. You can create a 1x1 GIF image that is completely transparent, that will work fine. Let's call that image bogusPixel.gif.

Next, we need some javascript that will figure out if we are in IE and need to apply an AlphaImageLoader filter. This is because IE doesn't really support alpha channel PNG's, but has a filter that does support them.

<script language="javascript">
    var bInitialized;
    function showImg(id) {
        var img = document.getElementById(id);
        img.style.visibility='visible';
        if (navigator.appVersion.indexOf("MSIE")>-1) {
            if (!bInitialized) {
                bInitialized = true;
                img.style.width = img.width;
                img.style.height = img.height;
                img.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(enabled=true, sizingMethod='scale', src='" + img.src + "')";
                img.src = "images/bogusPixel.gif";
            }
        }
    }

    function hideImg(id) {
        document.getElementById(id).style.visibility='hidden';
    }

script>

Sam Gentile was quite distressed when he had an emergency come up and had to cancel his presentation at our local CNY .NET Developer Group. Luckily, everyone is OK and we held an open "Chalk Talk" type session in lieu of Sam's presentation.

Here are a few notes from the presentation -

System.Convert vs. Parse
A question came up about when to use the System.Convert methods over the "Parse" methods for type conversion. As it turns out, the System.Convert methods will internally call the "Parse" methods for the desired type. However, the Parse methods will throw a ArgumentNullException if a Null parameter is passed...

double value;
string text = null;
// internally, Convert.To* will just call Parse methods for given type..
value = System.Convert.ToDouble(text);
// but Parse will throw an ArgumentNullException for Nulls...
value = double.Parse(text);

So then, what about all of those nifty VB.NET CType, CDbl, CInt, etc. conversion methods? Well, there is a good article here that goes on to explain that the VB.NET compiler is cool enough to optimize the MSIL spit out for those. And in fact, it is recommended to use these conversion methods (this was surprising really, because these conversion methods are mostly considered legacy type functions).

Atlas and Ajax
I also spent some time going over Atlas and Ajax demos showing a simple web service call, AutoComplete Behaviors, and the Resize Behavior I created. I hope to have time to refine this into a full presentation to give later on in the year!

Here are some links for the Atlas/Ajax stuff:
    Fiddler tool - great for analyzing ajax traffic
    Ajax .NET - stable, widely used ajax library for ASP.NET
    Atlas home - download and start playing!

Some Links from Greg
Greg Smalter also provided some great relative links:

      Using Atlas without ASP.NET shows using PHP with Atlas
      How-to Video on ASP.NET Validation Controls

IMPORTANT NOTE: Since the writing of this blog entry, the latest Atlas CTP now includes its own Resize Behavior and Extender! Details and Demo here.

Try It!

If you have played with Microsoft Atlas behaviors,  you might have come across the cool floatingBehavior which allows you to drag and drop web page elements around the screen.

Well, it's also possible to create your own behaviors, and while the documentation on this is pretty much nonexistant, there are two great blog entries here  and here on the subject.

So I thought, floatingBehavior is cool, but what if you could resize elements as well (like a little virtual window)? Thus was born my first Atlas Behavior, resizingBehavior!

Using ResizeBehavior
To add resizing behavior to an element, assuming you have already installed Atlas and created a new Atlas template project... First add ResizeBehavior.js (source at the end of this article) to your Script Manager...

... next you need to assign the resizeBehavior properties in the XML Config section of your Atlas page...
      resizeControlId should be assigned to the element you want resized
      resizeObjectId should be assigned to the element that controls the resize
      minWidth, minHeight control the minimum resize size
      arrowThreshold allows you to control the sensitivity of resizeObjectId

ResizeBehavior.js

I had installed a CTP version of SQL2005 on my notebook, followed by the RTM... alongside a SQL2000 installation. Somewhere along the line, I could not longer connect to my SQL2000 installation (was it the SQL2005 installs? Can't say for sure). The error I got was:

SSL Security error :ConnectionOpen (SECDoClientHandshake())

So after poking around, I found this article, which descries the bug and leads you through deleting your certificates. It worked great, except in my case the Certificate was under "Current User" so note that the steps in the fix lead you through "local computer"

I have been porting a couple of sites over to Dotnetnuke 4 and came across a problem in my older skins... the CSS class for the active tabs in the Menu were not being applied. Turns out you need to apply the "rootmenuitemactivecssclass" attribute as shown below (for an ascx skin implementation):

<dnn:SOLPARTMENU runat="server" id="dnnSOLPARTMENU" usearrows="false" userootbreadcrumbarrow="false" rootmenuitemactivecssclass="MainMenu_MenuItemSel" />