BAKOPANOS KONSTANTINOS

NUnit Hello Test

2010-02-20T16:13:00.004+01:00

You can download NUnit from http://www.nunit.org/

Getting started (Hello Test) !!!
Let's write our first test and run/debug it.
1. Create a class library in visual studio. A good convention is to suffix all your test projects with *Tests.
2. Add a reference to Nunit

3. Create a class and optionally suffix it with "Fixture". Then decorate it with the [TestFixture] attribute.

4. Create a public method, optionaly suffix it with "Test" and decorate it with the [Test] attribute.

5. Build your class library project.
6. You can run/dubug the unit test directly from studio if you have any plugin such as Resharper (VERY GOOD!!!) or TestDriven.Net or any other plugging.
nunit.exe
Start nunit.exe and create a new project. Then you add "assembly" or "VS Project", both will do.

You can directly run the test from the gui provide it.
If you want to debugg then goto Visual studio and attach to the nunit process. Then set the desired breakpoints, kick the test you'd like from the NUnit app and you should hit your breakpoints.

nunit-console.exe

MSBuild
The easiest way is to use some 3rd party msbuild task such as the http://msbuildtasks.tigris.org/
In order to use the tasks in this project, you need to import the MSBuild.Community.Tasks.Targets files. If you installed the project with the msi installer, you can use the following.

You can find info on msbuild at http://msbuildtasks.com/default.aspx
The task to call for NUnit is the following

Save the xml file, let's assume you name it NUnitSample.proj and call it from MSBuild

Video series: 3-Tier Pattern Architecture with Unity

2010-01-22T11:11:00.007+01:00

E00: Intro
http://www.youtube.com/watch?v=qaL-q4q6OIA

E01: set up the sample application
part1 http://www.youtube.com/watch?v=mUwWU9IUpR0
part2 http://www.youtube.com/watch?v=75iSSZ7o0gs
part3 http://www.youtube.com/watch?v=qg2U6-kG9l0

E02 : Dependency Injection "object management" with Unity
part1: http://www.youtube.com/watch?v=s5rd7mUu89A
part2: http://www.youtube.com/watch?v=XmUQvqjsTYU

E03 : component management "modularity" with Unity
E04 : configurability
E05 : testing/mocking

ArchitectureSamples-FunqUnity in C#4.0

2009-12-06T18:35:00.005+01:00

I have posted a very nice sample application on my googlecode:
ArchitectureSamples-FunqUnity
You can checkout the code with tortoise. You need VS2010 Express or higher. Soon I will post a sibling to this sample also in VB.NET. All necessary binaries: Unity, NUnit and RhinoMocks are committed with the sample for your convenience.

The sample application demonstrates the following architectural aspects:
. Domain Driven Design / Repository Pattern
. Modularity: Type safe registration of services
. Modularity: Xml registration of components
. Modularity: Inject xml configuration
. Dependency Injection
. Unit Tests / Mocks: isolate the repository the layer when testing the application layer
. Functional programming: use lambdas to isolate components in child containers
. Functional programming: use lambdas to isolate ADO.NET infrastructure calls (connections, commands)
. Functional programming: use lambdas to create a database technology factory (sqlce, oledb, ...)

Please sent me comments... If I get enough input I will include more aspects such as:
. Presentation patterns: MVC (console apps)
. Presentation patterns: MVP (win apps and web forms apps)
. Presentation patterns: Presentation Model (wpf and silverlight)
. Data Access Guidance
. Web Services Layer, DTO pattern
. Plug-in patterns
. Domain Driven Design / aggregates, validation, rules

List of most common Design Patterns

2009-11-22T12:08:00.003+01:00

In software engineering, a design pattern is a general reusable solution to a commonly occurring problem in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Design pattern (computer science)

Below I have a list of most common design patterns.

Creational Patterns

Abstract Factory

Creates an instance of several families of classes

Builder

Separates object construction from its representation

Factory Method

Creates an instance of several derived classes

Prototype

A fully initialized instance to be copied or cloned

Singleton

A class of which only a single instance can exist

Structural Patterns

Adapter

Match interfaces of different classes

Bridge

Separates an object's interface from its implementation

Composite

A tree structure of simple and composite objects

Decorator

Add responsibilities to objects dynamically

Façade

A single class that represents an entire subsystem

