heathesh.com

Simple SQL proc to generate an enum class for a lookup table

Admin — Wed, 08 Feb 2012 01:40:00 -1000

Here's the proc I created and below is the explanation of how I went about doing this: http://heathesh.com/code/sql/GenerateEnumClass.txt

I'm sure every c# developer has come across a situation where they have a lookup table that they'd like to convert into an enum in code. I've actually had to do it a few times myself and each time I use some sort of cursor and t-sql to create the enum class code. So I figured why not create a procedure to do this that I could re-use?

To begin with, there's a few parameters I needed to pass into the procedure. These were:

The table name
The namespace I wanted of the code
The DataContract namespace. Because most of the stuff I do now is WCF this was a necessity but you can obviously remove this if you want.
The id field on the lookup table.
The value field on the lookup table.

I've attached the proc for you to copy (http://heathesh.com/code/sql/GenerateEnumClass.txt). The basics of how it works is that I insert the id and value fields into a temporary table using sp_executesql, then loop through the values using a cursor and simply use print statements to output the relevant code.

To use the proc I created a simple table called Title with an Id and a Name column like so:

CREATE TABLE [dbo].[Title](
 [Id] [int] IDENTITY(1,1) NOT NULL,
 [Name] [varchar](50) NOT NULL,
 CONSTRAINT [PK_Title] PRIMARY KEY CLUSTERED 
(
 [Id] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, 
ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

I then populated the table with values like so:

INSERT INTO [Title] ([Name]) VALUES ('Mr')
INSERT INTO [Title] ([Name]) VALUES ('Mrs')
INSERT INTO [Title] ([Name]) VALUES ('Miss')
INSERT INTO [Title] ([Name]) VALUES ('Dr')
INSERT INTO [Title] ([Name]) VALUES ('Prof')
INSERT INTO [Title] ([Name]) VALUES ('Sir')
INSERT INTO [Title] ([Name]) VALUES ('Madam')
INSERT INTO [Title] ([Name]) VALUES ('Mr And Mrs')

You'll notice one of the values has spaces in it. Since enum names cannot have spaces in it when you run the proc you'll notice in the output that it adds the Description attribute with the full name of the row, this is so you can still get the value of the string. If you need help with this check out a previous post of mine on reading the description attribute: Reading the DescriptionAttribute of enumerators ...

Then I simply ran my proc like so:

 [GenerateEnumClass] 
  'Title', -- this is the name of the lookup table
  'Heathesh.Com.Entity', -- this is the namespace I wanted to appear in the code
  'http://heathesh.com/entities', -- this is the data contract namespace I wanted to appear in the code
  'Id', -- this is the id field of the table
  'Name' -- this is the name field of the table

And this produced my required output like so:

using System;
using System.Runtime.Serialization;
using System.ComponentModel;
 
namespace Heathesh.Com.Entity
{
 /// <summary>
 /// Title enum
 /// </summary>
 [Serializable]
 [DataContract(Name = "Title", Namespace = "http://heathesh.com/entities")]
 public enum Title
 {
 [EnumMember]
 Mr = 1,
 [EnumMember]
 Mrs = 2,
 [EnumMember]
 Miss = 3,
 [EnumMember]
 Dr = 4,
 [EnumMember]
 Prof = 5,
 [EnumMember]
 Sir = 6,
 [EnumMember]
 Madam = 7,
 [Description("Mr And Mrs")]
 [EnumMember]
 MrAndMrs = 8,
 }
}

I simply then added a "Title.cs" class to my project, replaced all the code in the class with what was generated and that was it. An enum class generated using sql from a lookup table.

Please note: Don't forget to add a reference to "System.Runtime.Serialization" in your project for the WCF stuff (DataContract, DataMember, EnumMember etc.)

Happy generating!

Using the Twitter REST API and Json.NET to see who doesn't follow you back on Twitter

Admin — Fri, 03 Feb 2012 05:09:00 -1000

I prefer following people that follow me back on twitter. So I normally check http://www.friendorfollow.com/ and generally unfollow people that aren't following me. While digging around the twitter dev site I found the REST APIs and I wanted to see what I could do with them. I figured a little console app that showed me who isn't following me back might be a decent challenge so I set off creating one.

I normally post step by step instructions of what I did in my blog posts, however this time I'm included the source code of the app so people can do whatever they want with it and I'm going to give you a basic run down of how the app works. You can download it here: http://heathesh.com/code/csharp/TwitterFollowerTest.zip

To begin with, I used the Twitter REST API to get a Json dataset of all the people I follow and all the people following me (I created a setting called "UserToCheck" in the app.config file so you can simply change this to any twitter handle to run the check for that account). I used Json.NET (http://james.newtonking.com/projects/json-net.aspx) to parse this Json into a simple list of user ids for each of the above. Then I simply iterated through the list and for anybody who wasn't following me I used another Twitter REST API call to get back that user's details in another Json dataset.

In order to make the user's detail more "user friendly" I created a simple class called TwitterUser and using the "DescriptionAttribute", reflection and Json.NET I populated this object with the Json dataset. Then I simply write out each screen name of whomever is not following me but from the code you will see you have a fully populated TwitterUser object which you could do quite a bit with (like display their twitter pic, bio etc.).

I'm pretty sure the code is pretty self-explanatory, but as usual if you have any questions feel free to contact me using my Contact page (http://heathesh.com/contact.aspx).

Happy tweeting!

How to install and get FILESTREAM working using SQL Server 2008 and Windows XP

Admin — Thu, 14 Jul 2011 00:43:00 -1000

To simplify this I'm just going to give you a step by step of what I did, I hope this helps you. If you have any problems with it please feel free to use my Contact page to get in touch and see if I can help you.

1. Run the Sql Server Configuration Manager

All Programs --> Microsoft Sql Server 2008 --> Configuration Tools --> Sql Server Configuration Manager

2. Select "SQL Server Services" which will populate the frame on the right, then right click and select "Properties" on the SQL Server Instance you want to enable this on

3. Select the FILESTREAM tab, check all the checkboxes on the tab

4. Click "Apply" then "OK"

5. Close the "Sql Server Configuration Manager", and open SQL Server Management Studio.

6. Connect to your SQL instance and then right click the instance name and select "Restart".

7. Next select "New Query".

8. Copy and paste the following into the window and run it, you only need to change "[Your Database Name]" to whatever the database you're trying to enable the filestream on:

EXEC sp_configure filestream_access_level, 2

RECONFIGURE

alter database [Your Database Name]
add FILEGROUP [MY_FILESTREAM] CONTAINS FILESTREAM

8. Install the following hotfix:

http://hotfixv4.microsoft.com/Windows%20XP/sp4/Fix303510/2600/free/403099_ENU_i386_zip.exe

If that link above is broken for whatever reason, you'll have to download the hotfix by starting here:

http://support.microsoft.com/?id=978835

They require you to supply them with your email address for some reason, I have no idea why.

9. Restart your PC.

10. Once restarted, open "SQL Server Management Studio" and run this (feel free to change the file location if you need to):

alter database [Your Database Name]
add FILE ( NAME = N'my_filestream', FILENAME = N'C:\Program Files\Microsoft SQL Server\MSSQL10.MSSQL2008\MSSQL\DATA\MyFileStream.Repository' )
TO filegroup [MY_FILESTREAM]

That should be it. Happy streaming!

Parallel processing of a list of items using a dynamic number of threads

Admin — Mon, 20 Jun 2011 01:46:00 -1000

While working on a project I came across an interesting problem. I had a list of items to process and I wanted to run a certain number of those items at the same time and let the number of items running at the same time be set in a settings file. To illustrate how I did this, let's start of with the items I was going to process. In this case let's say I had a class called "Queue" and each "Queue" item was something I need to do some work with.

 /// <summary>
 /// Queue entity
 /// </summary>
 public class Queue
 {
 /// <summary>
 /// Gets or sets the id
 /// </summary>
 public int Id { get; set; }

 /// <summary>
 /// Gets or sets the name
 /// </summary>
 public string Name { get; set; }
 }

Now in my application, I have a list of these Queue items and I want to be able to process more than one at a time, and I want to be able to set how many items I'm processing at a time in a settings file. So I added a setting file called "QueueSettings.settings" and added a setting called NumberOfThreads which I set to "3".

Now let's pretend my List of queued items to process looks like this:

 List<Queue> queuedItems = new List<Queue>();

 queuedItems.Add(new Queue { Id = 1, Name = "Apple" });
 queuedItems.Add(new Queue { Id = 2, Name = "Banana" });
 queuedItems.Add(new Queue { Id = 3, Name = "Orange" });
 queuedItems.Add(new Queue { Id = 4, Name = "Pear" });
 queuedItems.Add(new Queue { Id = 5, Name = "Peach" });

And for simplicity sake, the method that actually processes the Queue item looks like this:

 /// <summary>
 /// Process the queued item
 /// </summary>
 /// <param name="queue"></param>
 private static void processQueuedItem(Queue queue)
 {
 Console.WriteLine("Processed: {0} - {1}", queue.Id, queue.Name);
 }

Now we need to create a method that will call the above method as we require. So we first add the following namespace to our application:

 using System.Threading.Tasks;

Then we create the method that does the actual processing:

 /// <summary>
 /// Processes the queued items
 /// </summary>
 /// <param name="queuedItems"></param>
 /// <param name="threadsToUse"></param>
 private static void processQueuedItems(List<Queue> queuedItems, int threadsToUse)
 {
 //calculate how many times we need to loop, by determining how many times we'll do a full set of
 //items and adding one for the remainder of items. For example, if you have 5 items and you're threading
 //3 at a time, you need to run twice, once to do the first 3, then once to finish off the last 2
 int timesToLoop = ((queuedItems.Count % threadsToUse) > 0 ? 1 : 0) + queuedItems.Count / threadsToUse;

 //set a current record number which we will use to make sure we don't process the same item
 //more than once
 int currentRecordNumber = 0;

 //loop through the amount of times we need to loop
 for (int i = 0; i < timesToLoop; i++)
 {
 if ((currentRecordNumber + threadsToUse) > queuedItems.Count)
 {
 //this means we're doing the remainder of items
 int lastThreadsToUse = (queuedItems.Count % threadsToUse);
 Console.WriteLine("Processing {0} items", lastThreadsToUse);

 //run in parallel the number of remainder items by calling the process queued item method
 Parallel.For(0, lastThreadsToUse, _ => processQueuedItem(queuedItems[currentRecordNumber + _]));
 }
 else
 {
 //this means we're doing a full set of items
 Console.WriteLine("Processing {0} items", threadsToUse);

 //run in parallel the number of threads we've been passed by calling the process queued item method
 Parallel.For(0, threadsToUse, _ => processQueuedItem(queuedItems[currentRecordNumber + _]));
 }

 //increment the current record number by the number of threads we've processed
 currentRecordNumber += threadsToUse;
 }
 }

I'm using a Console application to test this, hence all the Console.WriteLine calls. The method should be self explanatory, it determines how many times it should run and then runs the relevant number of threads each time it is required until it's done. But just for complete disclosure sake, here's the "Main" method of my console app to show you how I tested this:

 /// <summary>
 /// Main application thread
 /// </summary>
 /// <param name="args"></param>
 static void Main(string[] args)
 {
 //create a dummy list of queue items
 List<Queue> queuedItems = new List<Queue>();

 queuedItems.Add(new Queue { Id = 1, Name = "Apple" });
 queuedItems.Add(new Queue { Id = 2, Name = "Banana" });
 queuedItems.Add(new Queue { Id = 3, Name = "Orange" });
 queuedItems.Add(new Queue { Id = 4, Name = "Pear" });
 queuedItems.Add(new Queue { Id = 5, Name = "Peach" });

 //get the number of threads we want to run in parallel from the setting file we
 //created before
 int threadsToUse = QueueSettings.Default.NumberOfThreads;

 //call the method to do the threading etc.
 processQueuedItems(queuedItems, threadsToUse);
 }

Happy Threading!

A step by step guide to consuming a web service

Admin — Tue, 31 May 2011 00:35:00 -1000

I was recently asked for some help from a web developer on how to consume a service, specifically a web service that returns weather information. I thought this would be the perfect opportunity for a new blog post, seeing as I haven't posted in quite a while.

Using Visual Studio 2010, I create a new "Project", specifically an ASP.Net Web Application. I called it "WeatherServiceWebApplication". Next I want to add a reference to my web service. To do this:

1. Right click on "References" and select "Add Service Reference".
2. When the dialog pop's select, select the "Advanced" button on the bottom left hand side of the dialog.
3. Next select the "Add Web Reference" button on the bottom left hand side of the next dialog.
4. Paste the URL of the web service you wish to connect to in the "URL" textbox of the next dialog, in this case I'm connecting to http://iservice.co.za/WeatherInfo.asmx. Then hit enter.
5. I like to change my "Web Reference Name" which you'll find towards the bottom right of the dialog, I changed this to "iServiceWeather".
6. Then click the "Add Reference" button.

Once you've done that, you'll notice a new folder in your solution called "Web References" with the relevant web service reference within it. To do a simple implementation of this, I'm going to make it load some stuff in the default.aspx page.

To begin with, I can see from visiting http://iservice.co.za/WeatherInfo.asmx that there are two methods available on this web service. I'm going to use the GetSACityWeather call to get the weather for Johannesburg. By clicking on the "GetSACityWeather" method name on the previously mentioned URL, I get to see the method definition etc. I specifically want to know what this method call returns, and on this page (http://iservice.co.za/WeatherInfo.asmx?op=GetSACityWeather) I can see the following:

HTTP/1.1 200 OK
Content-Type: text/xml; charset=utf-8
Content-Length: length

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
 <GetSACityWeatherResponse xmlns="http://iservice.co.za/">
 <GetSACityWeatherResult>
 <City>string</City>
 <ForecastDate>dateTime</ForecastDate>
 <CurrentCondition>
 <Condition>string</Condition>
 <FahrenheitTemparature>double</FahrenheitTemparature>
 <CelciusTemparature>double</CelciusTemparature>
 <Humidity>string</Humidity>
 <WeatherIconUrl>string</WeatherIconUrl>
 <WindCondition>string</WindCondition>
 </CurrentCondition>
 <ForecastConditions>
 <ForecastCondition>
 <DayOfWeek>Sunday or Monday or Tuesday or Wednesday or Thursday or Friday or Saturday</DayOfWeek>
 <FahrenheitLowTemp>double</FahrenheitLowTemp>
 <FahrenheitHighTemp>double</FahrenheitHighTemp>
 <CelciusLowTemp>double</CelciusLowTemp>
 <CelciusHighTemp>double</CelciusHighTemp>
 <Condition>string</Condition>
 <WeatherIconUrl>string</WeatherIconUrl>
 </ForecastCondition>
 <ForecastCondition>
 <DayOfWeek>Sunday or Monday or Tuesday or Wednesday or Thursday or Friday or Saturday</DayOfWeek>
 <FahrenheitLowTemp>double</FahrenheitLowTemp>
 <FahrenheitHighTemp>double</FahrenheitHighTemp>
 <CelciusLowTemp>double</CelciusLowTemp>
 <CelciusHighTemp>double</CelciusHighTemp>
 <Condition>string</Condition>
 <WeatherIconUrl>string</WeatherIconUrl>
 </ForecastCondition>
 </ForecastConditions>
 </GetSACityWeatherResult>
 </GetSACityWeatherResponse>
</soap:Body>
</soap:Envelope>

This tells me the response from the service call returns the object specified above, with all the relevant properties etc. available in the XML. So I want to add a few Literals to my default.aspx that I'll populate using this data. So I added the following:

 
 City:<asp:Literal ID="LiteralCity" runat="server" />
 
 ForecastDate:<asp:Literal ID="LiteralForecastDate" runat="server" />
 
 CelciusTemparature:<asp:Literal ID="LiteralCelciusTemparature" runat="server" />

Then I added the following using to the code behind page of my default.aspx:

//WeatherServiceWebApplication is the name of my application and iServiceWeather is the name I gave the service
using WeatherServiceWebApplication.iServiceWeather;

Next, I added properties in my code behind for the Literals I've created on the form:

 /// <summary>
 /// Gets or sets the display city
 /// </summary>
 private string _displayCity
 {
 get { return LiteralCity.Text; }
 set { LiteralCity.Text = value; }
 }

 /// <summary>
 /// Gets or sets the display forecast date
 /// </summary>
 private string _displayForecastDate
 {
 get { return LiteralForecastDate.Text; }
 set { LiteralForecastDate.Text = value; }
 }

 /// <summary>
 /// Gets or sets the display celcius temparature
 /// </summary>
 private string _displayCelciusTemparature
 {
 get { return LiteralCelciusTemparature.Text; }
 set { LiteralCelciusTemparature.Text = value; }
 }

These I put above my Page_Load method, which I then change to:

 /// <summary>
 /// Handles the page load event
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected void Page_Load(object sender, EventArgs e)
 {
 //the iServicecozaWeatherInfo class is created by Visual Studio when it generates the web service reference
 using (iServicecozaWeatherInfo service = new iServicecozaWeatherInfo())
 {
 Weather weather = service.GetSACityWeather(Region.Gauteng, "Johannesburg");
 _displayCity = weather.City;
 _displayForecastDate = weather.ForecastDate.ToString("dd MMMMM yyyy");
 _displayCelciusTemparature = Convert.ToString(weather.CurrentCondition.CelciusTemparature);
 }
 }

That's it. When I run my little web application it will show the following on my web form:

 City:Johannesburg, GP

 ForecastDate:31 May 2011

 CelciusTemparature:9

Happy Servicing!

Generic implementation of System.Web.Cache to get or read and add or store items in the cache

Admin — Mon, 29 Nov 2010 21:48:00 -1000

I have a bunch of settings stored in the database that I know may never change. In order to read these settings I would prefer not to do a database call everytime I want to get a setting value. So in order to minimize the database calls, I decided to implement a simple manager class to get and add items to the cache.

To start off with, I created my manager class (as static) and called it CacheManager:

 /// <summary>
 /// Cache manager to store and read items in the cache
 /// </summary>
 public static class CacheManager
 {
 }

Next, I added the usings I knew I would need to the class:

using System.Diagnostics;
using System.Reflection;
using System.Text;
using System.Web.Caching;

I'm adding System.Diagnostics and System.Reflection to dynamically create the "keys" I'll be using to cache my items. I created a method that would dynamically generate this key as follows:

 /// <summary>
 /// Gets the cache key for a particular method
 /// </summary>
 /// <param name="parameters"></param>
 /// <returns></returns>
 private static string getCacheKey(params object[] parameters)
 {
 StackTrace stackTrace = new StackTrace();
 MethodBase methodBase = stackTrace.GetFrame(2).GetMethod();
 StringBuilder cacheKey = new StringBuilder();

 //the start of the key will be the full method namespace underscore the method name
 cacheKey.AppendFormat("{0}_{1}", methodBase.ReflectedType.FullName, methodBase.Name);

 //add any parameters as trailing values in the key
 if (parameters != null && parameters.Length > 0)
 foreach (object parameter in parameters)
 cacheKey.AppendFormat("_{0}", parameter);

 //return the key we've generated
 return cacheKey.ToString();
 }

The "key" you use must be unique for each unique "object" you store in the cache. So the above method will determine the name of the calling method and allows you to pass in all the parameters of that method to create a unique key for every method you have. This should become clearer later on.

The next thing I wanted to do was create the relevant methods to get and add items to the cache, so I created the following two. The comments should be self explanatory:

 /// <summary>
 /// Gets an item from the cache
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="parameters"></param>
 /// <returns></returns>
 public static T Get<T>(params object[] parameters)
 {
 //generate the "key" for the cached item
 string key = getCacheKey(parameters);

 //set the return item to it's default
 T returnValue = default(T);

 //make sure the current http context is not null
 if (HttpContext.Current != null)
 if (HttpContext.Current.Cache.Get(key) != null)
 returnValue = (T)HttpContext.Current.Cache.Get(key);

 //return the value
 return returnValue;
 }

 /// <summary>
 /// Adds the relevant item to the cache and returns it as well
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="itemToCache"></param>
 /// <param name="hoursToCache"></param>
 /// <param name="parameters"></param>
 /// <returns></returns>
 public static T Add<T>(T itemToCache, int hoursToCache, params object[] parameters)
 {
 //generate the "key" for the cached item
 string key = getCacheKey(parameters);

 //make sure the current http context is not null
 if (HttpContext.Current != null && itemToCache != null)
 HttpContext.Current.Cache.Add(key, itemToCache, null, DateTime.Now.AddHours(hoursToCache), TimeSpan.Zero, CacheItemPriority.BelowNormal, null);

 //return the cached item
 return itemToCache;
 }

As you can see each method allows you to pass in an array of parameters and that array is then passed to the getCacheKey method and used to generate the unique key. Now to implement my caching, I have a method called "ReadAll" in my SettingsManager class. And this is how I implemented the caching:

 /// <summary>
 /// Reads all the settings and returns a list of them
 /// </summary>
 /// <returns></returns>
 public static List<Setting> ReadAll()
 {
 //try and get the list of items from the cache
 List<Setting> settings = CacheManager.Get<List<Setting>>();

 //if we found something in the cache, return it
 if (settings != null && settings.Count > 0)
 return settings;

 //if we get here, we haven't found anything so connect to the database and populate the list of settings from there, but first initialize the list
 settings = new List<Setting>();

 //now populate from the database
 using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["EngineDatabase"].ConnectionString))
 {
 connection.Open();

 using (SqlCommand command = new SqlCommand("SettingReadAll", connection))
 {
 command.CommandType = System.Data.CommandType.StoredProcedure;

 using (SqlDataReader dataReader = command.ExecuteReader())
 while (dataReader.Read())
 settings.Add(populateSettingFromReader(dataReader));
 }

 connection.Close();
 }

 //now add the list to the cache for 24 hours, and return it
 return CacheManager.Add<List<Setting>>(settings, 24);
 }

The "populateSettingFromReader" is a simple method I created to return a "Setting" object from a data reader as follows:

 /// <summary>
 /// Populates a setting object from the data reader
 /// </summary>
 /// <param name="dataReader"></param>
 /// <returns></returns>
 private static Setting populateSettingFromReader(SqlDataReader dataReader)
 {
 return new Setting
 {
 Id = Convert.ToInt32(dataReader["Id"]),
 Name = Convert.ToString(dataReader["Name"]),
 Value = Convert.ToString(dataReader["Value"])
 };
 }

My "Setting" class is a simple entity class that looks like so:

 /// <summary>
 /// Setting entity
 /// </summary>
 public class Setting
 {
 /// <summary>
 /// Gets or sets the Id
 /// </summary>
 public int Id { get; set; }
 /// <summary>
 /// Gets or sets the Name
 /// </summary>
 public string Name { get; set; }
 /// <summary>
 /// Gets or sets the Value
 /// </summary>
 public string Value { get; set; }
 }

As you can see the "ReadAll" method has no parameters so you don't get to see how the getCacheKey method works with parameters. However the cache key generated for this method would be something like: "[Namespace].SettingsManager_ReadAll".

To illustrate what the getCacheKey would return for a method with parameters, I created a method that would only retrieve one setting at a time using the setting's name as a parameter:

 /// <summary>
 /// Reads the setting for a specified setting name
 /// </summary>
 /// <param name="name"></param>
 /// <returns></returns>
 public static Setting ReadByName(string name)
 {
 //get the value from the cache passing in the name as a parameter to generate the unique key
 Setting setting = CacheManager.Get<Setting>(name);

 if (setting != null)
 return setting;

 //if we get here, we haven't found anything so connect to the database and populate the list of settings from there
 using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["EngineDatabase"].ConnectionString))
 {
 connection.Open();

 using (SqlCommand command = new SqlCommand("SettingReadByName", connection))
 {
 command.CommandType = System.Data.CommandType.StoredProcedure;
 command.Parameters.Add(new SqlParameter("@Name", name));

 using (SqlDataReader dataReader = command.ExecuteReader())
 if (dataReader.Read())
 setting = populateSettingFromReader(dataReader);
 }

 connection.Close();
 }

 //here I call the cache method passing in the "name" variable passed into this method as a parameter
 //which will be used as part of the cache key
 return CacheManager.Add<Setting>(setting, 24, name);
 }

