Pearl Tech » Application Development

Enterprise Library Logger.Write Not Working?

Geer — Mon, 17 May 2010 21:29:50 +0000

Using Logging Application Block provided by Enterprise Library is a common way of logging exceptions in .NET applications. It’s easy to setup and to use. One problem I had a while ago was that it worked while on my development PC, but stopped working once it’s deployed.

What I was doing was to use it to write event entries in windows event log as part of the exception handling in an ASP.NET web application. Nothing fancy. It worked fine on my PC, but it didn’t write anything to the event log when Logger.Write is executed. No exception was thrown from that line of code either. The program just went through as if that line of code was skipped.

It turned out to be a permission issue. When I debug the application in Visual Studio, it was running under my windows account credential which had permission to create Event Source in the system. However, when the application was deployed to the server, it was running under the default account which was “NT Authority\Network Service” in my case. By default, that account doesn’t have permission to create new Event Source in the system. It does have permission to write event entries though. So, when Logger.Write was executed, it couldn’t proceed because the Event Source wasn’t there, and the program didn’t have permission to create one. Actually, it makes sense to not throw any exception on this line, because people like me usually use this to log exceptions, and if the logging process itself throws exceptions, there is probably nowhere else we can handle and/or log them.

Now, how this can be resolve? The solution is quite simple. As long as the Event Source is created ahead of time, it will be no problem. What I did was to create required Event Source(s) on server through CMD.exe. Here is a sample command:

eventcreate /ID 1 /L Application /T information /SO "My Event Source" /D "My Event Source is created."

This command will create an event entry in the Application log. If the Event Source doesn’t exist, it will be created during the process. This is only required when the application is deployed to the server first time. So, I usually do it manually on server. However, if that’s not the case, you can build it into the installation package, and when the application is installed, the Event Source is created as well. Of course, you can use .NET to create Event Source in your installer too.

Exception Handling in ASP.NET Web Application

Geer — Thu, 22 Apr 2010 22:14:09 +0000

In web application development, we should always think about returning some kind of message to users when an exception is raised in the program. Sometimes, it can be very specific, while in other cases it can be generic. A common thought is to capture and possibly handle exceptions where they are raised, re-throw exceptions or raise custom exceptions as needed so they can propagate up to higher level tiers in the application, handle/log exceptions at a central place in the highest tier of the application, and finally display an error message to the end-users or redirect them to a customized error page.

This pattern works, but sometimes it is tricky to generate a meaningful message. The problem is that the exception can be thrown anywhere in your application, and the exception message may not always be appropriate or meaningful to end-users. If you blindly display all exception messages you finally get, users may see something like “Object reference not set to an instance of an object” which doesn’t mean much to them. So, in the final step of exception handling (where the program displays error messages or redirect users to an error page), you will see all kinds of exceptions which include .NET originated exceptions, exceptions raised by the program on purpose, and custom exceptions. Some of them are appropriate to show to users, while others aren’t. So, the question is how you can distinguish among them.

A lot of people suggest that if the original .NET exception message isn’t meaningful to users, and you can’t provide more specific message either, then a generic message such as “An error has occurred… Please contact the technical support team for help” can be used. I agree too. You may do this where you know an exception can be thrown, and re-throw the exception with customized message (whether specific or generic) and with the original exception embedded as the inner exception of the new exception. However, you don’t want to just put try/catch blocks in every piece of your code, and catch and re-throw every exception the program may possibly encounter. It’s labor intensive and inefficient. Also, there will always be something you can’t think of or look over, so there are still chances you can get unexpected exceptions in the end.

So, my solution is to let the program only catch and re-throw .NET originated exceptions when they are predictable and additional meaningful information can be provided, and let all other exceptions bubble up to the top tier. Then in the final step of exception handling, identify the exceptions that are re-thrown, and retrieve the error message directly from these exceptions; use a generic error message for all other exceptions. The question is how to identify these exceptions that are re-thrown. For this purpose, I usually create a custom exception class which is inherited from System.Exception. Use this class whenever I need to throw new exceptions or re-throw .NET originated exceptions. So, in the final step, I check the type of the exception, and decide whether to use it as the error message or use a generic one instead.

Here is the custom exception class:

public class ExceptionBase : Exception
{
public ExceptionBase(string msg, Exception innerEx)
: base(msg, innerEx)
{
}
public ExceptionBase(string msg)
: base(msg)
{
}
}

The ExceptionBase class has two constructors which give you the options to create an instance of exception with customized error message and with/without inner exception.

Here is how to use it in code:

throw new ExceptionBase(“Error has occurred in accessing database.”);

