.Net

Ease your SSMS experience: SSMS Tools PACK 1.0 is out!

Mladen Prajdić — Thu, 08 May 2008 08:35:14 GMT

After a long while I've finally managed to create a release version. I've also added some cool new features.

It is completely free and has no expiration date like the prior beta versions.

I've also changed the RSS feed to Feedburner to which you can subscribe to at: http://feeds.feedburner.com/SsmsToolsPack

If you're subscribed to the old feed please change it.

In SSMS Tools Pack 1.0 you can find these features:

- Uppercase/Lowercase keywords:

Set all keywords to uppercase or lowercase letters. Custom keywords can be added.

- Run one script on multiple databases:

Run selected or full window text on selected databases on the currently connected server.

- Copy execution plan bitmaps to clipboard:

Copy selected or all execution plans to a bitmap that is saved on the clipboard.

- Search Results in Grid Mode and Execution Plans:

Find all occurrences of your search string in the execution plans or in the results in datagrid mode.

- Generate Insert statements for a single table, the whole database or current resultsets in grids:

Generate insert statement from your data.

- Query Execution History (Soft Source Control):

Save all executed queries to file or database and easily find them.

- Text document Regions and Debug sections:

Add Regions and Debug section in your scripts to ease development experience.

- Running custom scripts from Object explorer's Context menu:

Speedy execution of custom scripts from Object Explorer's context menus.

- CRUD (Create, Read, Update, Delete) stored procedure generation:

Generate Customizable CRUD stored procedures for all tables in your database.

- New query template:

Create a template that is shown when creating a new query window.

Currently supported SQL Server Management Studio versions are:

SQL Server Management Studio 2008 CTP

SQL Server Management Studio 2005

SQL Server Management Studio 2005 Express

Hope you enjoy it!

And if you're feeling extra generous there's always PayPal. :)

Watershed Image Segmentation in C#

Mladen Prajdić — Mon, 11 Feb 2008 17:46:53 GMT

This is an implementation of the Grayscale Immersion Watershed Segmentation in C# based on the

Vincent-Soille immersion watershed algorithm

Read Full Post.

Automated GUI testing - Is it worth it?

Mladen Prajdić — Thu, 03 Jan 2008 20:21:08 GMT

In 2007 I've worked a lot with NUnitForms. It contains all major controls testers and you can easily create

your own ones for e.g. a Data Grid or a 3rd party control. I had to create one for Janus GridEx and it wasn't really

that hard. A little reflection went a long way :) Lately, the whole project was at a standstill for some time but now it seems

it's revitalizing nicely with new people on board. So if you haven't yet go take look. This is just one open source GUI testing platform

and I'm sure there are others... I haven't checked them out though.

Now to the big question: Is it worth it? It depends...

I'm not a hardcore TDD practitioner but I like having repeatable unit tests. But having automated GUI unit tests is in my opinion a waste of time.

Why? It simply isn't worth spending time writing them. You should have enough code coverage with non GUI tests to find any bugs long before

hitting the GUI. You might want to be tempted to unit test control positions or visibility or some other property... don't bother.

You'll spend your time better if you write more non GUI unit tests and check your GUI by hand (eye).

So what are they useful for? Well... I've used them for acceptance and integration testing with great success.

Integration Tests...

... test how different parts of your application work together. These kinds of GUI tests proved to be VERY useful and they are worth investing time in.

They have a great ROI (return on investment) once they're written.

For example we had a large workflow based application that was completely async in nature. It had a windows forms client that could be deployed on

multiple computers, all those clients connected to a single server that hosted a few webservices for data modifications, retrieval and some other stuff.

The whole app was also connected to Sharepoint server, Exchange Server, SQL Server, used InfoPath and a 3rd party software to export data from

and into it. With one single GUI integration test we could easily see if everything worked together as it should. We mocked the InfoPath and

3rd party software but everything else ran great.

The point of using GUI tests here is to see how and if your whole application works with all parts integrated together from GUI interaction

to Exchange connectivity. Even the best non GUI integration tests simply don't do that.

Acceptance Tests...

... test if your software is up to some specs usually defined by the business process. They're in essence a black box test.

You don't care what goes on inside the software you just want to see if the output is correct for a certain input.

In workflow based processes this can be very useful since you know what the input and output parameters are for your workflow.

For example you start the workflow in your app via NUnitForms, pressing "move in workflow" buttons until the workflow end and then check if

the output parameters have the correct values. You can check for various different GUI parameters in this test along the way but as I said above