I called this method like so:

 //get the theme setting value
 Setting setting = SettingsManager.ReadByName("Theme");

Now as you can see the value of the parameter I'm passing in is "Theme". So for this method the cache key would be something like: "[Namespace].SettingsManager_ReadByName_Theme". Note the trailing "_Theme".

Happy caching!

ASP.Net: Using a PlaceHolder to dynamically add a user control

Admin — Sun, 21 Nov 2010 20:27:00 -1000

In order to use a PlaceHolder to dynamically load user controls I'm going to start with a simple User Control I created called "HelloWorldUserControl". The HTML portion of the control was simple enough, I just created a literal that I wanted to populate using an Initialize command like so:

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="HelloWorldUserControl.ascx.cs"
 Inherits="PlaceHolderTest.HelloWorldUserControl" %>
<h1>
 <asp:Literal ID="LiteralHelloWorld" runat="server" />
</h1>

In the code behind of the control I just added my Initialize method like so:

 /// <summary>
 /// Initializes the control
 /// </summary>
 /// <param name="message"></param>
 public void Initialize(string message)
 {
 LiteralHelloWorld.Text = message;
 }

Simple enough, anything calling the Initialize method can pass in a string that will populate the Literal on the form with the text. Now I wanted to dynamically add this control to a Web Form. To do this I first created a Place Holder on my web form like so:

 
 <asp:PlaceHolder ID="PlaceHolderHelloWorld" runat="server" />
 

