Cesar de la Torre - BLOG

Creating several Entity Diagrams within a single Model in EF 5.0 and Visual Studio 2012

cesardl [MSFT] — Sun, 03 Jun 2012 16:27:00 GMT

This feature is killer and it’s been waited for long time by any developer or company who use EF visual models with a lot of entities.

Think about a model where you have hundreds of entities.., opening a single diagram with 200 entities doesn’t make sense and it is too slow and kind of unmanageable.

Now, with EF 5.0 and Visual Studio 2012, you can have many diagrams that visually Split the same entity model. This is cool, even more than the coloring feature.

For instance, in the model below, I have selected a group of entities (entities related with ‘Customer’), then you right-click on any of those entities and select the “Mode to new Diagram” option:

So now I can have a simpler entity diagram showing only the entities related to ‘Customer’. In this case, I called ‘CRM’ to this second diagram:

You can also do it in a COPY/PASTE way. so, any entity can be showed in several diagrams, etc.

I want to highlight that both diagrams are like a VIEW of the same MODEL, which has all the entities.

A given MODEL (.edmx) can have now many visual DIAGRAMS. This is really convenient for visually isolating certain areas of high complex and large models.

Coloring Entities with EF 5.0 RC and VS.2012 RC

cesardl [MSFT] — Sun, 03 Jun 2012 15:59:00 GMT

In Visual Studio 2012 RC (the Release Candidate was released last week on May 31st 2012) and Entity Framework 5.0 RC, the Entity Designer surface of EF MODEL/DATABASE FIRST, now supports entity shape coloring.
This is really nice to differentiate categories, like when you have several AGGREGATES within your MODEL, etc.

Here is a sneak peak of what we have in the RC:

On the other hand, when dealing with DDD Domain Models (Domain Driven Design approach), I think EF CODE-FIRST fits much better (No anemic-domain-model, entity classes can have their own logic in a straightforward way, just adding methods, etc.). Using this second approach (CODE-FIRST), we directly create/code entities as classes and therefore we don’t use any Entity Designer.

Sure, you could always add partial clases with methods and logic to the entity classes generated by the visual entity designer or POCO entity T4 templates, but that is kind of a workaround.. It is not so 'clean code'. ;)

In any case, having the entity shape coloring is very convenient to differentiate categories, if you are using the visual Entity Designer.

Creating a Windows 8 Release Preview Master VHD

cesardl [MSFT] — Thu, 31 May 2012 21:26:00 GMT

You can install Windows 8 into a .VHD following a similar process (like this post I wrote) than when you install it on a raw hard drive, but if you want to have a clean master .vhd which is not related to any specific installation and machine name, and you want to re-use this master .vhd in many machines over time, then the following procedure is much better.

Requirements

- Windows AIK for Windows 7 (To get the imagex.exe tool)
- AIK supplement for Windows 7 SP1
- Windows 8 .iso file or DVD

We need the Windows AIK and complement only to get the imagex.exe. So, if you don’t have it, just install Windows AIK setup, and then you must update it with the AIK supplement. In this second case, you just need to copy all the AIK supplement over the Windows AIK installation path, like doing it with the following command (Where we have the AIK supplement in the F:\ drive, like a DVD):

xcopy E:\ "C:\Program Files\Windows AIK\Tools\PETools" /ERDY

Creating the .VHD

This is the first step. We will create a dynamic disk because it takes less space when it is not started, and if desired, you could always change it to a fixed disk.

In order to create a .VHD we can use the Windows Disk Management or the command tool DISKPART.EXE.

I’ll use the Windows Disk Management Tool, as it is easier:

1. In menu “Action” select “Create VHD”.
2. Write the path where you want to store the .vhd file, the maximum file size (I'll go for 50GB) and the vistual disk type (I'll go for “Dynamically Expanding”).
3. Initialize the disk with the option “Initialize Disk, in the contextual menu.
4. Select the partition style. Currently the option GPT doesn't work for virtual machine booting because they do not support UEFI.
5. Then, we create the partition for the operating system. Right click on the free space of the disk and select “New Simple Volume”. In the wizard you must specify the size of the partition, the drive letter, etc.

Burning the Windows 8 .iso image into the .VHD

To do so, we need the command line tool called IMAGEX.EXE, which is included into the Windows AIK, in Windows\Program Files\Windows AIK\Tools\amd64 (or x86, etc.).

Before burning the Windows 8 operating system image we must check and find the index of the concrete Windows 8 installation we want to install (sometimes there are several possible installation within the same .ISO or DVD).

In this case, F:\ drive is the drive where I have the Windows 8 installation bits (DVD or mounted .ISO drive):

imagex /info F:\sources\install.wim

You’ll get a long output text where you’ll need to find the INDEX NUMBER you want to install. For instance INDEX=“1”

Then, just burn it!!!:

imagex /apply d:\sources\install.wim 1 W:

W:\ is in this case my mounted .VHD where I’m burning the Windows 8 bits.

Setting the .VHD Boot

Writing the boot sector and Master Boot Record

Once we have all the Windows 8 bits within the .VHD, we need it to be able to boot. In order to do so, we need to write a Windows 8 boot sector and the Master Boot Record. We perform this step with the BOOTSECT.EXE command tool. This tool is available within the folder \Boot in the Windows 8 setup bits, and the sub-folder related to our architecture (x86, x64, etc.). So, type:

bootsect /nt60 W: /mbr

Mark the boot partition as active

You can do this step using the Disk Manager, selecting the internal partition of our .VHD and right-clicking on it, then select “Mark partition as active”.

Another choice is doing the same step but using diskpart.exe and the “active” command.

AND THIS IS IT!!!

You could boot from this .VHD on any computer, like copying the .VHD and then using BCDEDIT in order to relate a boot option to this new .VHD. The first boot will be like a new configuration where you need to provide the computer name, and a few customization options.

(OPTIONAL) BOOTING FROM A .VHD WITHIN A USB-PEN (WINDOWS TO GO)

If you want to copy this .VHD and boot from a USB pen, then you also need to provide the boot information (BCD) using the tool BCDBOOT.EXE (available in %WINDIR%\System32), like the following:

bcdboot X:\Windows /s J:

Where W: is our drive for the physical USB-PEN and X: is the drive for the mounted .VHD disk copied into that USB-pen (mounted as a disk).

(OPTIONAL) CONFIGURING BOOT OPTIONS

You might want to change dual boot options, option string names, etc.

When you want to configure the boot options of windows you can use bcdedit.exe to modify the boot settings.

For instance, once you have booted in Windows 8 (any boot, you might have 2 'Windows 8' option strings... ;-)), you might want to change those boot options strings. In order to do so, start a CMD prompt and run bcdedit.exe (in \Windows\System32) to see the GUID of your boot options:

bcdedit /v

Remember/copy the GUID of your VHD installation and type the following line, of course, changing my 'xxxxxxxx' stuff to your GUID.

bcdedit /set {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} description "Windows 8 .VHD Image"

You can put the description you like, but the above line will change the description for your VHD installation boot option.

You can also change the order of the boot options typing the following:

bcdedit /displayorder {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} /addlast

---

Finally, once you have these kind of .VHD images, you can copy it and have as many BOOT options as you want.

The easiest way is to copy an originall boot menu option, like:

bcdedit /copy {Original_GUID_Number} /d "my new description"
or
bcdedit /copy {current} /d "my new description"
or
bcdedit /copy {default} /d "my new description"

Type again the following to see the new GUID for your new copied boot option:

bcdedit /v

Copy that GUID to a notepad or a paper...

After that, you must change the 2 pointers within the menu option, so they point to the new/right .VHD file:

bcdedit /set {My_new_GUID_Number} device vhd=[C:]\MyNewVMFile.vhd

bcdedit /set {My_new_GUID_Number} osdevice vhd=[C:]\MyNewVMFile.vhd

Entity Framework Code First DbContext and SQL Azure Connection Fault Handling

cesardl [MSFT] — Tue, 24 Apr 2012 19:06:00 GMT

I’ve been working migrating an App to Windows Azure and SQL Azure. This app is using Entity Framework 4.3 Code First and DbContext.

One important point is related to the SQL Azure Conection Fault Handling. If you don’t know about this topic, you can read this explanatory info:

http://social.technet.microsoft.com/wiki/contents/articles/1541.sql-azure-connection-management-en-us.aspx

Then, regarding a workaround when using Entity Framework 4.0 (based on ObjectContext), I wrote this post a few months ago:

http://blogs.msdn.com/b/cesardelatorre/archive/2010/12/20/handling-sql-azure-connections-issues-using-entity-framework-4-0.aspx

