We’ve just recently released to the world version 2.3.2 of the Habanero Enterprise Application Framework.  The download is available on the Habanero download page.  This is the most stable version of the framework yet - the new version contains over 1000 new tests and has lots of bug fixes and enhancements over 2.3.1. Here is a description of some of the bigger ones:

• Added Support for MSAccess2007
• Dramatically improved the performance of loading collections.
• Added the IN operator to loading BusinessObjectCollections.  This uses a very similar to notation to SQL where clauses. I will hopefully do a separate post on this on my Habanero blog
• Created a DataAccessorMultiSource, which can switch between DataAccessors based on the type loaded or saved.

Have a look at the change log page for a full list of the changes.  We’re also busy restructuring the project and will soon be releasing a whole slew of related libraries which we’ve been developing the past few months. Stay tuned!

If you try to access a record in an ADODB record set where the record does not exist, you’re likely to get an exception. The first question to ask of course is why you’re writing code for a field that might not exist, but certainly in my example, I was developing a class that was extensible and ready to be scaled depending on the requirements. To be more specific, it was populating the properties of a class once a record set had been filled by a fetch from the database. I had no guarantee that the SQL statement would meet specs, so I needed some error catching, just populating those properties that had corresponding record set fields.

Here then is the code written to check if the field existed. It is written in VB6:

Private Function RecordSetHasField(strField As String, rs As ADODB.Recordset) As Boolean
    Dim objField As Field
    For Each objField In rs.Fields
        If UCase(objField.Name) = UCase(strField) Then
            RecordSetHasField = True
            Exit Function
        End If
    Next
    RecordSetHasField = False
End Function

A typical use could be something like the following:

If RecordSetHasField("OrderedGauge", rs) Then
    If Not IsNull(rs!OrderedGauge) Then
        MetalGaugeOrig = rs!OrderedGauge
    End If
End If

I experienced the following message while trying to write to an Excel file from C# code using Interop:

System.Runtime.InteropServices.COMException: Exception from HRESULT: 0x800A03EC
   at System.RuntimeType.ForwardCallToInvokeMember(String memberName, BindingFlags flags, Object target, Int32[] aWrapperTypes, MessageData& msgData)
   at Microsoft.Office.Interop.Excel.Range.set__Default(Object RowIndex, Object ColumnIndex, Object )

The problem was down to inserting values at a zero index.  Excel documents begin their range at 1, not 0.  Now that’s a mindshift for a long-time zero-based programmer!

I’ve been working on an application that uses Habanero and Visual WebGui (VWG) to provide a simple website that lets a department manage a list of facilities. At Chillisoft we use test-driven development to build robust applications, and we attempt to get our business, logic and presentation layer as close to 100% test coverage as possible.

I was writing tests for a section of code that calls through to VWGContext.Current.Session, which effectively allows you to store and retrieve session variables in the same way you do in ASP.Net. The trouble is that Current returns null because no web environment has been launched.

I developed a workaround class that allows you to switch between using the real session and fake internal session. The end behaviour is exactly the same, but you’re obviously able to get your test layer running correctly.

The code is listed below and you can adapt it for ASP.Net quite easily by just replacing VWGContext with HttpContext. I do have a nUnit test class for this as well - just enquire below if you would like it.

using System.Collections.Generic;
using Gizmox.WebGUI.Forms;
 
namespace MyProject
{
    /// <summary>
    /// Provides a way to fake out your sessions for the purpose of testing.
    /// Defaults to using the VWG Session, but you can set UseRealSession to
    /// false to manage a fake session that stores values in the same way a
    /// web session does.
    /// </summary>
    public class SessionManager
    {
        private static SessionManager _current;
        public bool UseRealSession { get; set; }
        private Dictionary<string, object> _fakeSession =
            new Dictionary<string, object>();
 
