You're a good looking blog, what's your owner's name?

Visual Studio 2005 ASP.NET F5 Debugging performance

2007-10-17T10:27:00.000+01:00

I was experiencing a delay of about a minute between pressing F5 to start debugging my ASP.NET application (VS2005 SP1, Vista) and anything appearing in the browser.

After researching this and installing various hotfixes, nothing improved. Removing the google toolbar however seemed to make debugging return to its normal speed.

ASP/ASPX pages giving 404 errors

2007-09-05T11:12:00.000+01:00

In case I need to do this in future... I have been trying to copy a web site to a new web server (Windows Server 2003) and getting very confused about why .ASP and .ASPX pages were giving 404 errors, but HTML pages were displaying correctly. The reason was "ASP.NET" and "Active Server Pages" in the Web Service Extensions directory were both set to "Prohibited".

The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel.

2007-08-29T13:21:00.000+01:00

I was getting an error message "The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel." when trying to connect to an HTTPS site using an HttpWebRequest.

As the site I was connecting to was a test site from a 3rd party known to me, but not set up correctly at their end, to bypass this check I added the following line before calling GetRequestStream on my HttpWebRequest.


ServicePointManager.ServerCertificateValidationCallback 
+= new 
System.Net.Security.RemoteCertificateValidationCallback
(CustomValidation);

and added the CustomValidation function as follows:


private static bool CustomValidation(object sender, 
X509Certificate cert, X509Chain chain, 
System.Net.Security.SslPolicyErrors error)
{
    return true;
}

A set of principles for taking a new assignment

2007-08-06T08:40:00.000+01:00

Gerald M. Weinberg offers a set of principles for taking on a new assignment.

InternalsVisibleToAttribute, Unit Testing and Strong Names

2007-06-12T17:05:00.000+01:00

I previously posted about using the InternalsVisibleTo attibute for testing with NUnit.

I've had some problems building this with a stronly named assembly. I found the following post on Kent Boogaart's blog that describes how you should change the code in your assemblyinfo.cs file as follows:

[assembly: InternalsVisibleTo("Company")]

to

[assembly: InternalsVisibleTo("Company, PublicKey=xxxxxxxxxxxxxxxx")]

Adding a strong name to a third party dll

2007-06-12T16:35:00.000+01:00

I've been trying to build an assembly with a strong name and had some problems as it referenced a 3rd party assembly which had been built without a strong name.

To add a strong name I disassembled and reassembled the 3rd party assmbly as follows:

ildasm /out:thirdparty.dll.il thirdparty.dll

ilasm /dll /resource=thirdparty.dll.res thirdparty.dll.il /out=thirdparty.dll /key=mykey.snk

World Environment Day

2007-06-05T14:07:00.001+01:00

To celebrate World Environment Day, we have all been given a flowerpot, some peat and some forget-me-not seeds. You can follow whether the seeds grow into a beautiful plant or not here.

Refreshing Progress Bars

2007-06-05T14:01:00.000+01:00

I've been having some problems getting a progress bar to refresh, trying various calls to Refresh() and Invalidate() without much success. The solution to this is to create the dialog containing the progress bar in another thread, as described here.

Although the dialog is modeless, it should be displayed using ShowDialog(), not Show().

Standard for improving Standards

2007-05-16T10:29:00.000+01:00

Simon Baker suggests that standardisation does not have to supress innovation.

It's important to communicate the best ways of doing things, but standards are often enforced in a way that people are expected to accept without question. However, there are often many ways of doing something, and the best way will change over time with changes in technology and changes in people.

Perhaps standards should be seen as something that should be followed, but when its thought they cause a problem, judgement should be used as to the correct procedure should be followed. However, if people use judgement to deviate from the standard, any differences should be noted and their effect should be considered afterwards.

The differences can then be assessed to see if deviating from the standard was the right thing with hindsight and if so, the standard should be improved. if it was the wrong thing to do, we might need to explain the rationale behind the standard better.

Visual Studio 2005 - Disappearing controls on Windows Form

2007-04-16T11:21:00.000+01:00