try
{
// Data access operations
}
catch (Exception ex)
{
throw new ExceptionBase(“Error has occurred in accessing database.”, ex);
}

The central location I handle all exceptions is in global.asax, and here is what it looks like:

protected void Application_Error(object sender, EventArgs e)
{
Exception ex = Server.GetLastError();
string msg = “Unexpected error has occurred.”;
if (ex != null)
{
LoggingUtility.LogException(ex);
// Remove the HttpUnhandledException wrapper if there is one
if (ex.GetType() == typeof(HttpUnhandledException) && ex.InnerException != null)
{
ex = ex.InnerException;
}
// If this is a custom exception, change the message.
if (ex is ExceptionBase)
msg = ex.Message;
Server.ClearError();
}
// Try to redirect user.
Response.Redirect(string.Format(“~/Error.htm?aspxerrorpath={0}&error={1}”, HttpUtility.UrlEncodeUnicode(Request.Url.PathAndQuery), msg), true);
}

One note for this is that ASP.NET may put a wrapper exception (HttpUnhandledException) around the original exception. In the code above, it is simply removed because it doesn’t contain any useful information.

You can also create more custom exception classes based on the ExceptionBase class to improve consistency in your application, and the code above will still work. One example is:

public class BadUrlException : ExceptionBase
{
public BadUrlException(Exception innerEx)
: base(“Bad URL has been detected. Request could not be processed.”, innerEx)
{
}
}

This way the error messages for one type of exception are consistent across the application.

How to Use Microsoft Device Emulator in VS2008

Geer — Wed, 31 Mar 2010 13:37:18 +0000

Microsoft Device Emulator is a great tool for testing your mobile web applications without utilizing any real mobile device. Because it can use the same network that your computer is on, you can use it to test your mobile web applications hosted on development computers or test servers before the applications are published to the internet. It is part of the Visual Studio 2008, so you can set it up with very minimal work, if you already have VS2008 installed. It can also be installed separately. In the rest of this post, I will demonstrate how to set it up, to use your local network and access your mobile web applications.

Here are a few things you will need to have on your computer to continue.

Windows Virtual PC 2007. This is required, if you would like to connect the Device Emulator to your local network. The software can be downloaded from Microsoft website.
Microsoft Visual Studio 2008.
Microsoft Device Emulator (which comes with VS2008).

With all the above requirements available on your computer, you can follow the steps below to configure your Device Emulator.

Start VS 2008 IDE.
On the menu, go to Tools >> Device Emulator Manager
Start Device Emulator Manager
Right-click on a device you would like to use, and choose Connect option.
Connect to A Mobile Device
After the device is connected, right-click on the connected device again, and choose Cradle.
Cradle the Connected Device
Go to the device window. On the menu, choose File >> Configure
Configure Device
Go to the Network tab, and select the options as shown in the screen shot below. And then click OK to close the window.
Choose Network Card
In the device window, on the menu, choose File >> Reset >> Soft. And wait until the device is restarted.
Now you need to configure the internet connection in the mobile device. (The process could be different depending on what device you have picked.) Normally, you would find the Settings option in the main menu, and then go to the Connections section to choose/define an internet connection. Here below I use the device I chose as an example.
Choose Settings >> Connections >> Advanced >> Select Networks, and then choose My ISP for both Internet and Private Network connections.
Choose Settings

Choose Connections

Choose Advanced Settings

Choose My ISP
After confirming all these changes, you can now visit your mobile web application or internet using this Device Emulator. Task accomplished!
Your Mobile Website

Setting Siebel EIM Process Batch Number in Command Line

Geer — Thu, 25 Mar 2010 15:02:19 +0000

My customer’s current process of importing data into Siebel database is to use Siebel EIM interface. The data which needs to be imported will be formatted and inserted into EIM tables (or the staging tables), and then an EIM process will be ticked off in the command line to import the data into Siebel base tables. The command is fairly simple, and should be similar to the following:

[Path to The Siebel Application Bin folder]\srvrmgr.exe /g [Siebel Application Server Name] /e [Target Siebel Environment] /s [Siebel Application Server Name] /u [User Name] /p [User Password]

run task for component EIM with config=”[Config File].ifb”,Process=”[Process Name]“

The first command starts the srvrmgr program, and the second one ticks off the EIM process. The configuration file ([config File].ifb) specifies all the parameters needed by the EIM interface in order to complete the process. One of the important parameters we need to set in the .ifb file is the BATCH, which is the identifier for the group of data being handled during the current process. Normally, we set it to a fixed number or a range of numbers (for example, 500-600). So, when the EIM process runs, only the data with a batch number equal to the BATCH or falling in the range specified in the .ifb file will be processed. If in the EIM tables there are some records which are not ready to be processed at this moment, they can be skipped by identifying themselves with a different batch number. This is helpful when you are managing multiple data importing tasks which share the same set of EIM tables, and run at different time.