don't go overboard. I usually just check for visibility of certain panels or grids... simple things like that.

When I first started with GUI testing I thought it was a really big waste of time. And to tell you the truth if you don't draw the line somewhere it is.

I even had a moment when I thought it was a good idea to test everything only with GUI tests. That was so far over line I couldn't even see it anymore.

Luckily that moment passed pretty fast. Don't make the same mistake. If used wisely automated GUI tests are a big benefit.

SQL Server 2005 evil DBA prank

Mladen Prajdić — Thu, 15 Nov 2007 21:05:37 GMT

Today I feel a bit evil minded so I thought I'd share this little prank-friendly function.

If you put this into a .Net Assembly you import to SQL Server as a function or a stored procedure

you can wreck some real havoc :)

private static void SQLPrank()
{
    Random r1 = new Random(DateTime.Now.Millisecond);
    int lowerBound = r1.Next(1000, 2000);
    int upperBound = r1.Next(3000, 4000);
    int randomNumber = r1.Next(1000, 4000);
    /*
    1000             2000             3000             4000
      |----------------|----------------|----------------|
      .....|...................................|..........
    random lower bound                  random upper bound
      ..........................|.........................
                        random number 
      |----|-----------------------------------|---------| 
       Exit          Normal operation             Wait
    */
    if (randomNumber >= 1000 && randomNumber < lowerBound)
        Environment.Exit(0);            
    else if (randomNumber >= upperBound && randomNumber < 4000)
        Thread.Sleep(5000);
}

The gem here is the Environment.Exit(0) which shuts down SQL Server without anyone having a clue why.

This is perfect for a prank on your least favorite DBA or developer. :)

C#: Care about Event Memory Leaks with Delegate.GetInvocationList()

Mladen Prajdić — Wed, 24 Oct 2007 18:30:02 GMT

UPDATE:
After i've been proven wrong in the comments below I have to say this:

Go take a read of this article to see how circular references are really handled.

While Delegate.GetInvocationList() really is a great and usefull thing and it could be used in clearing up events,

there's no need for it since you can do that as easily by simply unsubscribin from the event when

you want to dispose your class.

You can read this post on, but know that this example is WRONG, except for the last part about

Observer pattern and WeakEvent pattern.

Maybe you should read this post since sometimes you can learn how stuff works by reading how it doesn't work :))

---------------------------------------------------------------------------------------------------------------------------------------

Subscribed events are one of the most common reasons of memory leaks in .Net. This means that if you have an object that has an event

and there are other object that are subscribed to that event, the original object won't be properly disposed until all events are unsubscribed since

an event is a strong reference.

A simple example of this is a form called MyForm that has a public event called OnDoMyFormThing and 5 classes are subscribed to this event.

When the OnDoMyFormThing is executed on the form it will notify all 5 classes. You might call this event a few more times depending on what your form does.

After this the form is closed. However the form isn't disposed until all 5 classes that are subscribed to the event get disposed. A hard way of doing this

would be to somehow implement the event removal on all 5 classes.

An easy way would be to do this in the Dispose method of the form itself. But how, if you don't know the name of every event handler.

But remeber that an event is just a delegate. And delegates have a GetInvocationList() method.

GetInvocationList() gets an array of delegates. Each delegate represents a method subscribed to an event. The order of the delgates is the same as the

invocation order of the subscribed methods on the event.

So your code in MyForm would be:

 public partial class MyForm : Form
 {    
    public event EventHandler OnDoMyFormThing;
    
    public MyForm()
    {
        InitializeComponent();        
    }
    
    private void button1_OnClick
    {
        MessageBox.Show("Test of OnDoMyFormThing event");
        OnDoMyFormThing(this, new EventArgs());
    }
    
    protected override void Dispose(bool disposing)
    {
        if (disposing && (components != null))
        {
            foreach (EventHandler eventDelegate in OnDoMyFormThing.GetInvocationList())
                OnDoMyFormThing -= eventDelegate;
            components.Dispose();
        }
        base.Dispose(disposing);
    }
}

And with this your form can be disposed normally.

Event subscriptions in 5 classes look like this:

class1.MyForm.OnDoMyFormThing += Class1EventHandler
class2.MyForm.OnDoMyFormThing += Class2EventHandler
class3.MyForm.OnDoMyFormThing += Class3EventHandler
class4.MyForm.OnDoMyFormThing += Class4EventHandler
class5.MyForm.OnDoMyFormThing += Class5EventHandler