        /// <summary>
        /// Gets and sets a particular session variable.  Returns null if you
        /// access a variable that has not been stored.
        /// </summary>
        public object this[string propertyName]
        {
            get
            {
                if (UseRealSession)
                {
                    return VWGContext.Current.Session[propertyName];
                }
 
                if (!_fakeSession.ContainsKey(propertyName)) return null;
                return _fakeSession[propertyName];
            }
            set
            {
                if (UseRealSession)
                {
                    VWGContext.Current.Session[propertyName] = value;
                    return;
                }
 
                if (_fakeSession.ContainsKey(propertyName))
                {
                    _fakeSession[propertyName] = value;
                }
                else
                {
                    _fakeSession.Add(propertyName, value);
                }
            }
        }
 
        /// <summary>
        /// Clears the values stored in the "false" session.
        /// This is useful for testing, where every test needs
        /// to start from a clean slate.
        /// </summary>
        public void Clear()
        {
            _fakeSession = new Dictionary<string, object>();
        }
 
        /// <summary>
        /// Gets the current session or creates a new one if not available.
        /// The session uses the real VWG session by default - call
        /// <code>SessionManager.Current.UseRealSession = false</code>
        /// if you want to use the fake session manager.
        /// </summary>
        public static SessionManager Current
        {
            get
            {
                if (_current == null)
                {
                    _current = new SessionManager();
                    _current.UseRealSession = true;
                }
                return _current;
            }
            set
            {
                _current = value;
            }
        }
    }
}

You can use the code in the following way:

SessionManager.Current["name"] = "Eric";
string name = (string)SessionManager.Current["name"];

General use of this code in a working application requires no setup, since the SessionManager defaults to using VWGContext. However, when you are writing a test class that tests code using the sessions, you’ll need to modify the TestFixtureSetUp and the SetUp:

[TestFixtureSetUp]
public void SetupTestFixture()
{
    SessionManager.Current.UseRealSession = false;
}
 
[SetUp]
public void Setup()
{
    SessionManager.Current.Clear();
}

Any feedback is welcome.

Use cases are an important part of the communication between a client and a developer, or a user and a business analyst. That much is evident, since they are written in plain English and describe the business process in detail from the user’s point of view.  All this is great except these use cases seem to create a huge administration overhead. What’s that I hear you say? “That’s the Project administrator/co-ordinators job”? No, we don’t have such a luxury! (We chose premium filter coffee and an espresso machine over having a co-ordinator).

In one of my less noob- like moments, I have realised that a requirements phase more often than not results in an abundance of use cases, which need to be tracked and managed. I did not choose to be an administrator, so I have promptly recognised the dire need for the Use Case Manager. To date use case management applications have focused on the analyst’s need to keep track of use cases. This works well for classic software methodologies like the water fall approach, but requirements are extremely fluid in agile software development, so transparency and simplicity in communication is vital. For a start, the use cases need to be available to everyone, making rapid feedback possible.  Since there are often multiple revisions of Requirements Documents, the user must be able to generate a new document whenever changes are made to the use cases.

My tasks for this month include implementing the following use cases in the Use Case Manager:

And now to the technical bit. How do I get the Use Cases into a word document? Converting objects from C# code into a document seemed to require the use of some third party software. “GloryDev” aka Brett suggested two free utilities: stringTemplate and NVelocity . Now having the attention span of a gnat does not help when trying to decipher what these things are. Having barely any experience with .NET alone, I have to figure out the what, why and when of templates. Templates?! I’m sure both tools are well defined for their purpose, but this noob has no idea what that is. I couldn’t join the dots between generating documents from code and using these “template engines”.  So I puzzled over what to do…. for a while.
In a world where another option is but a google away, it is very difficult to try and stick with something that isn’t producing results fast and after two weeks of mucking about I needed results….fast! My helpful fellow devs suggested using Active Reports, but again my lack of knowledge was a stumbling block. Also, it’s not free, so I only wanted to try it as a last resort.
Finally, the mention of XSLT took me down a viable path. There was still a learning curve, but perhaps not as steep a climb towards completion of the task. I was warned that XSLT was very hard to maintain, and it violated the requirement that it must be open to automated testing. The other devs took pity on me though, and allowed me to try it since I was not getting anywhere with the other methods yet.
The Habanero Business Object can be saved to XML, so I had the Project along with Packages, Use Cases and Use Case Steps saved to a file I could transform.
I googled “Xml to Word” and found some interesting articles. This article certainly took the pain out of producing word documents. Following it step by step along with the w3 schools tutorials on XML, XSLT and XPATH, I produced a listing of Use Cases in a Project, sorted by Package. This is the trick Chris Bennett thankfully chose to share with the world in the above article:
1.    Create the layout you want in Word.