However, we soon realized that it would be getting harder and harder to manage these .ifb files and to make sure these EIM processes don’t interfere with each other. For example, one of our custom applications needs to import data into Siebel using EIM interface upon users’ requests. The data importing process is exactly the same for all these requests, except for the data needed to be imported. Multiple users need to be allowed to submit their requests at the same time, and their requests should be handled separately. If we were going to do it in the old fashion, we would need to have a .ifb file for each of their requests, and use different batch numbers in these .ifb files. It is not realistic, or it is something we want to do either.

The solution is actually very simple. We took the BATCH setting out of the .ifb file, and instead we set it in the command line. This was not documented in the Siebel EIM Admin Guide, but after our testing it was proved to be a working solution. The command will look like the following now:

[Siebel Application Bin folder]\srvrmgr.exe /g [Siebel Application Server Name] /e [Target Siebel Environment] /s [Siebel Application Server Name] /u [User Name] /p [User Password]

run task for component EIM with config=”[Config File].ifb”,Process=”[Process Name]“,BATCH=[Batch Number]

This way the application can choose a BATCH number unique to the user’s request, construct the command, and then execute it to tick off the EIM process, and all these requests can share the same .ifb file.

To manage the batch numbers among different applications, we reserved a range of batch numbers for each application. For example, from 500 to 549 will be used only by application A, and from 550 to 599 will be used only by application B. Within each application, a batch number is assigned to each request based on the request identifier and the range of batch numbers reserved for the application. In our case, the request ID is an auto-incrementing integer, and the equation for calculating the batch number is:

[Batch Number] = [Request ID] % [Total Number of Allocated Batch Numbers] + [The Lowest Batch Number]
(Where % stands for the modulus operator)

For example, if the allocated batch numbers are from 500 to 549, and the current request ID is 1034, the batch number for this request will then be:

534 = 1034 % (549 – 500 + 1) + 500

This way the adjacent requests would have different batch numbers, and the batch numbers are used in a cycle. In our case, we will never have more than 50 users submitting their requests at the same time, but if this was for a larger user base, we could allocated a bigger range of batch numbers.

So, we finally were able to manage all users’ requests using limited batch numbers and a single .ifb file without the requests being interfered by each other. Task accomplished!

Developing with Windows Mobile 7

AaronH — Wed, 24 Mar 2010 21:27:28 +0000

Microsoft recently announced the general availability of developer tools for their Windows mobile platform. This article is a brief introduction to the platform and what the next generation of mobile development for Microsoft looks like.

After you’ve downloaded the developer tools installer, you will go through a download process…

After downloading the remaining components, you will install all component resources.

Once the developer tools have been installed, you can startup Visual Studio 2010 Express for Windows Phone which is the IDE used for the mobile development.

We will use the Silverlight for Windows Phone – Windows Phone Application project template and add some custom XAML and image resource to the base project.

In this simple application we’ve titled Mobile Portal just going to add some textblocks, buttons, and use a standard Silverlight grid layout. We first modify MainPage.xaml to create our custom view for the mobile application. Here is a view of our coding changes.

Next, we go to our Solution Explorer add our image resource using the context menu on the project and selecting Add -> Existing Item.

Finally, we add our custom styles to App.xaml. After building the solution and running the emulator, we see the following results.

If we rotate the device orientation, we can see how the view shifts to fit the space available.

We are glad to see that Microsoft is embracing the WPF and Silverlight-based development engine for the mobile platform. This decision allows developers and designers skilled in XAML to leverage their existing knowledge and prowess to create useful mobile applications for both business and pleasure. The small footprint of Silverlight makes it ideal for usage with embedded or mobile systems with limited power and memory.

You can download our complete solution here.

FileUpload Control not working in UpdatePanel

Geer — Mon, 25 Jan 2010 16:08:11 +0000

You may have experienced the problem with FileUpload control in an UpdatePanel – when you hit the submit button, Request.Files.Count always returns 0, even though you had registered the submit button as a PostBackControl and a PostBackTrigger of the UpdatePanel containing the FileUpload control.

In my case, the FileUpload only works when it is visible when the page is first time loaded (not a postback). It will not work (Request.Files.Count returns 0) when it is hidden originally and then made visible during later AsyncPostBacks. Maybe ASP.NET is confused, because I am also changing the submit button’s postback type between full postback and aysnc postback. The submit button is used by other things, and I only want it to fire a full post back when files need to be uploaded, and in all other cases, I want it to fire async postback and only do partial update on my page.