Easy enough so far. Next I wanted to populate this place holder with my user control and call the initialize method on the control. To do this I simply added the following code to my Page_Load event of my web form:

 /// <summary>
 /// Handles the page load event
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected void Page_Load(object sender, EventArgs e)
 {
 //create the control, and call the initialize method
 HelloWorldUserControl helloWorldUserControl = (HelloWorldUserControl)Page.LoadControl("HelloWorldUserControl.ascx");
 helloWorldUserControl.Initialize("hello world!!!");

 //add the control to the place holder, and you're good to go!
 PlaceHolderHelloWorld.Controls.Add(helloWorldUserControl);
 }

As you can see I create an instance of my control in the code behind using the Page.LoadControl method, and then simply cast that returned object to my control type to have a usable object where I can call my Initialize method against. I then simply added my control to the place holder, and that was it!

Happy loading!

The type or namespace 'MyNameSpace' does not exist in the namespace 'MyProject' error and possible fixes

Admin — Wed, 03 Nov 2010 06:51:00 -1000

While working with Visual Studio 2010 (VS2010) I created a solution with multiple projects in it. Each of the projects would build except my Windows Application / Console application and I was getting a very annoying error:

The type or namespace 'MyNameSpace' does not exist in the namespace 'MyProject' (are you missing an assembly reference?)