My computer crashed the other day and when I returned to edit my application, to my horror I noticed that the controls on a very complicated windows form that I was working on had vanished. When I tried to edit it, all I got was an empty dialog box, but all the source code for my form was still there.

I found several references to disappearing controls in VS2003, but they all said the problem had been fixed in VS2005.

The cause of this turned out to be that some lines had removed themselves from the designer.cs file :-

///
/// formMyForm
///
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink;
this.ClientSize = new System.Drawing.Size(869, 717);
this.Controls.Add(this.splitContainer1);
this.Controls.Add(this.buttonOK);
this.Controls.Add(this.buttonCancel);
this.Controls.Add(this.buttonAccept);
this.Name = "formMyForm";
this.Text = "My form title";

Copying these lines from the version in source control seemed to restore all the controls in the dialog.

Complete years between 2 dates

2007-03-01T16:23:00.000Z

A problem we have had calculating ages was due to it using the SQL Server "DateDiff" function. This counts the number of times a day crosses a boundary, e.g.

DateDiff(year,'12/31/2006','1/1/2007') is 1, as it crosses the 2006-2007 boundary.
DateDiff(year,'1/1/2006','12/31/2006') is 0 as it doesn't cross a year boundary.

I have written a function "yeardiff", which calculates the number of complete years between 2 dates, so

YearDiff('12/31/2006','1/1/2007') is 0
YearDiff('1/1/2006','12/31/2006') is 0
YearDiff('12/31/2006','1/1/2008') is 1

This function works by calculating the number of days the start date is into the year, subtracting this from both start and end dates (so the start date is 1 January), and calling DateDiff on the resulting date.

Here's the source code for this function:

CREATE FUNCTION yeardiff
(@start as datetime, @end as datetime)
returns int
AS
BEGIN
declare @years as int

declare @daysintoyear as int
declare @firstdayofyear as datetime
declare @newstart as datetime
declare @newend as datetime

set @firstdayofyear = convert(datetime,
'1/1/'+convert(varchar,year(@start)))
set @daysintoyear =datediff(day, @start, @firstdayofyear)

set @newstart = dateadd(dd, @daysintoyear,@start)
set @newend = dateadd(dd, @daysintoyear,@end)

return datediff(year,@newstart,@newend)

END

Nant and licensed 3rd party controls

2007-02-06T17:04:00.000Z

I've been having some problems building a project containing licensed grid and graph components from ComponentOne using NAnt. The project built correctly in Visual Studio, but when built with NAnt I got a box saying the component was not licensed.

I've found some others have had similar problems, but no solutions have been posted. I go it working after a lot of trial and error as follows:

1) Use an <exec> task to run the license compiler (lc.exe).
2) Ensure the /target: command does not contain a path.
3) Ensure your <csc> task does not contain a path in its output section.
4) Ensure the licenses file is included in the resources section. This did not work when it was included as an argument with an <arg value="/resource" element.
5) Copy the file to the correct destination directory at the end.

Here's the relevant part of my build file.

<target name="project" description="build project"
depends="..." >

<exec program="C:\Program Files\Microsoft
Visual Studio 8\SDK\v2.0\bin\LC.exe"
commandline="/target:project.exe
/complist:c:/nantcheckout/project/Properties\
licenses.licx
/outdir:c:/nantbuild /i:c:\nantbuild\C1.Data.2.dll
/i:c:\nantbuild\C1.Win.C1Chart.2.dll
/i:c:\nantbuild\C1.Win.C1Chart3D.2.dll
/i:c:\nantbuild\CAInterfaces.dll
/i:c:\nantbuild\CDERules.dll
/i:c:\nantbuild\clTreeViewHashT.dll
/i:C:\WINDOWS\Microsoft.NET\Framework\
v2.0.50727\System.configuration.dll
/i:C:\WINDOWS\Microsoft.NET\Framework\
v2.0.50727\System.Data.dll
/i:C:\WINDOWS\Microsoft.NET\Framework\
v2.0.50727\System.Deployment.dll

...

/>