2.    Save the document to XML (which Word allows you to do)

3.    Then tweak the XML into XSLT by (get this!) adding a few lines

That’s one more use case done. Next, I needed to find a way to insert the table from this listing at a specified point in the Requirements Document. Another chance to investigate something I know nothing about… google help me! And the search for examples to study and documentation to read begins.
I have found that to make the best use of MSDN, its best to google to get there; the site search is just shameful (don’t snigger its true). Google found a detailed how-to (105 printed pages… ahem) using the word object model which even had snippets of C# code. So I read through that and tried out some of the code to get a better idea of the domain.

Another resource that came in handy- this straightforward article from techrepublic. And you’ve got to love the description of seeing an open word instance as “both intriguing and scary”.
There was also an older, Visual Basic, Chillisoft-developed project that used bookmarks in the word object model to produce reports. This was the approach I was advised to use, and the code for it didn’t turn out as unwieldy as I thought it would. And another trick: record a macro for what you’re trying to do in Word, and attempt to translate that into C# code.

If I got anything out of this long, strange trip it would be that modelling what you want to do before you do it in code is very helpful. To save someone else the toil, this is C# code for inserting the content of one Word document into another:

public static void WriteRequirementsToWordDocument(string projectDocName, string requirementsTemplateName, string generatedDocName, string insertionPointBookmark)
{
object missing = Type.Missing;
_Application oWord = new Application { Visible = false};
_Document oDoc;
_Document projectDoc;
try
{
object fileName = Path.Combine(Environment.CurrentDirectory, requirementsTemplateName);
oDoc = oWord.Documents.Open(ref fileName, ref missing,ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing);
 
object projectFileName = Path.Combine(Environment.CurrentDirectory, projectDocName);
 
projectDoc = oWord.Documents.Open(ref projectFileName,
ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing);
 
projectDoc.Activate();
 
oWord.Selection.WholeStory();
 
oWord.Selection.Copy();
 
oDoc.Activate();
 
object insertAtBookmark = insertionPointBookmark;
 
oWord.Selection.GoTo(ref missing, ref missing, ref missing, ref insertAtBookmark);
 
oWord.Selection.Paste();
 
object requirementsFileName =Path.Combine(Environment.CurrentDirectory,generatedDocName);
 
oDoc.SaveAs(ref requirementsFileName, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing);
}
finally
{
oWord.Quit(ref missing, ref missing, ref missing);
}
}

To look at this technique in context you can download the Use Case Manager off Codeplex.

Habanero version 2.3.0 is the most stable and powerful version of Habanero available and the development team believes this version is going to knock the competition off the shelves. On top of a range of performance improvements, bug fixes, dependency inversions and extended test coverage, you’ll get new features like serialisation of BusinessObjects and a bunch of nifty UI tools.

What’s the Big Deal?

What sets Habanero apart from other data or ORM frameworks?

Agile from data to presentation
Firstly, Habanero provides an agile toolset right from the data layer through to the front end. Most ORM frameworks focus on reading data out of the database, but don’t go beyond that. As the developer you’re then required to tie a range of heterogenous frameworks together in order to move data through the data layer, the business logic layer and the presentation layer. Habanero ties these all seamlessly together, automating so much of the default implementations that lengthen your development time.

Switch out your data layer
Secondly, Habanero’s data handling allows you to swap in any data layer you choose, now that the dependency inversion between BO and DB is complete. As a developer you have the freedom to source your data from a database, an XML file, an Excel document, a web service or any medium you would like to create a Data Accessor for, and then get standard Business Object and Presentation layer behaviour. Furthermore, Habanero’s approach to Business Objects allows for fourth normal form application development.