I could not understand why this was happening because every single one of my projects would build individually except the Windows Application / Console Application. Luckily I noticed there was a warning message stating:

The referenced assembly " [insert assembly path here] " could not be resolved because it has a dependency on "System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" which is not in the currently targeted framework ".NETFramework,Version=v4.0,Profile=Client". Please remove references to assemblies not in the targeted framework or consider retargeting your project.

The root problem of this error is simple, your target framework is ".NETFramework,Version=v4.0,Profile=Client", specifically you're targetting the "Client" profile and one of your other projects references System.Web. The Client profile does not include any ASP.Net features and one of your projects must be referencing System.Web - and that is the cause of the error. To see more about the Client Profile please visit this MSDN page: .NET Framework Client Profile

In order to fix this, you just have to change the target framework of your application to ".NET Framework 4", and not ".NET Framework 4 Client Profile". You can do this by:

Right click the Windows Application / Console Application project in your solution explorer window, and select "Properties"
Select the "Application" tab
You should see a drop down under the heading "Target framework", if it currently says ".NET Framework 4 Client Profile" then you've gotten the error for the same reason I got it, and you simple need to change this to ".NET Framework 4"
Build your project again, and it should work!

Happy building!

Generic success and failure logging using the StackTrace class

Admin — Sun, 31 Oct 2010 19:59:00 -1000