<csc target="winexe"
output="PCOBrowserGE.exe" debug="false"
define="TRACE" >
<sources>
<include name="c:/nantcheckout/
project/*.cs" />
<include name="c:/nantcheckout/
project/Properties/*.cs" />
</sources>
<resources>
<include name="c:/nantcheckout/
project/Properties/*.resx" />
<include name="c:/nantcheckout/
project/*.resx" />
<include name="c:/nantbuild/
project.exe.licenses" />
</resources>
<arg value="/reference:C:\nantbuild\
c1.win.c1chart.2.dll" />
<arg value="/reference:C:\nantbuild\
c1.win.c1chart3d.2.dll" />
<arg value="/reference:C:\nantbuild\
c1.data.2.dll" />
</csc>

<copy file="pcobrowserge.exe" tofile="
c:/nantbuild/project.exe" />
</target>

10 Characteristics of a great programmer

2007-02-06T10:11:00.000Z

Steve Riley has complied a great list of the 10 characteristics of a great programmer.

I'd agree with everything on the list - the one thing that is missing is that great programmers know why they are doing what they are doing - there's no point producing an excellent solution to the wrong problem.

Cakes

2007-01-25T10:14:00.000Z

Cote writes about requirements gathering and cakes.

If your powerful boss asks you for a cake, you can't easily find out the details of what he wants. You have to find out via secondary sources (e.g. the boss's calendar, asking the baker what sort of cakes the boss has ordered before). The calendar may not be up to date, and the baker may not remember accurately.

This takes longer and is more likely to go wrong. If there are more steps than necessary in finding out requirements, the solution is to understand what the difficulty is with asking him directly and work on reducing these difficulties.

Personal Search Filter

2007-01-24T15:44:00.000Z

If you want to find out information about something, you will typically enter terms into a search engine.

The search engine will determine which results are most relevant (by using a complex algorithm based on how important it thinks the pages are). Everybody using this search engine will see the same results.

The things you want to see might not be the same as the things others want to see. However, you are more likely to want to see things that people "compatible with you" liked. If A likes B and B likes C, and B also likes D, then chances are that A will like D.

You could filter the results of your search (from the search engine) through a personal search filter. This would reorder your searches depending on

1) Things you have liked before
2) Things that people compatible with you have liked before.

When you visit a web page, you record whether you found it valuable. This updates your personal search filter and how compatible you are with other people. If you liked page A and B didn't like page A, you will not value the opinion that B liked page C. However if B liked A, you would be compatible with B and their opinion would affect your search filter.

This can be seen below:

Anti-tests

2007-01-12T10:21:00.000Z

Charles Miller describes the concept of an "Anti-Test", which is a test that verifies a bug exists.

This can be written when the problem is discovered, even if it's not going to be fixed immediately.

It means that if the problem is inadvertently fixed as a result of something else, we know this has happened, have a look at why this is the case and update our records accordingly. The test can then be changed to a normal test to make sure it doesn't go wrong again.

When you're ready to fix an anti-test, you can change it to a normal test - it should now fail (and this change should be easy to make), fix the bug and make sure the test passes.

NAnt version

2007-01-12T10:09:00.000Z

I've been trying to add version numbers to a NAnt build script using the <version> task, and come across a problem with the script in Marc Holmes' "Expert .NET delivery" book.

The task increments a property called "buildnumber.version", not "sys.version". Adding the following line to the script (as described here) seems to fix it.

<property name="sys.version" value="${buildnumber.version}" />

Using attributes to specify the contents of a menu

2006-12-03T16:22:00.000Z

Most people think it is a good idea to separate business and presentation logic in your application, so you can update one without changing the other. When you create an application with a menu bar, the menu items will often call functions in your business logic, and if you add a new business logic function you will need to add a handler in your presentation layer and the business logic function in your business logic layer.

This article describes how you can add attributes in your business logic layer and have these dynamically bound to a menu when your application runs. The attributes will look like the following:

   public class MenuHandler
    {
        [MenuOption ("Menu Option 1")]
        public void MenuHandler(object sender, 
EventArgs e)
        {
            //Business Logic
        }
    }

Creating your Attribute

The first thing you need to do is to set up your attribute. Create a class derived from System.Attribute as follows.

    [AttributeUsage(AttributeTargets.Method)]
    public class MenuOptionAttribute : 
System.Attribute
    {
        private string MenuText;

        public MenuOptionAttribute(String 
menutext)
        {
            MenuText = menutext;
        }

        public string GetMenuText
        {
            get
            {
                return MenuText;
            }
        }
    }

The first line of this specifies your attribute can be applied to methods (and not to classes). The constructor takes one argument, which is a string representing the menu text.

Applying your attribute to your business logic

Next, you write your business logic layer to use the MenuOption attribute. All you need to do is to put this before any functions you want on your menu, with the text to go on your menu:

    public class BusinessLogic
    {
        [MenuOption ("Menu Option 1")]
        public void Option1(object sender, 
EventArgs e)
        {
            // Option 1 code
        }

        [MenuOption("Option 2")]
        public void Option2(object sender, 
EventArgs e)
        {
             // Option 2 code
        }

You can add as many of these functions as you like.

Setting up your menu

Finally, you need to create your presentation layer. You can drag a MenuStrip to a form and add a title for your drop down menu. If you call the title "Main", when you add the title, it will create a ToolStripMenuItem, called "mainToolStripMenuItem" by default.

You need to use reflection to iterate over all the methods in the MenuHandler class, and see which of those methods have the MenuOptionAttribute attribute set.

If it is set, you need to call the GetMenuText() function on the attribute to find out the text to display on the menu bar and add the menu item.

Next, you need to create a delegate to your method.

Finally, you add the event handler to your newly created menu item. It's easier to understand this if you read the code example.

  public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            BusinessLogic bl = new BusinessLogic();

            mainToolStripMenuItem.DropDownItems.
Clear();
            foreach (MethodInfo method in 
(typeof (BusinessLogic)).GetMethods())
            {
                foreach (object attribute in 
method.GetCustomAttributes(true))
                {
                    if (attribute is 
MenuOptionAttribute)
                    {
                        ToolStripItem newitem = 
mainToolStripMenuItem.DropDownItems.Add((
attribute as MenuOptionAttribute).GetMenuText);
                        EventInfo ci = typeof
(ToolStripItem).GetEvent("Click");
                        Type tdelegate = ci.
EventHandlerType;
                        Delegate del = Delegate.
CreateDelegate(tdelegate,bl,method);
                        ci.AddEventHandler(
newitem, del);
                    }
                }
            }
        }
    }

You could add some code to your attribute to specify its position, and use this to order your menu items. You might want to specify more than one string, one for the heading and one for the item itself, so you can put menu items in under different headings.

InternalsVisibleToAttribute and Unit Testing

2006-10-21T13:10:00.000+01:00

When creating unit tests to be run with NUnit, I like to keep my tests in a separate assembly, which is not delivered when my project is deployed.

This can make it difficult to create unit tests for classes that should not be visible outside of that assembly. One of my classes uses one of 3 strategy classes that encapsulate a feature of the business logic. I would normally declare these with the intern access modifier, but to test each strategy works I've needed to make them publically available.

If, however, I add the [assembly: InternalsVisibleTo("UnitTests")] line to my AssemblyInfo.cs file, any objects declared with the intern access modifier can be seen by the UnitTests assembly.

Processes and Practices

2006-10-10T22:33:00.000+01:00

Jared Richardson describes a process he wants his team to follow. Many others have attempted the same and have reached similar conclusions, and I can't disagree with any of Jared's thoughts.

However, I think he misses out the most important part of the process which should be to regularly think about your process and what you have done and how you could have done it better. All processes and practices should be adaptable. Different people have different strengths and new technologies mean we have to develop things in different ways.

A lot has been written about technical debt, where if not enough time is invested in developing high quality software, it becomes harder to maintain and costs of new developments increase over time. We should also think about process debt, where if not enough time is spent improving and adapting our processes, they become less efficient and costs of new developments also increase.

C# collection classes performance

2006-10-10T21:42:00.000+01:00

I was looking for a table summarizing how different C# generic and non-generic collection classes performed, relative to one another, thought there would be hundreds available, but could not find one. So here one is for my future reference, and for anyone else who reads this.

O(1) = constant time
O(log n) = time proportional to the log of the number of elements in the collection
O(n) = time proportional to the number of elements in the collection

Some collections are better for smaller collections, but don't scale to larger ones. The List, LinkedList, SortedList, Queue and Stack classes are better for smaller collections than the Dictionary, Hashtable and SortedDictionary classes.

The type or namespace name 'Properties' could not be found

2006-10-04T10:25:00.000+01:00

I was getting an error message when building my project that said "The type or namespace name 'Properties' could not be found".

This was because I had changed the default namespace in the properties for my project to make it "project.name" instead of "name". The class that did not build was already in the namespace "project.name".

The error message was on a line that said

"global::name.Properties.Resources...."

Changing this to

"global::project.name.Properties.Resources...."

seemed to fix the problem.

Export to excel from SQL Server Express

2006-09-14T10:23:00.000+01:00

Once upon a time, a big bad grizzly bear wanted to write a program to export a view from an SQL Server Express database (containing the names and addresses of sweet fluffy things he wanted to eat) to an Excel file. As this was SQL server express, he tried to use DTEXEC and integration services, but growled ferociously when he realised that integration services was not supplied with excel, promising to sharpen his claws and tear apart Bill Gates.

However, a passing raccoon came to his rescue, and told him about the following trade secret way to do this (subject to removing the raccoons name and address from his database):

1) Go to the Surface Area configuration tool, select "Surface Area configuration for features". Select "Ad Hoc Remote Queries", and turn on "Enable OPENROWSET and OPENDATASOURCE support".

2) Create a template excel file, with the first row containing the column names in your view. You can use integration services to export a file to Excel, and then delete the data from it, leaving the first row.

3) From your program, use the File.Copy command to copy the template file to your destination file.

4) Run the following SQL query to populate the Excel file

insert into OPENROWSET('Microsoft.Jet.OLEDB.4.0', 'Excel 8.0;Database=c:\\aaa.xls;', 'SELECT * FROM [Query]') select * from ExportView

where c:\\aaa.xls is your file name, "Query" is the name of your worksheet and "ExportView" is the name of your table or view you want to export.

Shrinking an SQL Server 2000 Transaction Log

2006-08-11T12:54:00.000+01:00

I have a database in which the transaction log grew to 19GB, taking up the entire disk space on the server it was on, and which could not be shrunk. Most of the things I found on the net didn't shrink this very much.

However, I found the following script here which worked well, reducing it from 19GB to 52 MB.

http://www.thescripts.com/forum/thread79839.html


use database_name
go
create table shrinkfile(
col1 int,
col2 char(2048)
)

dump tran database_name with no_log
dbcc shrinkfile(logical_name_of_log, 50, TRUNCATEONLY)
go


set nocount on
declare @i int
declare @limit int

select @i = 0
select @limit = 10000

while @i < @limit
begin
insert into shrinkfile values(@i, 'Shrink the log...')
select @i = @i + 1
end

drop table shrinkfile

Updating .NET user controls on the screen

2006-08-10T07:57:00.000+01:00

I have some user controls that I need to add a lot of data to. This can be slow as the screen display is updated when each item of data is added. It also makes the dislpay flicker.

I couldn't find an equivalent of the BeginUpdate and EndUpdate functions in .NET 2.0, but it is possible to call the Windows API functions as follows.


private const int WM_SETREDRAW = 11;

[System.Runtime.InteropServices.
DllImport("user32.dll")]
static extern bool SendMessage(IntPtr 
hWnd, Int32 msd, Int32 wParam, Int32 
lParam);

/// 
/// Stop updates while we are 
/// filling a control with data
/// 

protected void BeginUpdate()
{
  SendMessage(this.Handle, WM_SETREDRAW, 0, 0);
  Cursor.Current = Cursors.WaitCursor;
}

/// 
/// Restart updates
/// 

protected void EndUpdate()
{
  SendMessage(this.Handle, WM_SETREDRAW, 1, 0);
  if (Parent != null)
  {
    Parent.Invalidate(true);
  }
  Cursor.Current = Cursors.Default;
}

I included these in a base class used by all my user controls, and added code to change the cursor to a wait cursor whilst the control was updating.