Runtime UI generation
Habanero then provides runtime generation of controls like grids and forms to edit your Business Objects. A lot of development time is spent building an interface piece by piece through the designer, which is particularly inefficient when you are creating an edit form for a number of fields from a single entity. Habanero automates this kind of interface, enforcing data validation, and providing real-time synchronisation between components displaying the same data.

One application for desktop and web
Finally, Habanero abstracts the specific UI environment so that you can code one set of controls to be released in multiple environments. By generating all components through IControlFactory, you need only switch out the implementation of IControlFactory you use in order to release the same application on either the desktop or the web. With support for the Visual WebGui AJAX framework, this marks a huge stride in simplifying web development. Gone are the old days of tedious ASP CRUD page design and you can now generate a data-driven web application in a fraction of the previous time and with twice the intelligence.

Free open source

Habanero v2.3.0 is now available for free download on the official site. As part of the Habanero community, we’re looking forward to hearing your contributions to the Habanero project, as well as integrating your own code into this groundbreaking framework.

Learning to use keyboard shortcuts is a double-edged sword.  On one hand, you get fed up with how hard it is to pull off a task and you feel a certain sense of triumph when you find a shorter way of doing a repetitive task.  On the other blade, becoming more efficient in what you do is part of the service to your employment contract.  You’re getting paid to perform a quality service as quickly as you can.

So what then is “the most useful keyboard shortcut you never used”…

Ctrl+A

This is the shortcut for “select all”, which selects all the text in the current control or document.  It’s supported by most text editors, including fields on a web page, email editors, text editors, Office documents.  So let’s look at some sample uses…

You’ve just written a nice comment on someone’s blog and you have that nagging doubt that the browser will get stuck and when you press Back your comment text will have disappeared.  Just before you hit the Post button, hit Ctrl+A and then Ctrl+C.  Now your text is sitting in memory in case everything goes wonky.

Formatting a document … you’ve just drawn up an entire Word document and want to change the font.  So now you scroll to the top, carefully place your cursor at the top, get annoyed, try again.  Then you scroll to the bottom and try to find the end of the selection (or even worse, you try dragging your mouse across several pages).  Instead, just press Ctrl+A and you’ve selected all the text.

You’ve just written text and you want to clear it.  Perhaps you filled in a web field and you don’t like it and want to start again.  Usually you would try aim your mouse pointer at the top left and try drag it, with a mixture of results, including missing the first character or the extra lines and spaces at the end.  Just hit Ctrl+A and Delete.  Job done.

To be honest, I only really started using Ctrl+A in the last year, and now I find myself using it all over the place.  Seeing as I’m done with this blog post, I’ll now press Ctrl+A, Ctrl+C and Publish.

Active Reports provides the XMLDataSource option for sourcing your data from xml.  My knowledge of all its ins and outs is not substantial, but I ran into two significant problems in a recent project which led me towards an alternative, innovative approach.

The first problem is that an xml document does not guarantee a structure like a database does.  Xml’s flexibility in the layout of elements is beautiful on one hand but hard to fit into a report that expects a fixed structure.

The second problem in my case was the use of sub-reports to cover for different structures in the xml document.  I won’t get fully into the detail, but where an element holds recurring sub-items, you can use sub-reports to list all the items.  The trouble is that a significant number of sub-reports kill your report generation performance.  I had a particular problem where my first report would take 15 seconds to generate on the server, and then degrade by another 5 seconds every time I ran it again.  This is of course totally unacceptable for a frequently used report.

Here then was my innovation … combine Active Reports and XSLT.  Active Reports provides the RichTextBox, which has an Html property to which you can assign the Html you generate from your XSLT.