I spent many hours trying many different solutions I saw on the internet, but none of them worked for me. However, I found an important hint which led me to the final working solution. That is the Enctype attribute of the Form. I learned that the Form.Enctype has to be “multipart/form-data” when files need to be uploaded. I think this is set automatically for you in normal cases, but it isn’t set up correctly in my case. So, I manually set it to “multipart/form-data” in OnInit of my user control, and it solves the problem.

Adding PDF icon to SharePoint Document Libraries

AaronH — Mon, 16 Nov 2009 17:10:16 +0000

One of the missing features in MOSS 2007 is the ability to recognize PDF files in a document library. It can be frustrating when all you see is a blank page icon instead of SharePoint recognizing the document type properly. This is a common portal issue that is easily remedied with a bit of extra configuration. Here is an example of how PDF items are normally displayed inside of a library view.

Following the Microsoft KB you can see that you need to edit the docicon.xml file located at the path C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\TEMPLATE\XML

The Docicon.xml configuration file is a listing of all document types that are supported by SharePoint. To support the PDF icon, you need to add the following Mapping XML element to the XPath //DocIcons/ByExtension. The Mappings are listed in alphabetical order, so you should insert the PDF mapping accordingly.

Here is the Docicon.xml file after the edit.

The next step is retrieving the small PDF icon from Adobe. When you have download the icon image, you need to save the image as “pdficon.gif” to match the mappings entry we created earlier. The last step is to copy the PDF icon image to the SharePoint template images path: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\TEMPLATE\IMAGES\pdficon.gif. This is the location where SharePoint will search for document type icons for rendering in document library views – according to the configured file extension mappings in docicon.xml.

After these steps have been completed, you can now visually distinguish the document type for PDF extensions with a quick icon type indicator.

Easy Access to Code Snippets with CodeKeep

ThadK — Mon, 09 Nov 2009 19:37:34 +0000

Remembering exact syntax seems to be a common issue for programmers. We tend to rely on Google or previous projects for a quick example to get us on the right path. Whether it’s a one line regular expression or an entire method, programmers are frequently looking at code samples.

Visual Studio has built in support for snippets, but some of the functionality is limited. For a while, I have kept simple methods and queries stored in files on my computer for quick access. I have found a simple solution for Visual Studio, as well as online for quickly accessing, storing and sharing routinely used snippets of code that will replace my old ways of storing snippets.

(www.CodeKeep.net) allows users to store and easily retrieve code snippets in many common programming languages. At the time of this posting, there are currently 28 languages that you can store, share, and search. There are two easy ways of adding and viewing your snippets. First, is on their website. The website allows you to not only view and manager your snippets, but it also lets you look through snippets other have chosen to share – when adding snippets, you have the ability to make your snippets private or public. The other way to access snippets is through a Visual Studio add-in (available in for both Visual Studio 2005 and 2008). Both options will let you store, browse, and search for code snippets.

Installation instructions

When installing, I recommend setting up an online account first. This will make the installation flow a little more smoothly. Make sure to have Visual Studio closed for the installation. Once you have an account setup, download and run the MSI to install CodeKeep. Make sure the read the ReadMe file. After installing the application, you will also need to copy three files into the Addins directory in you default project folder.

Once installed, the add-in is available through the Tools Menu

Because this is an online service, the snippets are not stored on your computer by default. However, the website does allow users to export their snippets. Whether you want to take them on the go, or simply back them up, browse to “My Snippets” and click Export Snippets. All of your snippets can be saved to an XML file.

Note: While using the add-in, I have hit a few bugs that will crash Visual Studio. Upon restarting VS, I get an error “Object reference not set to an instance of an object”. To get rid of this, I had run the MSI again and repair the installation.

This also required me to log into my account again.

Deploying to Google App Engine

AaronH — Thu, 05 Nov 2009 17:55:40 +0000

Google has opened up their hosting services to the cloud with their free Google App Engine offering. Google makes it quick and easy to get going with their cloud offerings. Here a quick review of how to get started with the App Engine.

To use App Engine, you need a Google Account. Once you have your Google Account, you can enable App Engine services by entering in your cell phone number and carrier on the App Engine setup page. Google will send you an SMS with an access code you need to enter into the website. This activation scheme is Google’s way of restricting you from creating multiple App Engine accounts.

When you have received your code via SMS and entered your activation code, you can begin creating applications. The following appears after you have activated your App Engine account.

When you click “Create an Application” you can enter an application alias where your new application will be hosted on the appspot.com domain.

