I've had to do this just a few times in the past several years, and I keep forgetting to blog it... but here goes. If you have a hanging issue in your application, it's easy to debug by attaching to the process through VS.NET. But what if the hanging only happens on a deployed machine without VS.NET installed? You can use cordbg.exe as follows...

- copy the below files from a developer's machine (with VS.NET or .NET SDK installed) to the machine with the issue
 msvcr71.dll
 msvcp71.dll
 msdis140.dll
 cordbg.exe.config
 cordbg.exe

- the user should have a hanging .NET app currently running. If not, have them run the app and recreate the problem.

- find the PID for the app by looking in task manager (you many need to add the PID column in to view it by selecting View/Select Columns from the menu)

- start cordbg.exe from a command prompt.

- attach to the .NET process... at the (cordbg) line, enter
 a {pid}
 where {pid} is the process id you found from task manager

- you can enter "sh" to show the source code lines of the current breakpoint.

- List the loaded modules in the process using the l mod command.
 The command line is shown below:
 (cordbg) l mod

- Display and examine the call stack trace for all current threads using the *w command. This should show what line the process is hanging on (assuming the PDB file is present for the hung assembly). Specify an argument of 200; this lists up to 200 levels of stack trace.
 (cordbg) *w 200

- Now detach from the process, and quit the debugger:
 (cordbg) de
 (cordbg) q

I had been using nprof (http://nprof.sourceforge.net) to do some profiling of a WindowsForms app, but it was hitting some really odd timings on a part of the code that relied on an ActiveX EXE (don't ask).

So while searching for another profiler to get a 2nd opinion from, I found this nice “Community Edition...“ It requires registration, but integrates nicely into the IDE...

http://www.compuware.com/products/devpartner/profiler/default.asp?cid=3019X36&focus=DevPartner&source=Web+%2D+Evaluation+Request&desc=Download+%2D+%27DevPartner+Profiler+Community+Edition%27&offering=DevPartner&sf=1&p=0

I've used Brinkster for hosting several websites on the cheap... and recently I wanted to take one of those sites and add DotNetNuke (DNN) on top of it, without converting any of the pages to DotNetNuke skins and tab pages.

What I did was rename the current site's Default.aspx to Default_MySite.aspx so that DNN's Default.aspx could take it's place. Then, I added a bit of code in DNN's Default.aspx to take care of rerouting any requests to “MySite”...

If Request.Url.AbsoluteUri.ToLower.IndexOf("mysite") <> -1 Then
      Response.Redirect("default_mysite.aspx")
End If

After a quick check to be sure that none of DNN's project files had the same name as the existing site, I copied the remaining DotNetNuke files on top of the existing site, built, and released. I also needed to make a request to Brinkster Support to add privileges for the ASPNET Machine account to my webroot and all subdirs (as this is required by DotNetNuke). This retrofit allowed me to quickly add DNN to an existing Brinkster hosted account and still preserve the existing site.

You would think this is a simple task: let's say you have a Crystal Report and you want to dynamically change an image in the report by loading an image from disk. Well, as it turns out, this functionality is not available in CR for .NET!

But here is a work-around; Crystal for .NET does support displaying images from a DB. And it does support accepting a disconnected ADO DataSet as a data source. So you can trick Crystal into thinking it loaded an image from disk and presto, you have dynamic images from disk. Here's the process:

(1) Create an XSD file (you'll use this as your report data source in step 2) with a binary column definition like so:

<xs:element name="AnImage" type="xs:base64Binary" minOccurs="0" />

(2) Create your Crystal Report and use an ADO.NET (XML) DataSource as your Crystal Report Data Source.

(3) Fill your DataSet, and then set the binary “image” column to an image file from disk using a MemoryStream like so:

Dim oLogo As System.Drawing.Image
Dim msX As New MemoryStream
Dim dsReportSource As New DataSet
' TODO: Fill your DataSet, dsReportSource, with your Report Data

(4) Load your Crystal Report and assign the Data Source as usual:

Dim oRpt As New ReportDocument
oRpt.Load("CrystalReport1.rpt")
oRpt.SetDataSource(DsTestImage1)
CrystalReportViewer1.ReportSource = oRpt

This is a handy function that accepts an Export Format (i.e. PDF, Word or Excel) and streams a Crystal Report output back to the browser client.

   Private Sub ExportReport(ByVal iFormatType As ExportFormatType)
        Dim sTargetPath As String, sTargetExt As String, sContentType As String
        Dim fs As FileStream
        Dim FileSize As Long
        Dim GenDS As DataSet
        Dim oRD As New ReportDocument()
        Dim crReportObject As ReportObject
        Dim oExO As ExportOptions
        Dim oExDo As New DiskFileDestinationOptions()

        'Build Target Filename
        Select Case iFormatType
            Case ExportFormatType.Excel
                sTargetExt = ".xls"
                sContentType = "application/vnd.ms-excel"
            Case ExportFormatType.PortableDocFormat
                sTargetExt = ".pdf"
                sContentType = "application/pdf"
            Case ExportFormatType.WordForWindows
                sTargetExt = ".doc"
                sContentType = "application/msword"

        End Select

        sTargetPath = Server.MapPath("") & "\Export\" & Session.SessionID & sTargetExt

        oRD = GetReportDocument()
        'Export to PDF
        oExDo.DiskFileName = sTargetPath
        oExO = oRD.ExportOptions
        oExO.ExportDestinationType = ExportDestinationType.DiskFile
        oExO.ExportFormatType = iFormatType
        oExO.DestinationOptions = oExDo
        oRD.Export()
        oRD.Close()

        'Send the file to the user that made the request
        Response.Clear()
        Response.Buffer = True
        Response.AddHeader("Content-Type", sContentType)
        Response.AddHeader("Content-Disposition", "file;filename=" & Left(ViewState("ReportName"), Len(ViewState("ReportName")) - 4) & sTargetExt)
        fs = New FileStream(sTargetPath, FileMode.Open)
        FileSize = fs.Length
        Dim bBuffer(CInt(FileSize)) As Byte
        fs.Read(bBuffer, 0, CInt(FileSize))
        fs.Close()

        Response.BinaryWrite(bBuffer)
        Response.Flush()
        Response.Close()

    End Sub

I've used the .NET CLR Profiling Services to find bottlenecks in code, such as suggested by this article (which includes an implementation of a CLR Profiler):

http://msdn.microsoft.com/msdnmag/issues/01/11/NetProf/

But the nice thing is, Whidbey has a built-in profiler available, with nice graphs and reports built in - check out this article to learn more

http://msdn.microsoft.com/msdnmag/issues/04/12/EnterprisePerformance/default.aspx

One of my Pocket PC components - AWaveCE - got an award.

http://www.pocketpcmag.com/awards/category_2004.asp?catid=46

I created AWaveCE awhile ago as a simple wrapper for a GPL mikmod port. It's always been free and the source is available on my SpriteHand website - http://www.spritehand.com

ASpriteCE was a finalist in the competition - that's a component for creating Pocket PC games, and is actually much more complex than AWaveCE ;-)