Flyweight

A fine-grained instance used for efficient sharing

Proxy

An object representing another object

Behavioral Patterns

Chain of Responsibility

A way of passing a request between chains of objects

Command

Encapsulate a command request as an object

Interpreter

A way to include language elements in a program

Iterator

Sequentially access the elements of a collection

Mediator

Defines simplified communication between classes

Memento

Capture and restore an object's internal state

Observer

A way of notifying change to a number of classes

State

Alter an object's behavior when its state changes

Strategy

Encapsulates an algorithm inside a class

Template Method

Defer the exact steps of an algorithm to a subclass

Visitor

Defines a new operation to a class without change

Type safe named instances with Unity

2009-11-17T22:09:00.003+01:00

The following example demonstrates registering a named instance in Unity. The only problem here is that both the registration and resolving of the dependency is done using a string. Even using a static class to hardcode all strings in a kind-of type safe way gives us no guaranty that the developer will respect the convention.

An alternate way of doing this would be using a delegate to resolve the instance giving a type safe argument such as an enumeration. So the registration in unity is a bit different...

Instead of a static class with constants we now have a type safe enumeration:

...and finally the client class that resolves the delegate:

In addition the actual resolving of the configuration string (typically read from a config) is done lazy... at the moment we really need it.
Finally we don't have ambiguity in registering in the container a type such as string, since we now mark the instance with an additional type (marker type).

Implementing a .NET Framework Data Provider

2009-11-12T12:42:00.004+01:00

Five years ago I needed to implement a web app for a chemicals company, that was using data from SqlServer, Oracle, Documentum and Hummingbird. The problem was that at that time both Documentum and Hummingbird (document management systems) had no oledb nor .net providers available. So my data layer became a big mess due to the fact that some of my code was through ADO.NET and the rest was using proprietary API's from Documentum and Hummingbird. In addition having such code was very error prone and not testable at all, since those API's at that time were very low level.
The solution that I had found was to implement my own .NET Data Provider. I used as basis an example posted on msdn: Implementing a .NET Framework Data Provider.
The article provides a template implementation of a "Fake/Sample" data provider for an in-memory database "Fake/Sample". If you are investigating in this direction then following the above link will be very helpful.
For your convenience I have created a sample wpf app using this code. The code is an identical copy of the original; I have only made some improvements to make it up-to-date with .NET 4.0 since the initial article was written for .NET 1.0
You can checkout the sources using tortoise: http://bakopanos.googlecode.com/svn/trunk/blog/DotNetDataProviderTemplate/
I used Visual Studio 2010 for this :-)

An overview of the code
The "fake/sample" database in the sample mimics a real world database that returns a cursor of the following structure:

The commands supported by the sample database are startwith "select " and startwith "update ". This is it: 2 hardcoded commands, no args or anything...

The select command returns always the following resultset hardcoded in code:
The update command simply alters the (2,2) cell of the above table.

Once you understand this sample you can implement your own wrapper for the database of your choice. I am about to implement a dataprovider for reading a large number of xml files...

Preventing Dialogs or Trace.Fail

2009-11-12T10:27:00.001+01:00

The System.Diagnostics provide a very nice infrastructure for logging. When you start an app, by default a DefaultTraceListener is added to the Debug.Listeners collection. The problem is that the DefaultTraceListener instance has the property AssertUiEnabled set to true. This will popup a nice message box, in case for example of this statement

In winforms or console apps this is quite nice. Especially the possibility to attempt a retry ...

In case you need to disable this dialog: for a wpf app, for asp.net, for a wcf service... then you simply need to set the AssertUiEnabled property to false. In addition you can wire your own outputs...

How much does it cost to resolve with Unity?

2009-11-11T22:26:00.006+01:00

The following sample shows how expensive it is to resolve types using a DI container. On my notebook it showed the following:

00:00:00.0040000
00:00:01.7080000
00:00:00.1640000

As you can easily see resolving a type with Unity is something like at least 40 times slower. Is it worth it? I believe yes because you'll catch up with the performance on good design.

Hints: migration from VS2008SP1 -> VS2010Ultimate

2009-11-11T11:09:00.000+01:00

1. The 2nd line of the project file has being changed

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

When you try to open the migrated project with VS2008 you simply get the following warning:

Project file contains ToolsVersion="4.0", which is not supported by this version of MSBuild. Treating the project as if it had ToolsVersion="3.5".

...all the rest work fine!

2. A whole set of new elements has being added to the default PropertyGroup of the project; all these are not breaking when you try to open the migrated project with VS2008.

<FileUpgradeFlags> 
</FileUpgradeFlags> 
<OldToolsVersion>3.5</OldToolsVersion> 
<UpgradeBackupLocation /> 
<PublishUrl>http://localhost/Utilities/</PublishUrl> 
<Install>true</Install> 
<InstallFrom>Web</InstallFrom> 
<UpdateEnabled>true</UpdateEnabled> 
<UpdateMode>Foreground</UpdateMode> 
<UpdateInterval>7</UpdateInterval> 
<UpdateIntervalUnits>Days</UpdateIntervalUnits> 
<UpdatePeriodically>false</UpdatePeriodically> 
<UpdateRequired>false</UpdateRequired> 
<MapFileExtensions>true</MapFileExtensions> 
<ApplicationRevision>0</ApplicationRevision> 
<ApplicationVersion>1.0.0.%2a</ApplicationVersion> 
<IsWebBootstrapper>true</IsWebBootstrapper> 
<UseApplicationTrust>false</UseApplicationTrust> 
<BootstrapperEnabled>true</BootstrapperEnabled>

3. A new element has being added on the PropertyGroup of each configuration; also nothing breaking... VS2008SP1 ignores them.

<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>

4. A new ItemGroup have being added; also nothing breaking... VS2008SP1 ignores them.

<ItemGroup> 
  <BootstrapperPackage Include="Microsoft.Net.Client.3.5"> 
    <Visible>False</Visible> 
    <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName> 
    <Install>false</Install> 
  </BootstrapperPackage> 
  <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1"> 
    <Visible>False</Visible> 
    <ProductName>.NET Framework 3.5 SP1</ProductName> 
    <Install>true</Install> 
  </BootstrapperPackage> 
  <BootstrapperPackage Include="Microsoft.VisualBasic.PowerPacks.10.0"> 
    <Visible>False</Visible> 
    <ProductName>Microsoft Visual Basic PowerPacks 10.0</ProductName> 
    <Install>true</Install> 
  </BootstrapperPackage> 
  <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1"> 
    <Visible>False</Visible> 
    <ProductName>Windows Installer 3.1</ProductName> 
    <Install>true</Install> 
  </BootstrapperPackage> 
</ItemGroup>

5. If your projects have being set to "Treat warnings as errors" then VS2010 is much more sensitive, especially to xmldocumentation mistakes.

Fail: VS2010 Setup

2009-11-11T10:26:00.000+01:00

Functional programming using Unity

2009-11-09T11:14:00.003+01:00

C# 3.0 comes with functional programming capabilities that can become very handy if combined with a dependency injection framework as Unity.
Take a look at the following example. The function ‘doThis’ can be register in the unity container just like any other instance of a type. At the time of registration the function ‘doThis’ isn’t called yet. It’s not even called at the time of resolving the function ‘doThis’ from the container. This idea is very useful when doing lazy things with Unity.

//create a unity container
IUnityContainer container = new UnityContainer();   
//define a function
Func<bool> doThis = delegate 
{ 
Debugger.Break(); 
return true; 
}; 
//register the function as instance
//function will not execute during registration 
container.RegisterInstance(doThis);
//resolve the function from the container
//function will not execute during the resolving
var f = container.Resolve<Func<bool>>();
//will execute here:-) 
f();

UnityContainer Lifetime Management extension methods

2009-11-03T21:20:00.003+01:00

The following code snippet registers the type MySingletonObject to the IMyObject interface as a singleton. The problem is that in order to get the UnityContainer type you need a references to the Microsoft.Practices.Unity.dll and in order to get the ContainerControlledLifetimeManager type you will need a reference to the Microsoft.Practices.ObjectBuilder2.dll

Now if the case is that you need more that ContainerControlledLifetimeManager type from Microsoft.Practices.ObjectBuilder2.dll then it’s worth the reference… if not then the following extension method could help you do the same as before without the need for a reference to Microsoft.Practices.ObjectBuilder2.dll (in a large project you will most likely have some base class library dll with common and shared types; create the extension method there…)

Using the extension method the code now looks like this:

Same idea can be applied for ExternallyControlledLifetimeManager.

Note that Chris Tavares (from the p&p team) has mentioned in the p&p summit 2009 last month that the next release of Unity will have the Microsoft.Practices.ObjectBuilder2.dll most likely merged into the Unity assembly.

NUnit 2.4.* to NUnit 2.5.* migration / Rhino.Mocks

2009-11-03T14:33:00.001+01:00

NUnit 2.5 has changed quite substantially compared with the previous 2.4.8 release, as outlined in the NUnit 2.5 release notes.
The problems that I had when migrating tests to NUnit 2.5 were:

Assert.IsInstanceOfType has been replaced by Assert.IsInstanceOf
NUnit.Framework.SyntaxHelpers namespace no longer exists. All classes that were in this namespace have been moved to the NUnit.Framework namespace
Many alias conflicts if using Rhino.Mocks
using RIs = Rhino.Mocks.Constraints.Is;
using NIs = NUnit.Framework.Is;
using RProperty = Rhino.Mocks.Constraints.Property;
using NProperty = NUnit.Framework.Property;
using RAssert = NUnit.Framework.Assert;
using NAssert = NUnit.Framework.Assert;
using NList = NUnit.Framework.List;
using RList = Rhino.Mocks.Constraints.List;
Has.Length(2); has been replaced by Has.Length.EqualTo(2));
Has.Count(1); has been replaced by Has.Count.EqualTo(1);
Has.Property("Length", 20) has been replaced by Has.Property("Length")
Error 243 Warning as Error: 'NUnit.Framework.Text' is obsolete: 'Use Is class for string constraints'

Good luck migrating

Developing a Solution Generator (EasySolutions)

2009-10-17T04:20:00.007+02:00

Considerations for large projects (Dynamic solutions)

The information is based on practices learned from my 4 year tenure as SW architect of a large (60 developers) team. I will show you how to get the most out of Visual Studio 2008 to help improve the effectiveness of your team-based software development using a tool that I am about to develop EasySolutions

A large project typically differs from a smaller project:

You need to partition your project into multiple (100+) Visual Studio projects.
You shouldn’t have to wait for several minutes before your IDE is responsive due to the fact that your solution is getting too big.

Building your projects for development

Something that I have learned is that you should never use solutions to build your project. Solutions are evil, really evil. You need them in order to work with Visual Studio, but that’s about it. You should never use them elsewhere and you should never commit solutions with the sources. Instead you should use MSBuild to build your project and you should dynamically generate the required solutions using a tool. Developing such a tool is no big deal. I will drop some bits explaining the idea and hopefully drop a first version of the tool in the next month or two.

What you will get meanwhile is the outcome of some work I did waiting for my flight to Zurich returning from the p&p summit!

Building a Solution Generator

This idea is very appealing since the projects files are in xml and usually also in MSBuild format thus they are very simply to parse.

The basic flow of such a tool is the following:

Search for project files (example *.csproj) recursively.
Load with XDocument each project and search for project references.

var projectReferences = 
from element in xdoc.Descendants(xNameSpace + "ProjectReference")
select Path.GetFullPath(Path.Combine(projectDirName, (string) element.Attribute("Include")));

Create an object graph with all the project references per project and serialize it to xml for convenience. You will use this cache in order to avoid unnecessarily parsing the project files again. The schema of your xml is based on the following fragment…

[XmlRoot(ElementName = "Projects")]
public class Projects : List { }

public class ProjectBase
{
  [XmlAttribute]
  public Guid ProjectGuid { get; set; }
}

public class Project : ProjectBase
{
  public Project() { }

  public List ProjectReferences { get; set; }
}