If your alias is available, you can then create an application and deploy to your new cloud application. In this example, we created the alias “pearlcompanies”.

Since we’re running in a windows environment, our next step is to setup Eclipse and the Google Plugin for Eclipse to deploy to our cloud application. We used Eclipse 3.5 (Galileo) in our example. After unpacking the Eclipse folder contents, we tell Eclipse where to get the Google Plugin. We add the available software site “http://dl.google.com/eclipse/plugin/3.5″ to our Eclipse Preferences.

Download and Install both the Google Eclipse plugin and GWT and App Engine SDKs.

After installing the Google SDKs, we can create Google App Engine projects (Web Application Projects). The nice thing here is that we can run the cloud application locally and verify it before deploying remotely to the cloud. The Google SDK comes with the components necessary to simulate the cloud environment.

Once we have our web project, we can begin creating our WAR package for deployment into the App Engine cloud service. The current App Engine supports Java and Python environments, but in this example we are going to use the Java runtime. Since we’re demonstrating deployment here, we are not going to use any servlets, but simply an HTML front-end. After changing the index.html page in our web project, we click the App Engine icon in the Eclipse toolbar.

After clicking the icon, we are prompted with the deployment wizard which has our Google account credentials and a link to the App Engine project settings. Click the project settings and enter the Application ID and version for the application (use the alias we setup previously).

Click ‘Ok’ on the properties dialog, and then enter your login credentials. Once you click ‘Deploy’, your application will be pushed into the Google App Engine cloud. You can view and manage your applications that are live in the Google App Engine site.

You can view the clone of our Pearl Companies website which we deployed to pearlcompanies.appspot.com. Please let us know about your App Engine experiences. We look forward to using this new powerful platform.

Deploying to Windows Azure

AaronH — Mon, 02 Nov 2009 20:32:25 +0000

Microsoft is expected to remove the CTP from their Azure Platform this month at PDC in Los Angeles. Until then, you can still receive access to their free cloud services platform. To get started with Azure you need a Windows Live ID and signup with Microsoft Connect to receive an access code (aka tokens).

When you receive your access token, you can begin creating projects on the Azure platform with the Azure Developer Portal. You can only create one project with the CTP, but you can have multiple services inside each project (web/worker roles).

After you’ve created your project in the developer portal, you can add services which will be the endpoints you deploy to for Windows Azure. We will add a Windows Azure Service in this example.

To create our Windows Azure application, we need to create a package (cspkg) that contains our application contents and a configuration definition (cscfg) that defines our roles. Microsoft has created Azure tools to assist in generating the package and configuration file. You can download the Azure SDK to create Azure applications using Visual Studio. The Azure SDK allows you to run your own local development fabric before pushing your application into the cloud. Eclipse also has its own Azure Tools if you prefer to develop in the Eclipse environment.

After installation of the Azure Tools, you now have a new project template “Cloud Service” which we’ll use to create our web role.

After providing a name for your Cloud Service project, you are prompted to select which roles you would like to use. We will choose “ASP.NET Web Role” for this example.

After clicking “Ok”, you will now have a Cloud Service project and a Web Role project in your solution. We will now remove the Web Role for this exercise, and replace it with an existing ASP.NET application called ASP.NET Chart Controls which Scott Guthrie announced last year. This application did not work on the PDC release of Azure, but Azure now allows web applications to run in Full Trust with some minor tweaking.

We now have our solution complete and have one web role we would like to deploy to the cloud. We must now publish the solution to Azure. We right-click on the Cloud Service project and click “Publish” which opens up the Azure Developer Portal.

After logging in with Windows Live, you want to deploy your application to the Staging Environment before pushing it live. To deploy, you simply select the application package (cspkg) and configuration definition (cscfg) from your “/publish” folder in the cloud service “/bin/Debug” directory.

Clicking on “Deploy” will load the Azure package and service definition to the cloud and create a VM necessary to run the application. The environment takes some time to setup and will show its state as “Initialization” until the VM is entirely ready. You are given a URI based upon a randomly generated GUID to view your application and test it before moving it into production. Having two environments is nice if you also have database changes that need to coincide with your deployment.

Once the application has been verified, you can click the center arrows icon to swap the Staging site into Production. You can see the two environments have now been switched.

Azure does make the deployment process a bit more involved, but there is an managed Azure Deployment API in the works to automate the build and deploy steps you may need in your organization. You can view our sample ASP.NET Chart Controls application running on Azure Services (cloudapp.net). Kudos to Microsoft for allowing full trust applications! We will be watching for more exciting features from the Azure Team.