Haven't you ever wished you could log success and failures without having to code separate methods? Well I thought about a simple way of solving this problem, and came up with the following. The method will allow you to log the success or failure of any method without needing to pass different parameters etc. You can use it to implement generic audit logging for your applications.

To start off with, you'll need the following usings on whichever class you add the method:

using System.Diagnostics;
using System.Reflection;

Next, add the method itself:

 /// <summary>
 /// Log an event
 /// </summary>
 /// <param name="ex"></param>
 private static void log(Exception ex = null)
 {
 Console.WriteLine("********************************************************");

 StackTrace stackTrace = new StackTrace();
 MethodBase methodBase = stackTrace.GetFrame(1).GetMethod();

 string serviceName = methodBase.ReflectedType.FullName;
 string method = methodBase.Name;

 //you can off course implement your own email / file logging etc. type methods here
 Console.WriteLine("Full Name: {0}.{1}", serviceName, method);
 Console.WriteLine("Log type: {0}", ex == null ? "Success" : "Exception");

 if (ex != null)
 Console.WriteLine("Exception: {0}", ex.Message);

 Console.WriteLine("********************************************************");
 }

The basics of the method is that it uses the StackTrace to determine the calling method's details, and depending on whether or not an exception is passed in it can be used to log success or failure. Here is an example of a successful method:

 /// <summary>
 /// A method that succeeds
 /// </summary>
 private static void thisMethodSucceeds()
 {
 //do whatever you want

 //now log that it succeeded
 log();
 }

