There are many ways of managing a Scrum Sprint, but I always look for the easy ways, I came across Deborah Hartmann, spreadsheet which I have found very useful and easy to get along with. Once you understand the processes of Scrum and what is required the spreadsheet speak a thousand words.
Tools for Linq to SQL and ADO.NET Entity Framework
I have found LINQ to SQL and the Entity Framework has a few missing features, one of these is the ability to update the designer diagrams, and this is where Huagati DBML come to play.
Huagati DBML/EDMX Tools is an add-in for Visual Studio that adds functionality to the Linq2SQL/DBML diagram designer in Visual Studio 2008, and to the ADO.NET Entity Framework designer in Visual Studio 2008 SP1.
TwitterPing
Updated my extensions on my blog this morning and included a Twitter updater by Miguel Jimenez, TwitterPing.
Had a few issues with the Extension, but with a few tweeks, and removing the dll by placing the code behind, it means it only needs the .cs file,
🙂
DDD South West Presentations for Room 3
Here is a list of Slides and Source code for DDD South West 2009 room 3
For full details on each of the talk check out the Agenda
These files are now on the DDD South West web site
Here are some photos too
http://picasaweb.google.co.uk/bryanavery102/DDDWouthWest#
Mocking
In object-oriented programming, mock objectsare simulated objects that mimic the behavior of real objects in controlled ways. A computer programmer typically creates a mock object to test the behavior of some other object, in much the same way that a car designer uses a crash test dummy to simulate the dynamic behavior of a human in vehicle impacts.
It is possible to perform integration testing on the Membership Provider, take a look at this blog entry to find out more Integration testing the MembershipProvider
Within the Project we are using Rhino Mocks, Oren Eini is doing a great job with this framework, and I think it’s the only one that seems to be keeping up with the latest features in .NET, other than TypeMock. Plus, it’s totally free to use. It’s also the only one other than TypeMock which does not require you to input strings for method names you’d like to mock, which is cool. It’s compelling to use it but the project is currently maintained by just one person. If Oren decides to drop it, or for any reason stop working on it, the book might turn out outdated quite quickly. Plus, it’s not very widely used, though it seems to be gaining in popularity.
References
Introduction to Mocking with Rhino Mocks
RPS – Calculation Model
Calculation Model
There are a number of calculations and data transformations that need to take place in order to produce the correct Leakage Calculation.
In order to complete the Leakage Calculation as fast as possible we are going to separate the calculations and data transformations in to different processes and control these processes using a Windows Service.
In order for a Windows Service to handle separate processes we will be using the Multi Threading abilities of the .NET Framework.
[edit]Windows Service Installation
To install a Windows Service, you could create an installation program that encapsulates the executable for deployment, which I find time consuming and inefficient when testing an application. Or, you could install the service though the InstallUtil.exe process that comes with the .NET Framework.
I created a simple batch file, install.bat, to simplify installation (and therefore testing) of the service. The batch script is shown below; uninstallation is as simple as creating another batch file, uninstall.bat, with exactly the same script, only substituting the /i (for install) with /u (for uninstall).
[edit]WCF (Windows Communication Foundation
[edit]Introduction
We needed to be able to communicate with the Window Service running on the server, from anywhere on the network and the Internet if needed. So the best possible solution was to use [Microsofts WCF], as it is very flexible and configurable.
[edit]Service Contract
We need to implement a service contract, this provides an interface that we can use to be able to communication with the service.
[edit]Command
Provides a method to invoke a command to the service, mainly used for testing and debugging
[edit]List
Get a list of Calculation that are available to be processed
[edit]Start
Start all the calculations
[edit]StartByName
Start a single calculation process by its name
[edit]Abort
Stop all calculations and abort their threads
[edit]Abort
Stop all calculations and abort their threads
[edit]Status
Return if any calculations are still running
[edit]Activity
Display the activity of all the processes that have ever happened since the service started
This returns back a String Array, and in each string a comma delimited structure.
Name, Id, Date/Time, Status
[edit]ActivityById
Returns the activity for a given Id
This returns back a String Array, and in each string a comma delimited structure.
Name, Id, Date/Time, Status
[edit]ActivityCancel
Clears all the Activity information
[edit]Multi Threading
[edit]Starting
Before we start the thread we need to ensure that when the Windows Service is closed, that all the threads are stopped. To do this you must set the thread to a background process withIsBackground
When a thread terminates because of its parent process, it stops dead, and no finally blocks are executed.
The same situation arises when a user terminates an unresponsive application via the Windows Task Manager, or a process is killed programmatically via Process.Kill.
Therefore Restarting the Windows Service will cause the threads to stop in their tracks, which is perhaps what you are after if you restart or stop a service.
[edit]Abort
Abort will work on a thread in almost any state – running, blocked, suspended, or stopped. However if a suspended thread is aborted, a ThreadStateException is thrown – this time on the calling thread – and the abortion doesn’t kick off until the thread is subsequently resumed.
[edit]Configuration
[edit]App.Config
The application configuration file can be configured to handle the different calculations, we are using the standard .NET configuration settings, using a Section Group, within the Config Sections tag, of WaterNet, and implementing the leakage section handler, as seen below:
To configure the separate calculations you add each calculation in to the leakage tag, as seen below:
Here is a list of possible configuration options available for the calculation plugins
[edit]name
The name of the Calculation Required
[edit]assembly_name
The assembly name to be used, comprising of the method and the Assembly name, both including the full namespace. Required
[edit]numberOfThreads
sets the maximum number of threads available for this process to run at any one time default = 1
[edit]isBackground
Indicating whether or not a thread is a background thread. default = True
[edit]priority
Indicating the scheduling priority of a thread.
default = Normal
A thread can be assigned any one of the following priority values:
Highest
AboveNormal
Normal
BelowNormal
Lowest
MVC tool case
Continuous Integration
Task today is to decide and implement an Continuous Integration build process, I will be looking at two options CruseControl and Team City. The are a lot more but for the purpose of the current .NET environment these are the two I’ll be looking at.
When working in a team, the developer needs to know that any changes he makes and stores in to your repository will work for others. When the developer submits code to the repository they must first update their code to reflect the changes in the repository since they took their copy. The more changes there are to the repository, the more work the developer must do before submitting their own changes.
Eventually, the repository may become so different from the developer’s baseline that they enter what is sometimes called, “integration hell,” where the time it takes to integrate is greater than the time it took to make their original changes. In a worse case scenario, the changes the developer is making may have to be discarded and the work redone.
Continuous Integration is the practice of integrating early and often, so as to avoid the pitfalls of “integration hell”. The ultimate goal is to reduce timely rework and thus reduce cost and time. When done well, continuous integration has been shown to achieve these goals.
After speaking and Googling for each of the products, I quickly came to the conclusion that although a number of clients I have work with before have been using CruseControl I have found it quite hard to setup and the configuration of XML configuration files can be a bit of a nightmare, and as such we just need a tool to work and not have to maintain. So for the rest of this article I will be focusing on Team City by JetBrains.
I will be using version 4.5.1. TeamCity-4.5.1.exe (231 mb)
What I like about this product is the licensing, currently the Professional version is free for up to 20 users and 20 build configurations, and when the project get larger you purchase an enterprise license, currently £1,560, ideal way of working and getting you to use the produce.
It’s worth watching this short introduction video from Dime Cast, to find out how easy it is to create and use Team City.
The Server automates the integration process by monitoring the team’s source control repository directly. Every time a developer commits a new set of modifications, the server will automatically launch an integration build to validate the changes. When the build is complete, the server notifies the developer whether the changes that they committed integrated successfully or not.
Effectively, integration becomes as easy as checking in code. Using an automated integration server not only makes integration easy, it also guarantees that an integration build will happen. There is no danger of developers forgetting to validate their changes after checking in.
The Team City offers several key features:
• Integration with a variety of Source Control systems
• Integration with other external tools, such as NAnt and Visual Studio
• Can build multiple projects on one server
• Remote management and reporting
So down to the installation, once downloaded (231mb file), I installed using all the default settings and it worked, very easy to setup.
Next was to setup a project, again quite easy, I was attaching to a Visual SourceSafe (VSS) solution, I ran in to my first issue as I was getting directory authentication failed. This was because the running “TeamCity Web Server” was using my System login and it did not have permissions to the network drive for the VSS. A quick change to the TeamCity Build Server service login and it all worked.
I ran the build on a simple project and it worked without a hitch.
Next was to install the System Tray Notifier, quite simple, going to the “My Settings & Tools” tab brings a list of download, after a simple download and run, then pointing the HTTP location of the Team City installation, it worked.
What can I say it’s all just too easy to setup.
Pre-tested Commit
One issue I had, but not with Team City, is that if you are using MS Test, the built in Visual Studio 2008 testing tool, then you will need to run MS Test. But to run MS Test it is tightly coupled with Visual Studio. Which means to run MS test you’ll need to install a version of Visual Studio on your Continous Intergration machine. Therefore it might be worth using NUnit for testing.
One very nice feature of Team City is the ability to perform a Pre-tested Commit, this is possible when you install the Visual Studio Addin
An approach which prevents committing defective code into a build, so the entire team’s process is not affected.
Submitted code changes first go through testing. If it passes all of the tests, TeamCity can automatically submit the changes to version control. From there, it will automatically be integrated into the next build. If any test fails, the code is not committed, and the submitting developer is notified.
The TeamCity plugins for IntelliJ IDEA, Microsoft Visual Studio 2005/2008 and Eclipse extend the respective IDE with the remote run and pre-tested commit features. Developers test their changes by performing a Remote Run. A pre-tested commit is enabled when commit changes if successful option is selected.
Reference
http://en.wikipedia.org/wiki/Continuous_Integration
Beyond Continuous Integration: Continuous Monitoring with Owen Rogers
Setting up CruiseControl.NET to be a Continuous Monitoring Server
http://www.stevetrefethen.com/blog/archives/#Continuous+Integration
http://www.stevetrefethen.com/blog/CCNETBasedEDIInvoicingProjectGoesIntoProduction/
http://sourceforge.net/project/showfiles.php?group_id=71179&package_id=83198
Threading
http://www.jobserve.com/EC1545A81AE3DF391Z9AED430336436C.jsap
How to sort a generic List
I came across a little issue today, in that I had an Interface object and I needed to be able to sort the list, I would normally implement the IComparable interface on the concreate type, but I don’t have access to the concreate type in my case.
I tried several different methods in the end I ended up with using a delegate, and found in SimoneB Blog, which I have extracted the content below:
Sorting a generic List<T> is pretty straightforward if you know how to do it. With C# 2.0, anonymous methods come at hand, as well as the little known Comparison<T> delegate (check out this post for more information about this class as well as other useful classes new to C# 2.0).
Ok, let’s suppose we have a product class (let me save some space by using C# 3.0 syntax).
class Product
{
public int ProductID { get; set; }
public string ProductName { get; set; }
public decimal UnitPrice { get; set; }
}
When we have a list of products we may want to sort it on the ProductName property before displaying it to the user. This can be accomplished with the Sort method of the List<T> class, which defines several overloads. The most handy in this case is the Sort(Comparison<Product>) method and the result is easily achieved with a couple lines of code.
List<Product> products = new List<Product>();
products.Sort(delegate(Product p1, Product p2)
{
return p1.ProductName.CompareTo(p2.ProductName);
});
So far so good, but what if we need to sort our list in several places during the execution of our program? Do we have to write that code each time? Actually no, since we can use the parameterless Sort() method of our list class. What this method does is use the “default comparer” to sort the list. So what’s this default comparer? It’s the comparer that’s automatically created if we implement the IComparable<T> interface. This way we can centralize the sorting logic into our class, and just call the parameterless Sort() method on it whenever we need it sorted on the ProductName property.
public class Product : IComparable<Product>
{
[…]
public int CompareTo(Product other)
{
return ProductName.CompareTo(other.ProductName);
}
}
Ok, now what if we want to be able to sort it on the other two properties, ProductID and UnitPrice? Do we have to write an anonymous method each time as we did in the beginning? Of course no, since there’s a useful trick which prevents us from needing to do that. We can define two static Comparer<Product> properties in our product class, and supply them as parameters to the Sort(Comparer<T>) method of our list whenever we need it sorted on something which is not the default sorting logic.
public class Product : IComparable<Product>
{
[…]
public static Comparison<Product> PriceComparison =
delegate(Product p1, Product p2)
{
return p1.Price.CompareTo(p2.Price);
};
public static Comparison<Product> IDComparison =
delegate(Product p1, Product p2)
{
return p1.ProductID.CompareTo(p2.ProductID);
};
[…]
}
Since they are static they can be used simply like so: products.Sort(Product.PriceComparison) or products.Sort(Product.IDComparison), which will respectively sort the list by price and id.
Below is the full code of the Product class.
public class Product : IComparable<Product>
{
private int id;
private string prodName;
private decimal price;
public static Comparison<Product> PriceComparison = delegate(Product p1, Product p2)
{
return p1.price.CompareTo(p2.price);
};
public static Comparison<Product> IDComparison = delegate(Product p1, Product p2)
{
return p1.id.CompareTo(p2.id);
};
public int ProductID
{
get { return id; }
set { id = value; }
}
public string ProductName
{
get { return prodName; }
set { prodName = value; }
}
public decimal UnitPrice
{
get { return price; }
set { price = value; }
}
public Product(int id, string prodName, decimal price)
{
this.id = id;
this.prodName = prodName;
this.price = price;
}
#region IComparable<Product> Members
public int CompareTo(Product other)
{
return ProductName.CompareTo(other.ProductName);
}
#endregion
public override string ToString()
{
return string.Format(“Id: {0} Name: {1} Price: {2}”, id, prodName, price);
}
}