The strong bidirectional reference between an event and its subscriptions is a common problem in all Observer pattern scenarions, so you must

know about it and care about it. If not, you're sure to get memory leaks.

In .Net ramework 3.0 there is a pattern called WeakEvent that you can use to create a weak reference to events and not really care about disposal.

C# : Get current Caret Line and Column in a multiline Windows Forms TextBox

Mladen Prajdić — Fri, 19 Oct 2007 13:40:41 GMT

I can't believe these properties aren't already natively implemented. Come on Microsoft... we do live in the year 2007 you know!!

I know that you can do this using P/Invoke and SendMessage but i wanted a nice managed way of finding

the current line and column of the Caret position in a multiline TextBox.

After a bit of experimenting i've come up with this extended class:

public class TextBoxEx : TextBox
{
    public TextBoxEx()
    { }

    public void GoTo(int line, int column)
    {
        if (line < 1 || column < 1 || this.Lines.Length < line)
            return;
        
        this.SelectionStart = this.GetFirstCharIndexFromLine(line - 1) + column - 1;
        this.SelectionLength = 0;
    }

    public int CurrentColumn
    {
        get { return this.SelectionStart - this.GetFirstCharIndexOfCurrentLine() + 1; }
    }
 
    public int CurrentLine
    {
        get { return this.GetLineFromCharIndex(this.SelectionStart) + 1; }
    }
}

Hope you find it usefull. If anyone knows a better way do let me know.

UPDATE: With a bit of help from Andrej this is a better and shorter version with set method too.

.Net: Passing user data with Exception back to the caller method

Mladen Prajdić — Mon, 24 Sep 2007 15:36:37 GMT

We're all familiar (i hope :)) with this construct:

try
{
    // ... some code here ...
}
catch (Exception ex)
{
    // one of these 2 lines are usually seen
    throw; // presereves the full call stack
    //throw ex; // changes the origin of exception to this method
}
finally
{ 
    // more stuff here
}

It's a standard error catching routine in .Net.

But what if you want to pass some user info back to the caller method with the Exception being thrown?

Reader... meet Exception.Data. Exception.Data... meet reader.

Now that you're both properly aquainted let see what it does.

Exception.Data is a dictionatry that holds object for key and value. This means that you can put anything into it.

Here's how my standard catch code part looks like:

catch (Exception ex)
{
    // pass the ex to preserve full stac trace
    Exception exNew = new Exception("New exception message", ex);
    exNew.Data.Add("string Data", "data");
    exNew.Data.Add("int data", 1);
    exNew.Data.Add("bool data", true);
    exNew.Data.Add("DateTime data", DateTime.Now);
    // full ex info with user data
    throw exNew;
}

I've seen a lot of code and i've never seen this being used. I have seen other way overcomplicated methods being used for the same functionality though. :)

Even though .Data is the first property in the Exception intellisense list it gets overlooked. How? I have no idea.

Little .Net tip: Start using List<T>.ForEach()

Mladen Prajdić — Sat, 01 Sep 2007 19:37:13 GMT

I haven't been using this function at all. Who knows why... maybe because i didn't know about it :)

But in my latest pet project i had to do something really quickly on a lot of items in a list.

After a bit of research into foreach and for loops, i saw the List<T>.ForEach method.

Did some testing and sure thing List<T>.ForEach proved to be faster than others.

I thought about posting the whole setup and how i've tested it, but then i saw that Dustin Russell Campbell

did exactly the same thing a bit more thoroughly, so why double it up, right?

Read it, like it, USE it!

Performance of foreach vs. List.ForEach

Simply rocks!

.Net Windows Forms ListView ColumnHeader width tip. Set it to -1 or -2.

Mladen Prajdić — Wed, 29 Aug 2007 17:25:00 GMT

A negative Width value??

I can hear it now:

Are you insane Mladen?? Do you want our apps going around looking ugly??

Well... of course I do! It means i can go around fixing them for big bucks :))

But joking aside, -1 and -2 width values are very usefull.

Setting the width to be -1 means that the column will have the width of the longest item in it.

Setting the width to be -2 means that the column will have the width of the column heading.

Pretty cool, no?

Ways to revert a database to pre-Test state after Unit testing

Mladen Prajdic — Fri, 06 Jul 2007 17:00:18 GMT

Tests are a pretty much a must in today's world of programming. There's even a whole Test Driven Development methodology that deals with this.

There comes a time when we have to test how our app interacts with the database.

More here