The output of this method will be (Serialization.Program is the name of my application):

********************************************************
Full Name: Serialization.Program.thisMethodSucceeds
Log type: Success
********************************************************

Here is an example of a method that fails. Notice we simply pass the exception into the log method now:

 /// <summary>
 /// A method that fails
 /// </summary>
 private static void thisMethodFails()
 {
 try
 {
 //try and do something, here we're going to throw an exception to simulate something going wrong
 throw new Exception("An exception occured here");
 }
 catch (Exception ex)
 {
 //log the exception
 log(ex);

 //NB: always "throw" an exception like this so as to maintain the stack trace, NEVER EVER "throw ex" as you will loose the precise
 //location the exception occured
 throw;
 }

 //if we get here the method was successful
 log();
 }

The output of this failing method would be:

********************************************************
Full Name: Serialization.Program.thisMethodFails
Log type: Exception
Exception: An exception occured here
********************************************************

Now obviously you would need to change the "log" method above to do whatever logging you actually wanted i.e. log to file, email out, save to a database table. I just wanted to get you onto the right foot in terms of starting a logging mechanism that can be used throughout an application with minimal effort.

The only drawback is that you cannot log the actual parameter values passed into the methods (if there are any). By changing the "log" method and including "methodBase.GetParameters()" you can get the ParameterInfo[] array of parameters. However that only allows you to see the names and types of parameters, but not the actual values, which as far as I know might not be possible at all.