Now there are a few pros and cons worth mentioning here.  Firstly, using reports as the output of your html provides pagination, which is a lot harder to pull off with pure XSLT and html pages.  As a con, XSLT is obviously not the most friendly computer language you’ve ever used and certainly not as easy as using a visual report designer.  What can be said though is that it is technically testable, or in other words, you can write a set of unit tests to ensure that it does what it’s meant to, which in my opinion is rather hard with Active Reports.

The other concern which needs to be mentioned is that the RichTextBox Html feature is something of a work in progress at the Active Reports lab.  I was originally using the version 3 build 5.0.0.117, which had a number of deficiencies in the html formatting, including no underlining and bold.  I upgraded to build 5.2.1236.2 (released May 2009), which fixed a number of issues, but still inserts an extra new line between tables.

Where the previous report was taking anything from 15 to 90 seconds to run, the newer version ran in 3 to 4 seconds consistently, a massive improvement.  For now I’m willing to suffer the trade-offs in order to get the rapid report generation.

Here then is the general code to generate the Html.  You’ll obviously need to adapt it for your own structure.  In this case the XML I wanted to transform was actually stored in the XMLDataSource, whereas you might source your xml from elsewhere.  You’ll notice that the html needs to be generated for each node or each instance of the detail section.

private void detail_Format(object sender, EventArgs e)
{
    XMLDataSource dataSource = (XMLDataSource)this.DataSource;

    if (_recordCounter >= dataSource.NodeList.Count) return;
    XmlNode resultRootNode =
       dataSource.NodeList[_recordCounter].ParentNode;

    string htmlOutput = GenerateResultsHtml(
       resultRootNode.OuterXml, _xslFilePath);
    const string xmlHeader =
       @"<?xml version=""1.0"" encoding=""utf-8""?>";
    resultsTextBox.Html = htmlOutput.Replace(xmlHeader, "");

    _recordCounter++;
}

public static string GenerateResultsHtml(string xml,
    string xslFilePath)
{
    XsltSettings settings = new XsltSettings();
    settings.EnableDocumentFunction = true;
    settings.EnableScript = true;

    XslCompiledTransform transform = new XslCompiledTransform();
    transform.Load(xslFilePath, settings, null);

    XmlReader xmlReader = XmlReader.Create(new StringReader(xml));
    StringBuilder stringBuilder = new StringBuilder();
    XmlWriter xmlWriter = XmlWriter.Create(
        stringBuilder, transform.OutputSettings);

    if (xmlWriter != null)
    {
        transform.Transform(xmlReader, xmlWriter);
        xmlWriter.Close();
    }
    xmlReader.Close();
    return stringBuilder.ToString();
}

As one last admission, the XSLT was already available for me to use.  Be warned that the transform language while very powerful is a little bit thorny.  At any rate, if you’re experiencing the kinds of problems I was, this may be a viable solution.

Our client required a modification to an existing web solution that displayed confidential results in html format, which could be printed from the results page.  The data was sensitive and was being forged, so we looked at adding a watermark.  This required moving across to using reporting rather than html, so we started building up a report structure.

I was very pleased to find that Active Reports provided a WebViewer control, especially since it gave you the option of either displaying reports with an ActiveX option or with a Adobe Reader option.  My assumption was the latter required extra processing to convert a document to PDF first.  However, the ActiveX option requires the client user to have internet access to download the plugin, whereas the Adobe browser plugin can be installed from a downloadable installer that can be run on any PC.

I was seriously misled though.  Having run down the development path with WebViewer for a while, I couldn’t get rid of the licensing message at the bottom and discovered that the control is only available to Professional users, whereas we were using Standard.  If you do have Active Reports Professional, have a look at the WebViewer.

Fortunately, the Active Reports website hinted at another approach, which I adapted for my own use and it works well.  My original concern with PdfExport was that the user experienced the lag that happens while Adobe Reader fires up in its own window.  Also, if I displayed the PDF in the current window, you lose the context of the website.

The end solution uses an IFrame, effectively using two pages to achieve the solution.  The ViewSpecResult (the parent page) has an IFrame and the PdfPage sits inside it and invokes the report generation.

Here is the ViewSpecResultASP markup:

<%@ Page Language="C#" AutoEventWireup="true"
   CodeBehind="ViewSpecResult.aspx.cs"
   Inherits="ResultsViewing.ViewSpecResult" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" runat="server">
    <title>Results Viewing</title>
    <link href="FormStyling.css" rel="stylesheet" type="text/css" />

    <style id="headerscript" runat="server" type="text/css">
        IFRAME
        {
            POSITION: absolute;
        }
    </style>

</head>
<body>
    <form id="form1" runat="server">
        <div>
            <iframe runat="server" src="PDFPage.aspx" height="70%"
                width="98%" id="IFRAME1"></iframe>
        </div>
    </form>
</body>
</html>

The ViewSpecResult C#/VB code is empty.  The PdfPage ASP markup is like this:

<%@ Page Language="C#" AutoEventWireup="true"
   CodeBehind="PDFPage.aspx.cs" Inherits="ResultsViewing.PDFPage" %>
<%@ Import Namespace="ResultsViewing"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Results Report</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>

    </div>
    </form>
</body>
</html>

The PdfPage.aspx.cs code looks something like this in my application:

public partial class PDFPage : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        string xml = ReportController.GenerateXmlForSpecimenArray();

        MemoryStream m_stream =
           ReportController.GenerateReportToMemoryStream(xml);

        Response.ContentType = "application/pdf";
        Response.AddHeader("content-disposistion",
           "inline; filename=MyExport.pdf");
        Response.BinaryWrite(m_stream.ToArray());
        Response.End();
    }
}

This calls through to a central controller close, which generates the report something like this:

public static ReportSimple GenerateReport(string xml)
{
    string xslFilename = HttpContext.Current.Server.MapPath("~")
        + "header.xsl";
    ReportSimple report = new ReportSimple(xslFilename);

    XMLDataSource dataSource = new XMLDataSource();
    dataSource.FileURL = null;
    dataSource.RecordsetPattern = "//SPECIMEN_HEADER";
    dataSource.LoadXML(xml);

    TrimXmlNodes(dataSource);
    report.DataSource = dataSource;
    SetWatermark(report);
    report.Run();

    return report;
}

public static MemoryStream GenerateReportToMemoryStream(string xml)
{
    MemoryStream memoryStream = new MemoryStream();
    ReportSimple report = GenerateReport(xml);

    PdfExport export = new PdfExport();
    export.Security.Encrypt = true;
    export.Security.Permissions = PdfPermissions.AllowPrint;
    export.Export(report.Document, memoryStream);
    memoryStream.Position = 0;
    return memoryStream;
}

Now all this code has been adapted from the official Active Reports knowledge base, where the solution is more complex in that it provides for a separate Web Service to do the report generation, which helps to spread the server load.  This was overkill for my application.

Note that I pulled off some interesting XML data sourcing for this application.  I’ll write about it in another post after this for those who are interested.  I saved huge amounts of processing time this way using XSLT.

I had a system deployed to a client site, and everything was working perfectly. The system administrator at the client site did a few things on the server, and next thing the Reports in the web site that use Microsoft SQL Server Reporting Services were giving an error.

Nothing had changed that should have affected the site! So, what could be causing the error?

The error in the report viewer was: “Object reference not set to an instance of an object.”

That’s an all too familiar error to anyone that has programmed in .NET and it is always slightly amusing to find it in someone else’s released program. The other day I got one from SQL Server Administrator when I clicked on something in the tree view on the left (just after I had freshly installed Reporting Services). Aha, so they are not infallible! A slight grin etched itself across my face. Well, anyway, the solution was a tried and tested standard Windows solution… Restart the PC. Amazing how often that works with Microsoft stuff hey! But in my case I was getting the error in my application, in a section that I had no control over, so how could I save myself this embarrassment?

Well, to get to the root of the issue, I had a look at the ReportServer_XXX.log found in the “C:\Program Files (x86)\Microsoft SQL Server\MSSQL.2\Reporting Services\LogFiles” folder on the server. The error message I was seeking was nowhere to be found! Aaargh! So, to the next point of call, the system event log. Aha! I found an error message there:

Event Type: Warning
 Event Source: ASP.NET 2.0.50727.0
 Event Category: Web Event
 Event ID: 1309
 Date: 6/2/2009
 Time: 10:25:45 AM
 User: N/A
 Computer: SERVERX
 Description:
 Event code: 3005
 Event message: An unhandled exception has occurred.
 Event time: 6/2/2009 10:25:45 AM
 Event time (UTC): 6/2/2009 8:25:45 AM
 Event ID: aeb8ddc7f53b431ead3b7a0c88ec5a5b
 Event sequence: 77
 Event occurrence: 2
 Event detail code: 0

Application information:
 Application domain: /LM/W3SVC/1/root/Reports-2-128884044406093750
 Trust level: RosettaMgr
 Application Virtual Path: /Reports
 Application Path: C:\Program Files\Microsoft SQL Server\MSSQL.2\Reporting Services\ReportManager\
 Machine name: SERVERX

Process information:
 Process ID: 1544
 Process name: w3wp.exe
 Account name: NT AUTHORITY\NETWORK SERVICE

Exception information:
 Exception type: NullReferenceException
 Exception message: Object reference not set to an instance of an object.

Request information:
 Request URL: http://localhost/Reports/Reserved.ReportViewerWebControl.axd?OpType=StyleSheet&Version=2005.090.1399.00 [^]
 Request path: /Reports/Reserved.ReportViewerWebControl.axd
 User host address: 127.0.0.1
 User: SERVERX\UserX
 Is authenticated: True
 Authentication Type: Negotiate
 Thread account name: NT AUTHORITY\NETWORK SERVICE

Thread information:
 Thread ID: 6
 Thread account name: NT AUTHORITY\NETWORK SERVICE
 Is impersonating: True
 Stack trace: at Microsoft.Reporting.WebForms.WebRequestHelper.GetExceptionForMoreInformationNode(XmlNode moreInfo, XmlNamespaceManager namespaces)
 at Microsoft.Reporting.WebForms.WebRequestHelper.ExceptionFromWebResponse(Exception e)
 at Microsoft.Reporting.WebForms.ServerReport.ServerUrlRequest(Boolean isAbortable, String url, Stream outputStream, String& mimeType, String& fileNameExtension)
 at Microsoft.Reporting.WebForms.ServerReport.GetStyleSheet(String styleSheetName)
 at Microsoft.Reporting.WebForms.ReportServerStyleSheetOperation.PerformOperation(NameValueCollection urlQuery, HttpResponse response)
 at Microsoft.Reporting.WebForms.HttpHandler.ProcessRequest(HttpContext context)
 at System.Web.HttpApplication.CallHandlerExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute()
 at System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean& completedSynchronously)

Custom event details:

For more information, see Help and Support Center at http://go.microsoft.com/fwlink/events.asp. [^]

That’s great, but it doesn’t really help that much. It’s not really something I can debug, fix and recompile because it’s right in the middle of Microsoft.Reporting. Well, ok maybe it’s slightly to the left of the middle of the component, but it’s still out of reach!

I turned to Google for answers. Very quickly I found this result:

http://social.msdn.microsoft.com/forums/en-US/sqlreportingservices/thread/ef0f1c39-fc92-4cde-9920-597a8d6981f9/

I tried accessing the Reports Manager web site at http://localhost/Reports and got the 403 error that the guys in the forum post above were talking about. At the end of the forum post it gives the solution. Some other places suggested reinstalling SQL Server, don’t listen to them!!!!!

!!! SOLUTON !!!

Just open the Reporting Services Configuration tool and in the Report Server Virtual Directory Settings section tick the “Apply Default Settings” checkbox and click “Apply”. No more problem!

So, the problem was not with my Web Site, but in fact some strange problem with Reporting Services. Whew, I was doubting myself for a moment there. The “Object reference not set to an instance of an object” bug is someone else’s embarrassment to sort out

Hope this has helped you.

All the best…