Also, this link, provided by the AppFabric Customer Advisory Team, is quite useful, too:

http://blogs.msdn.com/b/appfabriccat/archive/2010/12/11/sql-azure-and-entity-framework-connection-fault-handling.aspx

But, this info was all related to EF 4.0, ObjectContext, EF Templates (STE & POCO T4templates, etc.), not about EF 4.3, CODE FIRST APPROACH and DbContext.

Therefore, this post is about how to handle SQL Azure Connection Faults (something common in the Windows Azure platform) when using EF 4.3, DbContext and CODE FIRST APPROACH.

THE ISSUE:

If you take a look to the link provided by the AppFabric Customer Advisory Team, about the ‘Retry Policy’ when creating the EF Context. The tactic is to implement the OnContextCreated() partial method of your model context (based on ObjectContext) which is called each time a new context is instantiated. In this partial method, you employ a retry policy which opens a connection, submits a dummy query and handles exceptions with proper closure of invalid connections. In this way, the pool is ‘cleansed’ of all connections that have disconnected due to network glitches or idle expirations.

This was the initial suggested code for EF 4.0 and ObjectContext:

partial void OnContextCreated()
{
int MaxRetries = 10;
int DelayMS = 100;

    RetryPolicy policy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(MaxRetries, TimeSpan.FromMilliseconds(DelayMS));
    policy.ExecuteAction(() =>
    {
        try
        {
            string ss = Connection.ConnectionString;
            Connection.Open();
            var storeConnection = (SqlConnection)((EntityConnection)Connection).StoreConnection;
            new SqlCommand("declare @i int", storeConnection).ExecuteNonQuery();
            // throw new ApplicationException("Test only");
        }
        catch (Exception e)
        {
            Connection.Close();
            throw e;
        }
    }
    );
}

The issue is that this is based on the OnContextCreated() method which is related to your ObjectContext class.

When using CODE-FIRST approach, we use a context based on the DbContext, so we’ll have a slightly different code.

Instead of placing that code into the OnContextCreated() we can put it within the constructor of your model context (in this case based on DbContext).

Take into account that we’re using the RetryPolicy class, which is implemented in a special building block made by Microsoft Pattern & Practices team, called ‘Transient Fault Handling Application Block’ (good job Grigori & P&P team!).

It is available from NuGet: http://nuget.org/packages/EnterpriseLibrary.WindowsAzure.TransientFaultHandling

Exception from DbContext API: EntityConnection can only be constructed with a closed DbConnection

http://blogs.msdn.com/b/diego/archive/2012/01/26/exception-from-dbcontext-api-entityconnection-can-only-be-constructed-with-a-closed-dbconnection.aspx

It is a very nice explanatory information about that issue. In any case, the solution for that exception is to open the connection using the ObjectContext object instead of the DbConnection.

Instead of this line:

currentDbConn.Open(); //(Issue here!!)

We use this other line of code:

((IObjectContextAdapter)this).ObjectContext.Connection.Open();

Then, we’ll be able to run all the workaround within a DbContext constructor, like the final code below:

public class MyBCUnitOfWork
    : DbContext, IQueryableUnitOfWork
{
    //Constructor where we handle 'SQL Azure and Entity Framework Connection Fault Handling'
    public MyBCUnitOfWork()
        : base()
    {
        //SQL Azure and Entity Framework Connection Fault Handling
        //See: http://blogs.msdn.com/b/appfabriccat/archive/2010/12/11/sql-azure-and-entity-framework-connection-fault-handling.aspx?Redirected=true
        DbConnection currentDbConn = this.Database.Connection;

        int MaxRetries = 10;
        int DelayMS = 100;

        RetryPolicy policy = new RetryPolicy<SqlAzureTransientErrorDetectionStrategy>(MaxRetries, TimeSpan.FromMilliseconds(DelayMS));
        policy.ExecuteAction(() =>
        {
            try
            {
                //(CDLTLL) Using ObjectContext.Connection because there's an issue when using DbConnection.Open() here.
                //See this blog post from Diego Vega:
                //http://blogs.msdn.com/b/diego/archive/2012/01/26/exception-from-dbcontext-api-entityconnection-can-only-be-constructed-with-a-closed-dbconnection.aspx
                ((IObjectContextAdapter)this).ObjectContext.Connection.Open();

}

With that, we would have the ‘Retry Policy’ implemented when creating any DbContext object, so you employ a retry policy which opens a connection, submits a dummy query and handles exceptions with proper closure of invalid connections. In this way, the connection-pool is ‘cleansed’ of all connections that have disconnected due to network glitches, Sql Azure cluster-fail-over or idle expirations.

Domain Driven Design (DDD) & Visual Studio 11 Beta ALM, great fit!

cesardl [MSFT] — Fri, 06 Apr 2012 15:17:00 GMT

ALM

Domain Driven Design (DDD) is especially suitable for creating long-term LOB Apps, but usually, DDD is presented as a very patterns & architecture related subject (topics like Bounded-Contexts, Domain-Models, patterns like Repository, Aggregate, Value-Object, etc.), like we actually did in our ‘DDD Patterns Guidance with .NET’, but those are not, in fact, the most important topics when really applying DDD.

Domain Driven Design is much more than Architecture and Design Patterns. It implies a specific way of working for development teams and their relationship with Domain Experts, a good identification of Domain Model elements based on the Ubiquitous Language (specific vocabulary, terms, etc.) coming from the Domain Experts, stakeholders and users, for every Domain-Model we can have. All those topics are more related to the Application Life-cycle Management process (ALM).

DDD is a way to build apps, a way for the team, to work in projects. According to DDD, the project’s team should work in a specific way, should have direct communication with the Domain Experts (the customer or users, in many cases). The team should use an ‘Ubiquitous Language’ projected up to the the code itself (entity names, object names, etc.) which has to be the same language/terms used by the domain experts and users.

Whenever I say ‘Domain Expert’ (DDD terminology) I also mean, for most applications, ‘Customer’, ‘Stakeholder’, ‘Product Owner/Manager’ or even ‘User’.

The following diagram shows the typical DDD Application Life Cycle:

Like mentioned, because DDD requires a direct communication & collaboration between the Domain Experts (users) & the development team (and I mean direct communication flowing from the Domain Experts to the developers themselves, not through any ‘man-in-the-middle’ figure), we need to enable developers and domain experts to work together more closely.

In most development life cycles, the requirements and changes coming from the Domain Experts are often misunderstood caused by the differences between the lay vocabulary of the users (Ubiquitous Language of the Domain experts) and the technical vocabulary of the analysts and developers.

Additionally, as you can tell from the DDD Application Life Cycle diagram, DDD is complementary with most Agile methodologies, like SCRUM.

In DDD but also in most agile methodologies, we seek to address and accommodate change, we ‘embrace the change’ coming from the customer. But, the basic problem remains: Users & Domain-Experts must be able to express their requirements in a clear, concise and unambiguous manner that can be understood by the developers.

Including Domain-Experts & Customers in the Development workflow

A key part of successful application development is to listen to what Domain-Experts & customers say and to build what
they really want. To assist with understanding and documenting users’ requirements, Visual Studio 11
Beta provides Storyboarding tools. These tools enable the development team to discuss and visualize
requirements with users and to understand how users expect to use the application. The storyboard can be
saved to Microsoft SharePoint and linked to Visual Studio Team Foundation Server 11 Beta work items to
help provide context for the developers.

In DDD and in most Agile environments, developers must be able to quickly demonstrate the results of their labors and
obtain feedback from Domain Experts and users, again in a clear, concise, and unambiguous manner. Visual Studio 11 Beta
provides tools (like Feedback Manager Tool) that enable a stakeholder (like a Domain-Expert) to review the software and provide actionable feedback. The team can generate the appropriate tasks to deal with this feedback, plan for their implementation, and allocate the corresponding work to the appropriate members of the team. The feedback is stored in the Visual Studio Team Foundation Server 11 Beta database and is available to the developers who are responsible for incorporating any required changes.

Below is shown the working process and collaboration between the Domain-Experts (stake holders, users & customers) and the development team:

Gathering Domain-Experts requirements

The first step when getting the story from the Domain-Experts is gathering the requirements and explanations of the Domain. For that purpose it is very useful to have toolsets to visualize ideas and draw story-boards.

The Storyboarding Tool is an add-in for PowerPoint that enables a developer to work with a Domain-Expert in order to understand the business requirements and to plan how the application should function. With this tool, you can quickly mock-up a user interface and create animations that illustrate how the user expects to navigate through the application, show sample data, simulate events, and generally get a feel for what the user wants.

StoryBoarding Tool

The Domain-Experts and users simply use PowerPoint to view it.
The Storyboarding Tool provides a rich library of controls, but you can also create custom shapes, import them into the storyboard shape library, and share them with the rest of the team.

Gathering Domain-Experts and Customer Feedback

Your customers and end users are the reason that you build software. Therefore, obtaining their feedback, and feedback from the Domain-Experts, is critical to the success of the project. Visual Studio 11 Beta provides the Feedback Manager tool, which enables these key Domain-Experts and stakeholders to provide timely and actionable feedback to the development team. Actionable feedback includes not just text comments but also videos, screenshots, and audio annotations that help the user to highlight any specific issues. These items help the developer to understand the context in which the user was performing the actions when a problem occurred or a feature
was found to work incorrectly.

Using the Feedback Manager, the user can run the application and record the ways in which the application is used. The user can also take screenshots or record audio and video at any point, perhaps providing a running narrative of the tasks that he is performing.

The Feedback Manager records the user’s interactions with your application and logs keystrokes, mouse clicks, and
other events. When the user has finished the feedback session, clicking Submit saves the feedback information to
the Visual Studio Team Foundation Server 11 Beta database. The user also can provide a rating and comments for the application.

Managing the Life Cycle of long term Applications

Domain Driven Design is not suitable for any kind of applications. For instance, Data-Driven Apps, or static and short-term apps should not be built using DDD. It would be like building a bicycle using rocket science/technology. The DDD learning curve, patterns complexity, loosely-coupled components and and its carefully Domain oriented way of working wouldn’t make sense for simple and short-term apps.

On the other hand, DDD is suitable for long-term apps which have quite a lot of business logic, but, where its business logic is always evolving. Typical DDD apps have “ever-changing business rules”. And then, whenever we have an application where it is always changing and evolving, we will have many application versions to deploy during its life (possibly, during quite a few years). For this cases, a right Operations framework and life cycle management is critical.

DDD applications (or specific Bounded-Contexts) are typically a living asset, with a life cycle that spans the activities that represent the entire lifetime of the product, from identification of business requirements, through development, testing, deployment, support, and maintenance, right up to the eventual retirement of the application.

If we have many versions to deploy along the time (Typical DDD long-term apps), each time we deploy a newer version in the PRODUCTION environment, we are not only introducing new functionality, it is quite possible that we will be introducing new bugs to be detected and fixed. As the software is used, bugs are often discovered. So the toolset must provide facilities for recording issues, to enable the development team to resolve them, and to provide the operations staff with the information that they require to roll out the fixes. This interaction implies an inherent connection between the processes that the development team performs when it builds and maintains the software and those that the operations team uses to manage the software when it is deployed. Development and operations personnel must be able to collaborate effectively because there is potential for bottlenecks to occur that will lead to delays and inefficiency wherever handoffs between the two teams exist, especially when there is scope for miscommunication between them.

Development / Operations collaboration

Visual Studio 11 Beta helps to align development with operations into a seamless workflow, reducing the churn that can occur. For example, a common situation is that the operations team reports a bug in the live software that the development team is unable to reproduce outside the production environment. To help with situations such as this, Microsoft IntelliTrace has been extended to support the production environment. By using Visual Studio Team Foundation Server 11 Beta, the operations team can record and capture the sequence of events that caused the bug in the Production environment and to store the trace information, together with the appropriate production environmental data. The operations team can then hand this information, together with any other observations, to the development team for analysis and triage. Following an Agile approach, the project manager can subsequently create an appropriate work item and allocate it to a developer. This workflow helps to accelerate communications between the development and operations teams, ensuring that bugs are resolved and updated software is deployed in a timely manner.

IntelliTrace in production is an historical debugging tool that records the sequence of events that led to the unexpected behavior. The information that IntelliTrace captures includes diagnostic data, details of exceptions, the call stack, and a trace of where the code failed. The data that IntelliTrace captures can be stored and then replayed by a member of the development team by using Visual Studio 11 Beta. A developer with Visual Studio 11 Beta can use this information to debug the application as if it was running live on their development computer.

IntelliTrace in Production

Working Closely with Operations Personnel

Visual Studio provides a server monitoring solution for teams that use or want to adopt System Center Operations Manager (SCOM). Visual Studio can deploy a monitoring agent for ASP.NET applications running on a web server. This agent collects rich data about exceptions, performance issues, and other errors. Using the TFS Connector for SCOM, Operations staff can file these exceptions as work items in TFS and assign them to developers to investigate in order to improve and fix production web applications. Visual Studio and the TFS connector, in conjunction with SCOM, provide a real-time improvement feedback loop for server-based applications deployed in production, leading to continuous improvements and high quality.

Closing the loop with Operations Personnel, System Center Operations Manager (SCOM) and TFS

Summary

Domain Driven Design is not only related to architecture and design patterns. In order to really apply the DDD approach, it is fundamental to take care of the direct relationship between Domain Experts and the development team as well as the relationship between production operations and the development team. Visual Studio 11 provides useful tools for that.

Installing Windows 8 Release Preview on a .VHD file from a bootable USB-Pen

cesardl [MSFT] — Wed, 29 Feb 2012 19:12:00 GMT

** May 31st 2012 – UPDATE TO WINDOWS 8 RELEASE PREVIEW **

There are quite a few steps to do, so I’ll write it down for my records.

Specifically, I have installed the Windows 8 Release Preview on a on a Samsung Slate Series 7 Tablet, but on a .VHD with native Boot:

For more info about .VHD with Native Boot, see (Updated: May 31, 2012 Applies To: Windows 8):

http://technet.microsoft.com/library/hh825689.aspx

Requirements:

- You’ll need a USB keyboard plugged into your tablet.

- A USB-Pen with at least 8 Gb.

A.- INSTALLING THE OPERATING SYSTEM

STEP #1
Backup your data on your Series 7.

STEP #2
Update BIOS
(this step is optional – unsupported developer BIOS will resolve hardware button incorrect mapping when Windows 8 is installed.) Use at your own risk.
Download the last BIOS for the Series 7 Slate from the Samsung Support web site and install it following the provided procedure.

STEP #3 - Configure BIOS (do this even if you don't update the BIOS.)
Enter BIOS setup: Power off the PC. Power the system back on and at the same time, press the “HOME” hardware key on the bezel. Select “ENTER SETUP” (note: if you do not have a USB keyboard attached you can use the VOL+/VOL- keys to select, Rotation Lock button as “enter”, and both vol buttons at the same time to go back.)

- Select the ADVANCED menu option in the BIOS menu
- Change “Allow UEFI boot” to YES
- Save settings and exit.

STEP #3

Get the Windows 8 Release Preview bits (ISO image)

First of all, you need to get the bits. I want an .ISO image so I’ll burn it on an USB pen.

You can download the .ISO image from here: http://windows.microsoft.com/en-US/windows-8/iso

Then, having an empty USB pen (it will be formatted), just burn it on it. You can use the Microsoft Store USB/DVD Download Tool. Grab it from here:

http://www.microsoftstore.com/store/msstore/html/pbPage.Help_Win7_usbdvd_dwnTool#ms_help_topics_at4

Once installed, you run the tool and you’ll get a wizard where you specify the origin .ISO image and the destination bootable USB Pen:

So, ready to start the real process!.

STEP #4 - Booting the Windows 8 Release Preview from the USB-Pen

- Plug the bootable USB-Pen into the USB slot in your Tablet.

- Start the tablet, but almost instantly (after half a second), press on the small “HOME/WINDOWS” hardware key on the center of the tablet. This will show you the BOOT-MENU, so I can boot from the USB-Pen:

Again, in order to select the right option (USB DISK), if you do not have a USB keyboard attached you can use the VOL+/VOL- keys to move up/down on the Boot menu, and then select the option pressing the second small harware key on the right of the tablet (beside the ‘on’ key).

You will see a “Windows” word over the black background (no more the small fish of the Consumer Preview) when starting the Windows 8 setup:

Then, you’ll see the initial “Windows 8” setup Window:

STEP #5 – Creating a .VHD file drive from the Windows 8 setup process

Instead of installing Windows 8 on the plain hard-drive, we’re going to create .VHD file and then we’ll install Windows 8 on that .VHD file. The booting start will be native (no HyperV), having the same performance than installing it on the plain hard-drive, but it is a much cleaner way. When I get another version of Windows 8, I’ll install it on a different .VHD file. It is a nice, clean and great way to handle native Dual/multiple booting.

- Select keyboard and ‘time & currency’ preferences for the setup, and then press the ‘Next’ button. You’ll see a Windows 8 window with a single “Install now” button. Press on the ‘Install button’ button (This is a different way than when doing a similar setup procedure using Windows 7).

- Carry on with the typical screens (Product Key, License, etc.) until you get to the ‘Installation type’. Select ‘Custom Install’:

Go until the Drive selection screen.

- CAUTION: You’ll get to the Drive selection Window. Now, pay attention here.

DO NOT PICK AN EXISTING HARD DRIVE. As shown in this screenshot, instead hit SHIFT-F10 to get to a console command-prompt. We want to create and attach our VHD file and install Windows 8 to THAT instead!!.

- Now we finally get a Command prompt Windows where we’ll be able to create a native bootable .VHD file-drive. We’ll install Windows 8 on that .VHD file, afterwards.

- Explore de drives you can see from the command prompt (C:, D:, E:, etc.). When installing Windows, it usually creates several small initial partitions, therefore, when you do the following steps, you have to specify E:\ drive instead C:\ drive (At least, that is my case). If you try with C:\ and you get an error message saying something like "You don't have space enough". Try specifying E:\ drive, and check the partition where you are going to create the .VHD file.

- Run the Diskpart command-tool writing Diskpart.

- Now, we create the .vhd file. I’m going to create a 30GB expandable file. You can create it bigger or smaller.

Type: Create vdisk file=E:\Windows8.vhd maximum=30000 type=expandable

- Select the .vhd file so the Windows 8 setup is able to see it as a drive

Type: select vdisk file=E:\Windows8.vhd

- Attach this drive to the setup system:

Type: attach vdisk

and Finally get out of the DISKPART tool, too.

Type: exit (you will exit DISKPART)

- Finally get out of the command prompt, another ‘exit’:

Type: exit (you will leave the Windows Command-Prompt, but Do Not Reboot!!)

- We return now to the ‘Drive selection Window’.

- Press the ‘Refresh' button, and you’ll see our new .VHD drive!:

- Install Windows 8 on this attached .VHD. First you'll need to create a partition & format it, selecting the drive which is really our .VHD file, and then clicking on the "Drive Options (Advanced)". From tha tmenu you can create a partition within the .VHD file and format it, afterwards.

You might get an error/warning saying that your computer hardware might not support this disk, just ignore it and press ‘Next’..

-It will reboot, etc., and you got it!!!!

- When starting, I have now a native & multiple-Boot, for Windows 8 (Release Preview), Windows Consumer Preview and Windows 7, because I already did similar setup processes with older OS versions:

Remember, the great thing here is that even when we are starting Windows 8 from a .VHD file, it is booting in a native way, so performance will be good (graphics card, etc.). Starting like that, Windows 8 runs smoothly in this Samsun Tablet.

I have my native operating systems stored in just a few files, so my hard drive is kept clean, for the future (next versions, etc.).

Something like the following files:

There you have it, the first METRO screen of Windows 8 Release Preview:

Enjoy Windows 8 Release Preview!

B.- (OPTIONAL) CONFIGURING BOOT OPTIONS

You might want to change dual boot options, option string names, etc.

When you want to configure the boot options of windows you can use bcdedit.exe to modify the boot settings.

bcdedit /v

Remember/copy the GUID of your VHD installation and type the following line, of course, changing my 'xxxxxxxx' stuff to your GUID.

bcdedit /set {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} description "Windows 8 .VHD Image"

You can put the description you like, but the above line will change the description for your VHD installation boot option.

You can also change the order of the boot options typing the following:

bcdedit /displayorder {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} /addlast

---

Finally, once you have these kind of .VHD images, you can copy it and have as many BOOT options as you want.

The easiest way is to copy an originall boot menu option, like:

bcdedit /copy {Original_GUID_Number} /d "my new description"
or
bcdedit /copy {current} /d "my new description"
or
bcdedit /copy {default} /d "my new description"

Type again the following to see the new GUID for your new copied boot option:

bcdedit /v

Copy that GUID to a notepad or a paper...

After that, you must change the 2 pointers within the menu option, so they point to the new/right .VHD file:

bcdedit /set {My_new_GUID_Number} device vhd=[C:]\MyNewVMFile.vhd

bcdedit /set {My_new_GUID_Number} osdevice vhd=[C:]\MyNewVMFile.vhd

CQRS BUS and Windows Azure technologies

cesardl [MSFT] — Wed, 22 Feb 2012 17:17:00 GMT

CQRS has several internal patterns and objects types like Commands, CommandHandlers, Events, EventHandlers, and a few others. In the following diagram I show a basic diagram positioning those topics:

I am not going to explain CQRS philosophy here, as you can read about it in many posts from Greg Young, Udi Dahan, Martin Fowler, etc.

The only thing I want to highlight before going further is that CQRS is not a top-level architecture. On the other hand, it should be used only for certain scenarios/contexts, certain areas within a complex application: Only for selected BOUNDED-CONTEXTS (in DDD lingo).

The point is that this kind of pattern or approach provides (as a consequence) very high scalable applications; therefore, it fits great in Cloud-Computing platforms, like Windows Azure.

In this post I only want to focus about what Windows Azure technologies we could use for the CQRS Buses.

First of all, all the communications based on the CQRS Buses are asynchronous. The Bus could be implemented in many different ways. For a Proof of concept and having a single server, it could even be an In-Memory Bus. But, if we have a real and scalable system, we’d need a Bus implementation placed on a global position, accessible from any Front-End and Back-End server.

We put/send COMMANDS into the Bus from the Presentation Layer (if using a server UI, like ASP.NET MVC. If the UI is remote, like HTML5, Silverlight, WPF, etc., then, we’d probably have a Web-Service Layer in between, like WCF or REST Web-API). But, the important point here is that COMMANDS will be taken from a single point (COMMAND-HANDLER) and they will be processed only once (like process ‘RegisterAttendee’ COMMAND). It is something we order to our system, so it is an imperative verb.

In any case, for handling COMMANDS, we’d need any asynchronous system that will allow to process messages, and each message will be taken and processed just once. A Message-Queue system would be nice for this purpose. Talking about Windows Azure technologies, we could use Windows Azure Storage Queues, based on the Put message and Peek message functions.

On the other hand, EVENTS are generated when a COMMAND is already processed and persisted. It is done & finished, so all events’ names are past tense verbs, like ‘AttendeeRegistered’ EVENT. But, and here comes an important difference, EVENTS can be consumed from many systems in order to propagate changes. They can be processed by the EVENT-HANDLER, but also from other BOUNDED-CONTEXTS and event from external systems. Therefore, we could use a Publish/Subscription approach for this topic. Talking about Windows Azure technologies, we could use Windows Azure Service Bus.

Below is shown a more specific diagram where Windows Azure technologies are highlighted:

It seems clear that in order to have a publish/subscription approach (for EVENTS), we need the Windows Azure Service Bus. Regarding COMMANDS, we could use Windows Azure Storage Queues, but the Service Bus is also a possibility here, too.

A few months ago, before having the Windows Azure SDK 1.5, the Service Bus was not supporting message queues, but now, it supports persistent queues plus a richer set of functionality like integration with WCF communication stack, transactional behavior, a guaranteed first-in-first-out (FIFO) ordered delivery, publish and consume message batches, etc.

Additionally, the Windows Azure Service-Bus price is quite similar to the Windows Azure Storage Queues price.

In the following link you can see a detailed comparison between the Windows Azure Service-Bus and the Windows Azure Storage Queues, taking into account Capabilities, Capacity, Quotas, Management, Operations, Performance and Prices:

http://msdn.microsoft.com/en-us/library/hh767287(VS.103).aspx

Scoping CQRS and Event-Sourcing Guidance Project

cesardl [MSFT] — Fri, 13 Jan 2012 03:04:00 GMT

I am collaborating with the patterns & practices team. We are considering doing a guidance project on implementing systems using the Command & Query Responsibility Segregation (CQRS) approach. This is not going to be a framework or reusable components. We are positioning this project as a learning journey and envision providing an experience report that describes building a sample app (reference implementation) to showcase various CQRS and Event Sourcing (ES) concepts & techniques. We will include explanations of various trade-offs and architectural decisions made along the way. Of course, we will publish the reference implementation/sample app to complement the written guidance.

We are not into chasing elusive silver bullets. Our ultimate goal is produce practical guidance for real world development problems.

We are interested in your perspectives, your needs and your suggestions on what you’d like us to focus on.

Today we open the first round of public consultation with a questionnaire to help us direct our exploration. Depending on your feedback and related priorities we will produce an initial backlog which we will also invite the community to comment/vote on.

If you care about CQRS, ES, Domain-Driven Design and good design practices, please take part in this consultation process. Both real world experiences and the need to be successful with CQRS in the near future are valuable perspectives.

Panda Security releases a free Beta version of Panda Cloud Office Protection 6.0, in the Cloud, on Windows Azure!!

cesardl [MSFT] — Fri, 06 Jan 2012 15:41:00 GMT

I publish this information because I’ve been collaborating with them on migrating their backend anti-virus system to the Microsoft PaaS cloud which is Windows Azure. They have got many benefits on doing this, like elasticity, rapid scalability, and one of the most important things, they have reduced their costs and TCO a lot!.

It is a great Product for any kind of company (small or large) who would like to manage all their anti-virus in a consistent, monitorized and global way.

You can try this BETA version of Panda Cloud Office Protection 6.0 downloading it from here:

http://www.pandasecurity.com/homeusers/downloads/beta/managedprotection/

The following are the product characteristics:

Panda Cloud Office Protection is a security solution for PCs and servers based on the concept of Software as a Service (SaaS). Software as a Service lets companies focus on their core business, freeing them from the management tasks and operating costs associated with traditional security solutions.

It prevents companies from having to invest in additional hardware, maintenance personnel and other resources dedicated to anti-malware protection while achieving high level security, even in remote offices, with minimum resource consumption.

The Web-based administration console allows centralized management of computer protection anytime from anywhere through single-sign-on.

Panda Cloud Office Protection offers an innovative way to manage security, as it automates all maintenance tasks. This lets many small businesses forget about security management or outsource it quickly and easily with no impact on the user.

Panda Cloud Office Protection is complemented with periodic security audits benefiting from Panda’s exclusive Collective Intelligence Technologies.

We completed the Microsoft Architects Forum: Enterprise & ISVs Applications on Windows Azure (Barcelona Dec. 13th & Madrid Dec. 15th)

cesardl [MSFT] — Fri, 16 Dec 2011 13:27:00 GMT

It was a nice event exposing Windows Azure scenarios very oriented to ISVs, subjects like Multi-Tenancy, Security, Java apps on Windows Azure, etc. Additionally we had three companies (Panda-Security, Softeng and Grupo Teldat) talking about their real experience in their projects when migrating their products to Windows Azure, talking about optimizations, performance and scalability best practices.

Here I post the PRESENTATIONs we talked about (in Spanish):

https://skydrive.live.com/?cid=C537C2AF47F728A0&id=C537C2AF47F728A0%211027

And a few pictures of both occurrences of the event

Architects Forum in Madrid:

Architects Forum in Barcelona:

Alfonso Velasco, from Panda-Security, explaining their experiences and why they migrated their product backend from a hosting provider to Windows Azure:

Architects Forum: Enterprise & ISVs Applications on Windows Azure (Barcelona Dec. 13th & Madrid Dec. 15th)

cesardl [MSFT] — Sat, 03 Dec 2011 11:34:00 GMT

In December we’re going to deliver this free assistance event focusing on enterprise applications and architectures on Windows Azure, subjects like MULTi-TENANCY on windows Azure, and showing optimizations, scalability and load testing made by real Windows Azure customers like PANDA-SECURITY and SOFTENG.

This is the Agenda (SPANISH).

Hora	Descripción	Ponentes
9:30-10:00	Registro
10:00-10:15	Presentación del evento	César de la Torre Microsoft
10:15-11:00	Securización de aplicaciones en Windows Azure: Propagación de credenciales AD mediante ADFS 2.0 y Access-Control de Windows Azure	Plain Concepts
11:00-11:30	Café (Catering Microsoft)
11:30-12:55	Aplicaciones Multi-tenant (multi-organización) en Windows Azure	Cesar de la Torre & Luis Panzano Microsoft
13:00-13:55	Proyecto de despliegue de la Solución ‘ Panda Cloud Protection ' en Windows Azure y Pruebas de Carga realizadas con Visual Studio 2010 sobre Windows Azure .	Panda Security
14:00-15:25	Tiempo Comida
15:30-16:25	Desplegando Aplicaciones Java y Servidores de Aplicación no Microsoft, en Windows Azure	Ilitia
16:30-17:25	Optimizaciones de aplicaciones en Windows Azure (Cache, rendimiento, escalabilidad y latencia). - Caso real sobre la optimización de Softeng PortalBuilder en Windows Azure .	Softeng

You can register to the events in the following pages:

1.- Architects Forum: Enterprise Applications on Windows Azure (Barcelona Dec. 13th 2011)

https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032498149&Culture=es-ES

2.- Architects Forum: Enterprise Applications on Windows Azure (Madrid, Dec. 15th 2011)

https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032498152&Culture=es-ES

Creating an X.509 certificate for Windows Azure

cesardl [MSFT] — Tue, 29 Nov 2011 21:06:00 GMT

I always forget the command line to do this, so I’m going to post it in my own blog.

The way to set a specific certificate name, so you can find it within Windows Azure after it is registered, is using the Certificate Creation Tool (makecert.exe) to create an X.509 certificate:

- Open the Visual Studio Command Prompt window as an administrator.

- Change the directory to location where you want to save the certificate file.

- Type the following command:

makecert -sky exchange -r -n "CN=MyCertificateName" -pe -a sha1 -len 2048 -ss My "MyCertificateName.cer"

Where MyCertificateName is the name that you want to use for the certificate. It must have a .cer extension.

- After generating the .cer, you must install it into your machine if you want to use it for Windows Azure signing, etc.

To do so, it must be installed within the ‘Certificates (Local Computer) –> Personal –> Certificates.

You can do this using the Certificates Snap-in, you know, mmc.exe –> Add Snap-in –> Certificates –> Local Computer, etc.

After registering the certificate into your machine, you might want to export it (from the Certificates Snap-in) as .PFX, including the private key, setting a password, etc.. You might need this in order to install in into Windows Azure.

We completed the IASA-DDD Conference! (November 7th 2011)

cesardl [MSFT] — Wed, 09 Nov 2011 21:13:00 GMT

It was a remarkable DDD (Domain Driven Design) event in Madrid, Spain. We got around 150 attendees!!, and taking into account that this is the inaugural event from the IASA-Spain association, and this association was almost unknown in Spain, until now, it is something I must highlight. Of course, having the keynotes delivered by Eric Evans and Udi Dahan was fundamental for achieving that.

Most attendees gave such a good feedback about the sessions and specifically about the IASA-Spain initiative because we were talking about Architecture, Design, DDD, patterns, etc., no matter what technology you work with. In fact, there were sessions and attendees used to work on .NET platform but also sessions and people used to work on Java platform. Even the sponsors were companies very heterogeneous, like: Microsoft & Oracle, or Microsoft partners, and JavaHispano.com, etc. That is good for open debates about design and architecture and also for technology interoperability and especially to learn from each other experiences.

Here I post some data and pictures about the Conference.

There were registered attendees from all around Spain:

And even from all around the world!:

Eric Evans, Udi Dahan and me, handling the ‘Questions and Answers’ session (Q&A):

Eric Evans starting his great DDD Keynote:

Udi Dahan while speaking during his great CQRS keynote:

A view of the attendees, with Diego Vega (Entity Framework Product Group Program Manager in Microsoft Corp) taking notes on his laptop. There are many other familiar faces from companies like Wolters-Kluver, Panda-Security, Telefónica I+D, Repsol, MRW, Plain-Concepts, Sogeti, Indra, Fujitsu, Unisys, Kriter, Microsoft Iberica (Consulting Services, Premier Support and DPE), NTR, Avanade, Pasiona, Aventia-Renacimiento, Raona, and a long etc. with many more companies. There were also many people from the Java community, as well:

Diego Vega & Unai Zorrilla during our Session regarding Architecture Patterns and .NET, with special focus on Entity Framework 4.1 Code-First which facilitates the implementation of patterns like POCO Domain Entities, Repository pattern, UoW pattern, and allows to comply with principles like ‘Persistence Ignorant’, etc.:

Alfredo Casado during his session about ‘Implementing DDD Patterns on Java Platform’, using Hibernate and Spring.

Enrique Martin Casado, from Oracle, while speaking during his session (Approach about implementing CQRS based on Oracle Service Bus and Oracle Coherence Cache):

Interview to Udi Dahan, Eric Evans and Diego Vega, for the Dnm Magazine (technical magazine):

CQRS WORKSHOP, by Udi Dahan (Next day, on November 8th 2011). This Workshop (a full day with Udi Dahan) got about 22 attendees:

Final picture (the day after the Workshops, Nov. 8th) with some speakers and several collaborators. Starting from the right: Diego Vega (Program Manager from the Entity Framework Product Group, Microsoft Corp), Eric Evans, Udi Dahan, Javier Calvarro (Microsoft Developer), Myself (César de la Torre, Microsoft), Unai Zorrilla (Plain Concepts) and Pierre Millet (Microsoft Consulting Services).

Tomorrow (Nov. 10th) we’ll deliver the last WORKSHOP, a DDD WORKSHOP by Eric Evans. I’ll probably update this post with some info about tomorrow.

It’s been a great experience, and I really appreciate Eric Evans, Udi Dahan and Diego Vega coming to Madrid and helping us to deliver such a great event-sessions and Workshops.We really enjoyed all this week with them and all the attendees, of course!.

You can download the presentations from here:

https://skydrive.live.com/?cid=7B0099B3E1CF634F&id=7B0099B3E1CF634F%21172

How to explore a Windows Azure Package (How to create it with no encryption)

cesardl [MSFT] — Wed, 05 Oct 2011 08:21:00 GMT

As you may know, a Windows Azure package is a .ZIP file, but, it is encrypted, so, even though you can rename the extension, when you take a look into it, you cannot really see the project files.

In order to see it, you need to create a package which is not encrypted. You can do so setting a System Variable (in the Properties menu within ‘My Computer’):
_CSPACK_FORCE_NOENCRYPT_ with value set to true

Eric Evans and Udi Dahan in Madrid! (DDD Conference and Workshops, Nov.2011)

cesardl [MSFT] — Tue, 20 Sep 2011 10:40:41 GMT

Eric Evans and Udi Dahan in IASA DDD (Domain Driven Design) Conference and Workshops!!! (Nov.2011).

This is a unique opportunity. On November 7th, there will be an initial conference (free registration) introducing DDD & CQRS, and then, during next days (Nov. 8th and Nov.10th), there will be several workshops run by Eric Evans and Udi Dahan, having deeper content during a whole day.

- DDD Conference (Nov. 7th 2011) - (Free registration): http://dddiasaconference.eventbrite.com/

IASA-SPAIN-MEMBERS have a 50% off discount on Workshops!!!:

- DDD Workshop (Nov. 8th 2011) - A whole day with Eric Evans and DDD deeper content - (Registration under fee): http://dddworkshopee.eventbrite.com/

- CQRS Workshop (Nov. 8th 2011) - A whole day with Udi Dahan and CQRS deeper content - (Registration under fee): http://cqrsworkshopud.eventbrite.com/

- DDD Workshop (Nov. 10th 2011) - 2nd occurrence, same content as DDD workshop on Nov.8th - (Registration under fee): http://dddworkshopee2.eventbrite.com/

HELP?: For any question or help during the registration process, contact to iasaspain@iasaglobal.org

SPONSORSHIP?: If you would like to sponsor this event, please contact to cesardl@iasaglobal.org for details.

Global Landing page: http://www.iasaglobal.org/iasa/Spain_Chapter.asp?SnID=1327701029

EF 4.1.1 RTM (Update) and Code First Migrations August 2011 CTP Released

cesardl [MSFT] — Sat, 30 Jul 2011 17:40:14 GMT

EF 4.1 Update 1 (EF 4.1.1) has been released a few days ago.

http://blogs.msdn.com/b/adonet/archive/2011/07/25/ef-4-1-update-1-released.aspx

The important point is also EF 4.1.1 Code First Migrations August
2011 CTP Released:

http://blogs.msdn.com/b/adonet/archive/2011/07/27/code-first-migrations-august-2011-ctp-released.aspx

This is really important for people working with Code-First because it allows
to change your Entity Model and then upgrade your database instead of having to
re-create the database from scratch.

Even though EF Code-First Migrations is still a CTP, it is something just for your development time, it won't impact to your production code dependencies which are RTM dlls/assemblies (EF 4.1.1).

EF 4.1.1 (Update) is a release version (RTM).

Cesar.

Value-Object pattern implementation in .NET

cesardl [MSFT] — Wed, 20 Jul 2011 22:37:00 GMT

Regarding DDD patterns, here I link two nice Value-Object implementation samples:

http://elegantcode.com/2009/06/07/generic-value-object/

http://grabbagoft.blogspot.com/2007/06/generic-value-object-equality.html

About Ayende’s blog posts series reviewing the NLayered Sample-App

cesardl [MSFT] — Wed, 20 Jul 2011 22:14:00 GMT

Ayende has been publishing a series of blog posts reviewing the V1.0 of the NLayerApp Sample App (Note we made V2.0 public a few weeks ago, so most of the code issues he highlights do not apply now).

We’ve been taken into account every of those posts as well as every comment from the community in his blog. Some comments to Ayende’s posts were also good points to think about.

First of all, we are thankful to Ayende and anyone who provides feedback in order to improve our initiative (SampleApp & Guidance) for the community and we will always take into account any comment and feedback.

Second, this is a local initiative gathering experiences from projects, mostly from the Spain community with the collaboration of MVPs, local Microsoft people and some partners. This is not a Microsoft Corp initiative.

Regarding the specific posts that Ayende has been publishing about the NLayerApp V1.0, while we don’t agree on some of the global opinions about what a sample app should be, we acknowledge on some of the improvable code he pointed out, and the points we agree that were issues, were fixed in V2.0 before Ayende published his series. There are also a few other points where we don’t agree, like the size of the SampleApp where we want to show simple and isolated scenarios that anybody can understand (Orders, Customers, simplified Bank Transfers, etc.) showing typical pattern implementations using Entity Framework 4.1 Code-First, or the post about the ‘Query Specification Pattern’ where we think it is useful for many scenarios, like composite queries.

Here you can see a few threads where we explained the modifications because of Ayende’s feedback:

DI & WCF (INSTANCE PROVIDER):

http://microsoftnlayerapp.codeplex.com/discussions/263833

LOGGING

http://microsoftnlayerapp.codeplex.com/discussions/263763

WCF & Exception Handling Improvements for V2.0

http://microsoftnlayerapp.codeplex.com/discussions/264445

Again, we want to highlight that we are thankful to Ayende and we acknowledge that anyone can always improve his code. Therefore, his critics are positive for the community and to this project because he helped us to improve some areas of code in our sample application.

Finally, we’d like to say that this sample app is only a reference for several patterns explained in this guidance you can download and review (Currently draft chapters). Anyone should review it jointly (Guide+SampleApp):

http://microsoftnlayerapp.codeplex.com/releases/view/69008#DownloadId=253553

We will appreciate any constructive and specific feedback you can provide and we will take it into account.

Cesar de la Torre

Microsoft Spain

Published first ALPHA version of Domain Oriented N-Layered Architecture V2.0

cesardl [MSFT] — Sun, 03 Jul 2011 14:34:00 GMT

New! First V2.0 ALPHA version at CODEPLEX and preliminary chapters’ drafts of eBook (Second Edition)

Dear colleagues, after some time of effort, we can show you our preliminary version (alpha version, actually) of what V2.0 will be. We are initially covering mostly ‘the server-core’, with a single client app consuming it (Silverlight), and evolving and taking into account many experiences we got and learned also with you. We got a lot of feedback coming from our Discussions-Forum at Codeplex, and many other channels. Many of you have already used this project as a reference and have applied it into real & complex projects, with success in most of the cases, and this is the best reward we could get!. But also, we got many points we could improve. Any constructive feedback is important and will be taken into account. We’ll continue working and evolving it in order to get better patterns’ implementations, along with you.

Improvements in the Domain Layer
- Using EF 4.1 POCO Code-First approach for Domain Entities/Aggregates/ValueObjects
- Added more Domain logic within entities (no anemic domain)
- Better exposure of Aggregates’ elements
- Better support to navigations between Aggregates and elimination of inverse relationships not needed
- Entity Validation support
- Specification pattern implementation, use of expressions as specifications and composition support

Improvements in the Application Layer
- DTO and DTO-Adapters support
- Validation support
- Improvements in exception management

Improvements in the Data-Persistence-Infrastructure Layer
- Using EF 4.1, CodeFirst, DbContext
- Persistence layer simplification and improvements
- IoC/Unity: Elimination of abstractions no needed
- Better testing strategy for Integration Tests

Improvements in the Presentation Layer
- Reviewed and minor improvements in MVVM code

Improvements in the Distributed-Services Layer
- Segregation in 2 Web-Services (One per MODULE).

- Improvements regarding WCF exceptions handling (less spread code in Catch)
- We currently use SOAP Web-Services, but we will switch to REST in the coming future when the new WCF Web API (WebApi.all) (still in beta) will support Silverlight.

Here you can get preliminary main DRAFT chapters for V2.0 (Second Edition) currently being reviewed, not finished.
http://microsoftnlayerapp.codeplex.com/releases/view/69008#DownloadId=253553
You can also download the first edition of the Arch-Guide eBook (free), but take into account that it is related to V1.0 of this project.
http://http://msdn.microsoft.com/es-es/architecture/en/

I would also like to remind the following (Project Scope and main Goals and what we are not covering):

Project Scope

This project/sample is willfully restricted to .NET implementation of most used patterns in N-Layered Domain Oriented Architectures based on simple scenarios easy to understand (Customers, Orders, Bank Transfers, etc.). This initiative is NOT trying to teach how to apply DDD. That shouldn't be Microsoft's goal and DDD is much more than Architecture & patterns implementation.
This is an Educational example, not a real world system, it shows educational scenarios, easy to understand useful from a patterns implementation point of view, but not necessarily as a whole business application. The architecture is decoupled and relatively complex so it would allow to grow your system.
Also, this sample goes along with our Architecture Guidance, and there are aspects in the guidance that are not covered by this sample, and viceversa.
Its main goal is to show how to use .NET 4.0 wave technologies implementing typical DDD patterns: N-Layered Architecture, Domain Entities, Aggregates, Repositories, Unit of Work, Domain Services, Application Services, DTOs, DTO-Adapters, etc.

Reminding what DDD is and what this project is NOT covering

Domain Driven Design is much more than Architecture and Design Patterns. It implies a specific way of working for development teams and their relationship with Domain experts, a good identification of Domain Model elements (Aggregates/Entity Model, etc.) based on the Ubiquitous Language for every Model we can have, identification of Bounded-Contexts related to models, and a long etcetera related to the application life cycle that we are not covering (only very slightly in our Guidance). There were already excellent literature and knowledge about that before this project was started, coming from people like Eric Evans, Martin Fowler, Udi Dahan, Greg Young, etc.
Our guidance and sample application focuses only on about a 20% of DDD subjects, we do NOT intend to teach DDD as a whole", we are only filling a gap we saw regarding implementing most useful Domain Oriented design patterns with the latest version of .NET.
And remember that we need you; we need your constructive feedback to evolve and improve this project.
Thank you very much.

Feedback and Improvements

Remember that this is a very early version (ALPHA and preliminary eBook Guidance drafts). We are, in fact, getting quite a lot of feedback and therefore refactoring many points & code that we acknowledge are improvable. But you can actually get the essence of our approach.

We’d really appreciate any constructive feedback in order to improve our current arch-guidance and sample-app.

See feedback from the community who have used this Guidance (V1.0) since many months ago:

http://microsoftnlayerapp.codeplex.com/discussions/229559
http://microsoftnlayerapp.codeplex.com/releases/view/56660#ReviewsAnchor
http://microsoftnlayerapp.codeplex.com/releases/view/49514#ReviewsAnchor

DDD-Exchange 2011

cesardl [MSFT] — Mon, 13 Jun 2011 09:23:00 GMT

So, it was such a great event with Eric Evans, Udi Dahan and Greg Young.

Here I post a few pictures I got.

Before starting:

Eric Evans presenting the Agenda:

Q&A to Eric, Udi and Greg:

Saying hello to Udi:

Strong discussions below…

All in all, I really liked all the sessions, check it out here:

http://skillsmatter.com/event/design-architecture/ddd-exchange-2011/js-2046

Working with WCF RIA Services JSON endpoints for HTML5, JavaScript & JQuery

cesardl [MSFT] — Tue, 07 Jun 2011 11:25:13 GMT

WCF RIA Services and JSON endpoints

Interesting posts about the base for many future apps based on HTML5, WCF RIA Services JSON endpoints and JavaScript :

http://blogs.msdn.com/b/davrous/archive/2010/12/14/how-to-open-a-wcf-ria-services-application-to-other-type-of-clients-the-json-endpoint-4-5.aspx

http://www.yumasoft.com/node/108

http://joseph-connolly.com/blog/post/WCF-RIA-Services-jQuery-and-JSON-endpoint-Part-1.aspx

Developer & Design Tools will evolve to simplify and give much more productivity, but this is the technical base for many future Internet scenarios.

MVVM pattern and JQuery, JSON and JavaScript

Regarding architecture and design patterns, a MVVM seems interesting when consuming REST Web-Services from JavaScript and Jquery. Here I have several options and posts:

http://kaboom.codeplex.com/

http://blogs.claritycon.com/blog/2011/02/20/mvvm-databinding-javascript-with-knockout-html5-boilerplate/

http://channel9.msdn.com/Events/MIX/MIX11/FRM08

http://weblogs.asp.net/scottgu/archive/2010/05/07/jquery-templates-and-data-linking-and-microsoft-contributing-to-jquery.aspx

http://stackoverflow.com/questions/6089727/how-to-architecture-a-webapp-using-jquery-mobile-and-knockoutjs

I still have to test this stuff out… We’ll see…

On the other hand, WCF RIA Services & Silverlight is still the best choice for LOB apps (Enterprise apps, Line Of Business Apps), especially ‘Out of the Browser’ (Windows). VS.LightSwitch is another RAD tool being released this summer of 2011, and it bets on Silverlight.

Implementing a Value-Object Base class (Supertype pattern–DDD patterns related)

cesardl [MSFT] — Mon, 06 Jun 2011 22:22:00 GMT

It is usually a recommended practice to have Value-Object base-class so we can have common functionality which can be used by all of our value-object classes. Typically, comparison methods or any other common subject for Value-Objects, should be included here.

Below I show a sample Value-Object Base-Class:

public class ValueObject<TValueObject> : IEquatable<TValueObject>
    where TValueObject : ValueObject<TValueObject>
{

    
public bool Equals(TValueObject other)
{
    if ((object)other == null)
        return false;
 
    //compare all public properties
    PropertyInfo[] publicProperties = this.GetType().GetProperties();
 
    if ((object)publicProperties != null
        &&
        publicProperties.Any())
    {
        bool result = true;
        foreach (var item in publicProperties)
        {
            //compare two values using default equatable method
            if (!item.GetValue(this, null).Equals(item.GetValue(other, null)))
            {
                result = false;
                break;
            }
        }
 
        return result;
    }
    else
        return true;
}
 
public override bool Equals(object obj)
{
    if ((object)obj == null)
        return false;
 
    ValueObject<TValueObject> item = obj as ValueObject<TValueObject>;
 
    if ((object)item != null)
        return Equals((TValueObject)item);
    else
        return false;
 
}
 
public override int GetHashCode()
{
    int hashCode = 31;
    bool changeMultiplier = false;
    int index = 1;
 
    //compare all public properties
    PropertyInfo[] publicProperties = this.GetType().GetProperties();
 
    if ((object)publicProperties != null
        &&
        publicProperties.Any())
    {
        foreach (var item in publicProperties)
        {
            object value = item.GetValue(this, null);
 
            if ((object)value != null)
            {
 
                hashCode = hashCode * ((changeMultiplier) ? 59 : 114) + value.GetHashCode();
 
                changeMultiplier = !changeMultiplier;
            }
            else
                hashCode = hashCode ^ (index * 13);//only for support {"a",null,null,"a"} <> {null,"a","a",null}
        }
    }
 
    return hashCode;
}
 
public static bool operator ==(ValueObject<TValueObject> x, ValueObject<TValueObject> y)
{
    // If both are null, or both are same instance, return true.
    if (System.Object.ReferenceEquals(x, y))
    {
        return true;
    }
 
    // If one is null, but not both, return false.
    if (((object)x == null) || ((object)y == null))
    {
        return false;
    }
 
    // Return true if the fields match:
 
    return x.Equals(y);
 
}
 
public static bool operator !=(ValueObject<TValueObject> x, ValueObject<TValueObject> y)
{
    return !(x == y);
}
}

Don’t like EF 4.1 ‘Data Annotations’ for DDD Architectures implementation –’Fluent API’ fits better for that!

cesardl [MSFT] — Fri, 27 May 2011 16:47:00 GMT

I write this post in order to get some feedback regarding what I currently think about EF 4.1 Data Annotations and how it fits in DDD Architectural styles.

About DDD Architectural styles, here it is our Architecture Guide (Though we are actually writing its second edition, adding EF 4.1 Code-First approach). But most DDD Architectural concepts and patterns are exposed there:

http://msdn.microsoft.com/es-es/architecture/en/

The subject I want to toss about is the following:

In DDD architecture designs we must isolate our Domain Model Layer and therefore, our Domain Entities from any other layer, especially from infrastructure layers, like Data Persistence layers where we have the selected data technology (like EF or NHibernate, etc.). Even more, our Domain Classes (Entities, Value-Objects, Domain Services, etc.) should comply the PERSISTENCE IGNORANCE PRINCIPLE. This is why POCO Entities are the right choice for DDD.

Ok, then here we come with EF 4.1 CODE-FIRST approach, which is great for POCO Domain entities and fits great within DDD Architectural styles. Cool!

If you deep-dive a bit into EF 4.1 CODE-FIRST, you’ll see that the initial way to make the mappings from your POCO Domain Entities classes towards your final database tables is based on conventions. Ok, that is nice, but then, if those conventions are not ok for you (because you need to adjust to an existing database or whatever), then you need to customize those conventions. You can do that either in two ways:

- Data Annotations. For any of you that might not know what is EF 4.1 ‘Data Annotations’, here you have a link:

http://msdn.microsoft.com/en-us/data/gg193958

- Fluent API. Regarding EF 4.1 ‘Data Annotations’, here you have another link:

http://msdn.microsoft.com/en-us/data/gg194005

What I think is the following:

‘Data Annotations’ might initially look very appealing and easy to use when decorating our classes with attributes, but, on the other hand, and from a POCO point of view, it is a bit intrusive on our Domain entities, as we need to write specific attributes which are links to a specific persistence infrastructure, like EF 4.1. Even when most EF ‘Data Annotation’ attributes are defined within the ‘System.ComponentModel.DataAnnotations’ namespace which is part of the .NET Framework, still it is a bit intrusive on our Domain Entities.

On the other hand, using ‘Default Conventions’ or customizing it with ‘Fluent API’ is a way that fits much better with the PI (Persistence Ignorant), because our Domain Model will be ignorant of those mappings which will be defined into our Data Persistence Infrastructure layer, so, our Domain Model Layer will be better isolated from infrastructure implementation.

Therefore, if you are starting your project from scratch, the best way to go would probably be this: “Base your entity classes on default conventions, as much as you can”, because then your POCO domain entities will be cleaner, pure POCO!. Additionally, using ‘Fluent API’ would be transparent towards your Domain Entity Classes and you won’t stain your POCO Domain Entities, either.

We should make use of the Code First ‘Fluent API’ in order to change/customize our entity mappings, however, it must be written overriding DbContext methods (within our EF Context class). Specifically, we must override the ‘DbContext OnModelCreating()’ method. Therefore, that is part of the Data Persistence Infrastructure Layer, so we won’t be messing on our POCO Domain Entities.

Thoughts?, Comments?

Just Published the English version of our 'DDD N-Layered .NET 4.0 Architecture Guide’ book and Sample-App at CODEPLEX

cesardl [MSFT] — Mon, 23 May 2011 14:56:49 GMT

We just published the English version of our 'DDD N-Layered .NET 4.0 Architecture Guide’ book (at MSDN).

The ‘landing page’ where you can download the free eBook in several formats like .PDF, .XPS and for eBook Readers (.EPUB, .MOBI) is the following:

http://msdn.microsoft.com/es-es/architecture/en/

This special post is dedicated to let you know that we recently published at MSDN the new DDD .NET 4.0 Architecture Guide/Book (First Edition in English), available as eBook (.PDF, .EPUB and .MOBI) which follows Domain Driven Design Architectural style and trends. We also provide an end-to-end sample application (at CODEPLEX) where you can check every .NET code aspect. We were working on it during 2010 and published the same guidance in Spanish in late 2010. Since its first publication we got really good feedback you can check below and at our CODEPLEX site.

Microsoft has noticed, in multiple customers and partners, the need to have a “.NET Base Architecture Guide” that can serve as an outline for designing and implementing complex and mission critical enterprise .NET applications with long term life and long evolution (DDD target apps). This frame of common work defines a clear path to the design and implementation of business applications of great importance with a considerable volume of business logic. Following these guidelines offers important benefits regarding quality, stability, and especially, an improvement of future maintenance of the application, due to the loose-coupling between components, homogeneity, and similarities of the different developments that will be done based on these guidelines.

This Architecture Guidance has also been reviewed by the Microsoft Entity Framework Product Group (Microsoft Corp) because EF is a core component of the technology it uses.

It is also available as a regular printed book, in English or Spanish, from Krasis Press:

Sample Application

We elaborated a sample application as a needed companion for this Architecture guidance, so anyone can check every pattern implementation in a working and end to end example. This sample app is published as OPEN SOURCE CODE at the following CODEPLEX site:

http://microsoftnlayerapp.codeplex.com/

Related technologies

The guidance implements typical DDD patterns (Domain Entities, Repositories, Aggregates, Unit of Work, Value Object, Domain & Application Services, etc.) and IoC/DI techniques, using the following technologies:

Visual Studio 2010 y .NET 4.0
Entity Framework 4.0
UNITY 2.0
WCF
Silverlight 4.0
WPF 4.0
ASP.NET MVC
PEX&MOLES
Windows Server AppFabric Hosting & Cache (Optional)
Windows Azure (Optional)
SQL Server
SQL Azure (Optional)

Feedback

The following are a few comments and feedback gathered from our CODEPLEX site:

(5*)
Brilliant. The best fully developed example available. The documentation will become my architecture bible
by TimCromarty on May 14 at 12:16 AM

(5*)
This is by far the best DDD guide and sample project around.
by Cyberdude3 on Apr 11 at 3:25 PM

(5*)
The best online project about DDD...
by alen_ekt18 on Apr 2 at 12:41 AM

(5*)
Oh my god Really The English book that goes with this release is so awesome. It’s the best technical document with guidelines that I read by FAR Looking forward to see it being finished! Keep up this excellent work please Can't use enough superlatives Best Regards, Tom
by buckley on Mar 30 at 11:34 AM

(5*)
I just started reading the English version of the documentation. It is awesome. The authors injected much practical knowledge and insights into the abstract topics of application architecture. If you have read Evans and Fowler, the documentation will help you really put all the theoretical ideas together in more tangible ways than I have seen any literature to date. Great work.
by liberty2k on Mar 10 at 9:06 PM

(5*)
Very sophisticated and well thought out. Will be using this to compare to our architecture which is very similar using DDD, Repository Pattern, Linq, Unity and Entity Framework. Can't wait to get the full English translation.
by ben555 on Feb 25 at 12:28 AM

(5*)
Creo que este proyecto ¡es una joya! Ya lo estoy aplicando en soluciones a problemas reales y me ha dado preciosas y buenas sorpresas de buen funcionamiento. Me parece que es admirable el trabajo desarrollado para los repositorios genéricos con LINQ, especificaciones y filtros. Gracias nuevamente a César y al equipo todo.
by asereware on Feb 5 at 7:57 AM

(5*)
Most impressive .Net project ever seen. Keep up the (awesome) good work!
by NicoJuicy on Feb 2 at 1:24 AM

You can check more feedback and ratings, at our CODEPLEX site:

http://microsoftnlayerapp.codeplex.com/discussions/229559

http://microsoftnlayerapp.codeplex.com/releases/view/56660#ReviewsAnchor

Future steps

This guidance is a living Project so it will continue evolving the Guide and Sample App. Specifically we are already working on the following new features:

- EF 4.1 evolution (POCO Code-First Entities)

- Claims-based Security implementation on the sample application (The Guide already covers it)

- New Client technologies (Windows Phone 7, HTML5, etc.)

We hope this work might be useful for many organizations and we encourage you to provide feed-back and new ideas using our discussions-forum at CODEPLEX.

César de la Torre Llorente
Architect, DPE
Microsoft

http://blogs.msdn.com/cesardelatorre/

http://msdn.microsoft.com/es-es/architecture/en/

Workshop VS.Lightswitch & Windows Azure!

cesardl [MSFT] — Tue, 26 Apr 2011 11:18:00 GMT

[UPDATED June 7th] Here I add a nice LightSiwtch Sample Application:

http://blogs.msdn.com/b/bethmassi/archive/2011/05/25/contoso-construction-lightswitch-advanced-development-sample.aspx

[UPDATED May 11th 2011]

Here I attach the presentation we delivered in this Workshop.

---

On May 5th, joining forces with Avanade, we’ll deliver the following Workshop in Microsoft Office (Madrid):

Maximum productivity and 'Time-To-Market' using the new Microsoft RAD VS.LightSwitch and Windows Azure.

This environment is especially made for small & departmental apps. Non complex scenarios for very simple & small apps.

The event will be delivered in SPANISH.

You can register here (Free registration):

https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032480432&Culture=es-ES