Happy logging!

Simple XML Serialization and Deserialization using generics

Admin — Thu, 28 Oct 2010 21:06:00 -1000

I wanted to create a standard manager class I could use to serialize and deserialize my entity classes regardless of the type of class. I wanted the manager class to be able to write the XML out to a file, or read it from a file and return the populated class object. In order to do this, I started off with the methods to Serialize a class. But first, you need to add the following usings:

using System.IO;
using System.Text;
using System.Xml.Serialization;

Next, add the methods:

/// <summary>
 /// Serialize class into an XML string
 /// </summary>
 /// <typeparam name="T">Type of the class</typeparam>
 /// <param name="classToSerialize">Class to serialize</param>
 /// <returns>The serialised string</returns>
 public static string SerializeToXML<T>(T classToSerialize) where T : class
 {
 XmlSerializer serializer = new XmlSerializer(classToSerialize.GetType());
 StringBuilder stringBuilder = new StringBuilder();

 using (StringWriter writer = new StringWriter(stringBuilder))
 {
 serializer.Serialize(writer, classToSerialize);
 writer.Close();
 }

 return stringBuilder.ToString();
 }

 /// <summary>
 /// Serialize class directly to file
 /// </summary>
 /// <typeparam name="T">Type of the class</typeparam>
 /// <param name="fileName">File name and path</param>
 /// <param name="classToSerialize">Class to serialize</param>
 public static void SerializeXMLToFile<T>(string fileName, T classToSerialize) where T : class
 {
 using (StreamWriter streamWriter = new StreamWriter(fileName, false, Encoding.Unicode))
 {
 streamWriter.Write(SerializeToXML<T>(classToSerialize));
 streamWriter.Flush();
 streamWriter.Close();
 }
 }