You can now start querying that Projects instance typically using Linq. Generating a solution file is quite easy; the solution schema is very simple. {FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") is the id of csprojects… Similarly you find id’s for all projects types supported.

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleApplication1", "ConsoleApplication1\ConsoleApplication1.csproj", "{CD06FCD6-9F1A-4736-A034-925C24F628C3}"
EndProject

What you get from such tool:

You are able to open only the necessary projects each time.
You are able to make structural changes to your projects (add, rename, delete projects) without the fear that you will break other solutions.
You don’t need to store the solution files in the source control.

Getting the tool one step further

Another point of pain is synchronizing all project properties across many studio projects (Some examples the output dirs should much, the build configurations should much, flags such generate doc and warnings should much and so on). The first problem is to find out the mistakes and there are tools around that will do this like BuildCop. The second problem is to go and manually alter all mistakes... fun job to do in a large project don't you agree? Well we could reuse the above idea, craft a simple gui to maintain project settings from all projects in one view and then directly save the changes into the visual studio project files. After all it's quite simple to alter XML...

Validation for Windows 7 is coming soon!

2009-09-11T14:03:00.002+02:00

I am ALWAYS so glad to install new releases of Microsoft Windows. So I have installed the Windows 7 RTM. Today (11.09.2009) I got a very bad surprise! Windows poped up a warning that my copy is not genuine with a link to validate my copy of Windows 7. So I try to validate at http://www.microsoft.com/genuine/ .... and during the validation process I get the following message:

Validation for Windows 7 is coming soon!
Microsoft constantly strives to update our technologies to help protect our customers from the risks of counterfeit software. Right now, we are working hard to improve the way that validation checks to see whether Windows 7 running on your PC is genuine.
Shortly after Windows 7 is available for purchase beginning October 22, you will be able to validate Windows 7 running on your PC to help you determine that it’s genuine.

The problem is that some win7 features have being meanwhile disabled:-(

Visual Studio 2008 SP1 on Windows 7

2009-09-04T17:51:00.002+02:00

I have installed VS2008 on Win7 and it works just great. The only problem that I had was related to the VSTO.

Knowledge base number: KB949258MSI (s) (F0:5C) [18:27:43:876]: Windows Installer installed an update. Product Name: Visual Studio Tools for the Office system 3.0 Runtime. Product Version: 9.0.30729. Product Language: 0. Manufacturer: Microsoft Corporation. Update Name: KB949258. Installation success or error status: 1603.

To overcome follow these steps.

1. Install VS2008
2. Install the
Make sure that before running the Microsoft Visual Studio Tools for the Microsoft Office System (version 3.0 Runtime) Service Pack 1 (x86)
http://www.microsoft.com/downloads/details.aspx?FamilyID=d8eb4921-891a-4b5e-973f-0b96e6ccf376&DisplayLang=en
3. Install the VS2008 SP1

This should work!

Install Windows 7 on a vhd file

2009-08-09T21:27:00.002+02:00

Please have in mind that you can only boot from vhd files on the Ultimate and Enterprise editions of Windows 7. The instructions bellow work on all editions but you will be only able to logon if you are running Ultimate or Enterprise due to licensing issues.

Boot from the Windows 7 dvd and select “repair your computer”.
Select “use recovery tools”
Select “command prompt”

x:\sources> diskpart
diskpart> create vdisk file="c:\images\win7.vhd" maximum=64000
diskpart>select vdisk file="c:\images\win7.vhd"
diskpart>attach vdisk
diskpart>exit
x:\sources>setup

Good luck!

also read: http://blogs.msdn.com/knom/archive/2009/04/07/windows-7-vhd-boot-setup-guideline.aspx

Windows 7 Compare editions

2009-08-07T12:10:00.002+02:00

more info

Windows 7
Starter

Windows 7 Starter makes small notebook PCs easier to use because it puts less between you and what you want to do—less waiting, less clicking, less hassle connecting to networks. Windows 7 Starter combines the latest in reliability and responsiveness with the familiarity and compatibility of Windows.

Windows 7
Home Premium

Make the things you do every day easier with improved desktop navigation.
Start programs faster and more easily, and quickly find the documents you use most often.
Make your web experience faster, easier and safer than ever with Internet Explorer 8.
Watch, pause, rewind, and record TV on your PC.
Easily create a home network and connect your PCs to a printer with HomeGroup.

Windows 7
Professional

Home Premium
Run many Windows XP productivity programs in Windows XP Mode.
Connect to company networks easily and more securely with Domain Join.
In addition to full-system Backup and Restore found in all editions, you can back up to a home or business network.

Windows 7
Ultimate

Home Premium + Professional
Help protect data on your PC and portable storage devices against loss or theft with BitLocker.
Work in the language of your choice and switch between any of 35 languages.

A Developer's Introduction to Windows Workflow Foundation (WF4) in .NET 4 Beta 1

2009-08-07T11:06:00.002+02:00

A fantastic article on WF .NET 4

A Developer's Introduction to Windows Workflow Foundation (WF4) in .NET 4 Beta 1

Introduces a significant amount of change from the previous versions of the technology that shipped as part of .NET 3.0 and 3.5.
Revisited core of the programming model, runtime and tooling.
Increased performance and productivity.
Backwards compatibility. The new framework components are found primarily in the System.Activities.* assemblies while the backwards compatible framework components are found in the System.Workflow.* assemblies.

A Developer’s Introduction to Windows Communication Foundation (WCF4) in .NET 4 Beta 1

2009-08-07T11:03:00.002+02:00

A very nice article on WCF .NET 4

A Developer’s Introduction to Windows Communication Foundation (WCF) .NET 4 Beta 1

The article describes the main feature areas. These feature areas summarize most of what’s new in WCF and they highlight the top-level opportunities offered by this release of the framework.

Feature Area	Description
Simplified Configuration	Simplification of the WCF configuration section through support for default endpoints, binding and behavior configurations. These changes make it possible to host configuration-free services, greatly simplifying the developer experience for the most common WCF scenarios.
Discovery	New framework support for both ad-hoc and managed service discovery behaviors, which conform to the standard WS-Discovery protocol.
Routing Service	New framework support for a configurable routing service that you can use in your WCF solutions. Provides features for content-based routing, protocol bridging, and error handling.
REST Improvements	Enhances the WCF 3.5 Web programming model with some additional features that simplify REST service development.
Workflow Services	Rich new framework support for integrating WCF with WF to implement declarative long-running workflow services. This new programming model gives you the best both frameworks have to offer (WCF & WF).

JetBrains ReSharper 4.5

2009-05-23T22:08:00.001+02:00

JetBrains is providing the “best” productivity add-on around. Visual Studio is simply not the same without R#. There is a small penalty in performance of-course but it’s absolutely worth it. Bare in mind that the solution wide analysis feature should not be turned on all the time for large solutions (50+ projects) because it slows down studio a lot.

The is a 30 day fully functional trial available: http://www.jetbrains.com/resharper/download/index.html

Features: http://www.jetbrains.com/resharper/features/

Code Analysis: On-the-fly Error Detection; Multilevel Code Inspection; Quick-Fixes; Navigating Between Code Highlights; Solution-Wide Error Analysis; Value Analysis; Annotated Framework

Navigation & Search: Navigate from Here; 'Go to' Features; Usage Search; CamelHumps; Type Hierarchy; File Structure; Find Referenced/Dependent Code; Collapse All in Solution Explorer; Locate in Solution Explorer; View Recent Items; Stack Trace Explorer; To-do Explorer

Refactorings: Using Code Refactorings; Change Signature; 'Convert' Refactorings; Copy Type; Encapsulate Field; 'Extract' Refactorings; 'Inline' Refactorings; 'Introduce' Refactorings; Make Method Static/Non-Static; 'Move' Refactorings; Pull/Push Members Up/Down; Rename; Replace Constructor with Factory Method; Safe Delete; Use Base Type where Possible

Code Generation: Create from Usage; Generate Type Members; Implement/Override Methods; Configure Generation Options

Coding Assistance: Syntax Highlighting; Context Actions; Code Completion; Complete Statement; Extended Naming Style Configuration; Parameter Info; Highlight Matching Delimiters; Importing Namespaces; Auto-insertion of Delimiters; Code Reordering; Quick Documentation; Comment/Uncomment Code; Highlight Current Line; Extend/Shrink Selection; Duplicate Line or Selection; Multiple Entries Clipboard

Code Cleanup: Using Code Cleanup; Code Formatting; Optimizing Namespace Import Directives; Removing Code Redundancies; Migrating to C# 3.0; Reordering Type Members; Code Style Configuration and Sharing

Code Templates: Live Templates, Surround Templates, File Templates; Customizing, Configuring and Sharing Templates

Unit Testing: Running and Debugging Tests; Unit Test Explorer; Unit Test Sessions; Profiling Unit Tests with dotTrace Profiler

Cross-Language Functionality

Build Scripts

Visual Studio 2010 Beta 1 (MSDN Subscriptions)

2009-05-23T21:14:00.002+02:00

Visual Studio 2010 Professional Beta 1 (x86) - DVD (English)
Includes: Professional; 05-18-2009
File Name: en_visual_studio_2010_professional_edition_beta_1_x86_dvd.iso
Date Posted (UTC): 5/18/2009 10:03:17 AM

Available to Levels: MSDN OS (VL); VS Pro with MSDN Pro (VL); VS Pro with MSDN Premium (Empower); MSDN OS (Retail); Developer AA; VS Pro with MSDN Pro (Retail); MSDN Enterprise; MSDN Universal (Retail); VSTS Team Suite (VL); VSTS Architecture (VL); VSTS Development (VL); VSTS Test (VL); VS Pro with MSDN Premium (VL); MSDN Universal (VL); VSTS Database (VL); VS Pro with MSDN Premium (Retail); VSTS Test (Retail); VSTS Development (Retail); VSTS Architecture (Retail); VSTS Team Suite (Retail); VSTS Database (Retail); BizSpark Admin; BizSpark;

Visual Studio Team Foundation Server 2010 Beta 1 (x86 and x64) - DVD (English)
Includes: Team Foundation Server; 05-18-2009
File Name: en_visual_studio_team_foundation_server_2010_beta_1_x86_x64_dvd.iso
Date Posted (UTC): 5/18/2009 10:02:33 AM

Available to Levels: MSDN OS (VL); VS Pro with MSDN Pro (VL); VS Pro with MSDN Premium (Empower); MSDN OS (Retail); Developer AA; VS Pro with MSDN Pro (Retail); MSDN Enterprise; MSDN Universal (Retail); VSTS Team Suite (VL); VSTS Architecture (VL); VSTS Development (VL); VSTS Test (VL); VS Pro with MSDN Premium (VL); MSDN Universal (VL); VSTS Database (VL); VS Pro with MSDN Premium (Retail); VSTS Test (Retail); VSTS Development (Retail); VSTS Architecture (Retail); VSTS Team Suite (Retail); VSTS Database (Retail); BizSpark Admin; BizSpark;

Visual Studio Team System 2010 Team Suite Beta 1 (x86) - DVD (English)
Includes: Team System; 05-18-2009
File Name: en_visual_studio_team_system_2010_team_suite_beta_1_x86_dvd.iso
Date Posted (UTC): 5/18/2009 10:02:03 AM

Available to Levels: MSDN OS (VL); VS Pro with MSDN Pro (VL); VS Pro with MSDN Premium (Empower); MSDN OS (Retail); Developer AA; VS Pro with MSDN Pro (Retail); MSDN Enterprise; MSDN Universal (Retail); VSTS Team Suite (VL); VSTS Architecture (VL); VSTS Development (VL); VSTS Test (VL); VS Pro with MSDN Premium (VL); MSDN Universal (VL); VSTS Database (VL); VS Pro with MSDN Premium (Retail); VSTS Test (Retail); VSTS Development (Retail); VSTS Architecture (Retail); VSTS Team Suite (Retail); VSTS Database (Retail); BizSpark Admin; BizSpark;

ASP.NET Portal Starter Kit

2009-05-22T20:11:00.001+02:00

The ASP.NET Portal Starter Kit demonstrates how you can use ASP.NET and the .NET Framework to build a dynamic portal application. The ASP.NET Portal Starter Kit offers all the functionality of typical portal applications.
It's developed in c# 3.0 \ .NET 3.5.

http://www.codeplex.com/ASPNETPortal

Project Scope

Re-engineering the original project using up-to-date technologies

Features

Dynamic Portal Infrastructure
10 basic portal modules for common types of content
2 extra portal modules: RSS Feed and Wiki (postponed)
A "pluggable" framework that is simple to extend with custom portal modules
Online administration of portal layout, content and security
XML based definition of portal layout
Database based definition of portal layout
Roles-based security for viewing content, editing content, and administering the portal
Full mobile support using the ASP.NET Mobile Controls
Multiple database support easily extensible to support more databases
Web service layer ASMX and WCF
Smart Client to support Admins and power users

Technologies and Design Approaches Demonstrated

.NET 2.0 \ .NET 3.5
Web Client Software Factory
Object Builder
Smart Client Software Factory
ASP.NET Mobile Controls
Three-tier architecture with ASP.NET
Role Based Security
Layered architecture
- Vertical: Data\Business\Presentation
- Horizontal: Services, Framework
Design Patterns
NUnit Tests
Master Pages, SiteMaps & Themes

Design Pattern: Factory Method

2009-05-21T21:55:00.001+02:00

The factory method pattern deals with the problem of creating objects without specifying the exact class of object that will be created. The factory method design pattern handles this problem by defining a separate method for creating the objects, whose subclasses can then override to specify the derived type of object that will be created.
More generally, the term factory method is often used to refer to any method whose main purpose is creation of objects.

This sample requires the following to be installed: Visual Studio 2008. You can checkout a read-only copy of this sample using tortoise from:
http://bakopanos.googlecode.com/svn/trunk/designpatterns/GangOfFour.FactoryMethod

A very simple example: we’ll create a DataFactory class that will be able to map a IDataReader to an Object. The DataFactory is abstract since the subclasses will override the Map method implementation.

public abstract class DataFactory<T>
    where T : class, new()
{
    public abstract List<T> List();

    protected List<T> List(string cmd)
    {            
        var items = new List<T>();
        
        using (var conn = new SqlCeConnection(@"Data Source=Database1.sdf"))
        {
            conn.Open();
            using (var command = new SqlCeCommand(cmd, conn))
            {
                var reader=command.ExecuteReader(CommandBehavior.CloseConnection);
                while (reader.Read())
                {
                    items.Add(Map(reader));
                }
            }
        }
        return items;
    }

    public abstract T Map(IDataRecord reader);            
}

We need to map the database Table Titles to the object Title.

 
public classTitle      
{ 
    public int Id { get; set; } 
    public stringName { get; set; } 
} 
The TitleDataFactory class subclasses the DataFactory and overrides the Map method.

public class TitleDataFactory : DataFactory<Title>
{
    public override List<Title> List()
    {
        return List("select * from titles");
    }

    public override Title Map(IDataRecord reader)            
    {
        int id = (int) reader["id"];
        string name = reader["name"] as string;
        var item = new Title {Id = id, Name = name};

        return item;
    }
}

Although the sample is far from a proper ORM implementation it demonstrates well the Factory Method design pattern. 
If you are looking for your next ORM tool then this is the wrong place, consider:
EntLib, Spring, ActiveRecord, NHibernate
LinqToSql, EntityFramework, DataSet
any of the many commercial frameworks such as IdeaBlade, DevExpress XPO and so on…
Some sample client code to demonstrate how to use the DataFactory

/// <summary>
/// Entry point into console application.
/// </summary>
static void Main()
{
    List<Title> list = new TitleDataFactory().List();
                
    foreach (var title in list)
    {
        Console.WriteLine(title.Name);
    }

    // Wait for user
    Console.ReadKey();
}

C# Generics and Extension methods to build a simple iterator

2009-05-20T22:22:00.001+02:00

In this example we focus on the type safe collection classes and show how to build a simple iterator.

using System;

namespace ForEachIterators
{
    interface IAction
    {
        void Action();
    }

    static class Program
    {
        public static void ForEachI<T>(this T[] array) where T : IAction
        {
            foreach (T elem in array)
            {
                elem.Action();
            }
        }

        public class MyString : IAction
        {
            readonly string _s;
            public MyString(string s) { _s = s; }

            public void Action()
            {
                Console.WriteLine("I'm a string with {0}", _s);
            }
        }

        public delegate void Action<T>(T obj);

        public static void ForEach<T>(this T[] array, Action<T> action)
        {
            if (action != null)
                foreach (T elem in array)
                {
                    action(elem);
                }
        }
        //leave private 
        static void StringAction(this string s)
        {
            Console.WriteLine("a String {0}", s);
        }
        //leave private 
        static void IntAction(this int i)
        {
            Console.WriteLine("an Integer {0}", i);
        }

        static void Main()
        {
            var arr0 = new MyString[2];
            arr0[0] = new MyString("Hallo");
            arr0[1] = new MyString("value");
            arr0.ForEachI();

            var arr1 = new [] { "Hello", "World" };
            arr1.ForEach(StringAction);
            var arr2 = new [] { 2, 6, 3, 9 };
            arr2.ForEach(IntAction);
            arr2.ForEach(IntAction); //Delegate inference
            arr2.ForEach(i => Console.WriteLine("lambda: {0}", i));

            Console.ReadLine();
        }
    }
}