The comments should be self explanatory, take special note of the "where T : class" clause, I added that in as a safety clause so this methods could only be run on class objects and not value types. Next I added the deserialize methods:

 /// <summary>
 /// Deserialize class
 /// </summary>
 /// <typeparam name="T">Type of object to return</typeparam>
 /// <param name="serializedObject">Serialized xml string</param>
 /// <returns>Deserialized class</returns>
 public static T DeserializeXML<T>(string serializedObject) where T : class
 {
 XmlSerializer serializer = new XmlSerializer(typeof(T));
 T result = default(T);

 using (MemoryStream input = new MemoryStream(System.Text.Encoding.Unicode.GetBytes(serializedObject)))
 {
 input.Position = 0;
 result = (T)serializer.Deserialize(input);
 input.Close();
 }

 return result;
 }
 /// <summary>
 /// Deserialize class from file
 /// </summary>
 /// <typeparam name="T">Type of object to return</typeparam>
 /// <param name="filePath">File name and path</param>
 /// <returns>Deserialized class</returns>
 public static T DeserializeXMLFile<T>(string filePath) where T : class
 {
 T result = default(T);

 if (File.Exists(filePath))
 {
 string fileContents = System.IO.File.ReadAllText(filePath);

 if (fileContents.Length > 0)
 result = DeserializeXML<T>(fileContents);
 }

 return result;
 }

That was pretty much it. I put the methods in a static class I named XmlManager and I've been using it to serialize and deserialize my entity classes. Simple example of how to use this:

 //create a sample person object to serialize
 Person person = new Person
 {
 Id = 1,
 FirstName = "Heathesh",
 Surname = "Bhandari",
 DateOfBirth = new DateTime(1980, 1, 1)
 };

 //serialize the class to xml
 string serializedXml = XmlManager.SerializeToXML<Person>(person);
 Console.WriteLine(serializedXml);

 //deserialize the xml string to the class object
 Person newPerson = XmlManager.DeserializeXML<Person>(serializedXml);
 Console.WriteLine("{0} {1} {2}", person.Id, person.FirstName, person.Surname);

Happy serializing!