InitializeComponent();

Windows 7 Phone Hardware

2010-10-11T10:24:00.001-04:00

MSDN Channel 9 has posted a First Look video.

Phones are from Dell, LG, HTC and Samsung.

Download the Development tools.

A Repository-like façade for Entity Framework – Part II

2010-09-12T09:35:00.001-04:00

This is the second post in this series.

Part 1

The first thing we need to do to enable using our POCOs with EF 4.0 is to decide how we want to handle change tracking and lazy loading of our child collections.

For now, let’s take full advantage of EF’s capabilities and allow it to generate the proxies for lazy loading and full change tracking.

To do this, there are four requirements:

Each POCO must have an empty default constructor.
Each property of the POCO must be declared virtual.
The child collection properties must be of type ICollection<T>.
New POCO objects must be instantiated with ObjectContext.CreateObject<T>.

Since List<T> is an implementation of ICollection<T>, we can keep it for our collection, but we need to mark all the properties as virtual. Here are our entities:

using System.Collections.Generic;

namespace Entities.School
{
    public class Department
    {
        public virtual long Id { get; set; }

        public virtual string Name { get; set; }

        public virtual List<Course> Courses { get; set; }
    }

    public class Course
    {
        public virtual long Id { get; set; }

        public virtual string Name { get; set; }

        public virtual Department Department { set; get; }
    }
}

Note that I have removed the code that kept the Department.Courses collection in sync, when the Course.Department is set. I had hoped that the proxy behavior would replace this “default” behavior, but it looks like from my testing that the proxy synchronization takes place, followed by the “base” behavior. This resulted in two entries being made in the Courses collection each time a Course was assigned to the Department. I removed the base behavior, which means that if the in-memory repository is used, the client code will need to synchronize the collection.

Next, we create the model. Right-click on the model canvas and select Generate Database from Model. This will create the DDL script to create the tables.

Next, blank out the Custom Tool property on the file properties for the EDMX file. This way, no code will be generated for your model. This means we need to write our own ObjectContext class. Many authors recommend creating strongly-type properties for exposing each ObjectSet (Departments, Courses). You can do that, but it isn’t very useful for our Repository interface. Rather, we will create Query<T> and SetOf<T> methods to return the appropriately typed IQueryable and ObjectSet, respectively.

using System;
using System.Collections.Generic;
using System.Data.Objects;
using System.Linq;

namespace Model
{
    public class PocoContext : ObjectContext
    {
        public PocoContext(string connectString)
        : base(connectString)
        {
            ContextOptions.LazyLoadingEnabled = true;
        }

        Dictionary<Type, ObjectQuery> roots = new Dictionary<Type, ObjectQuery>();

        public ObjectSet<T> SetOf<T>() where T : class
        {
            ObjectQuery root;
            if (!roots.TryGetValue(typeof(T), out root))
            {
                var set = CreateObjectSet<T>();
                roots[typeof(T)] = set;
                return set;
            }

            return (ObjectSet<T>)root;
        }

        public IQueryable<T> Query<T>() where T : class
        {
            return (IQueryable<T>)SetOf<T>();
        }
    }
}

Finally, we create our Repository implementation.

using System.Linq;

namespace Model.School.Model2
{
    using Interfaces;

    public class SchoolRespository : BaseRepository
    {
        private PocoContext context;

        public SchoolRespository(string connectString = "name=Model2Container")
        {
            context = new PocoContext(connectString);
        }

        public override IQueryable<T> Query<T>()
        {
            return context.Query<T>();
        }

        public override T New<T>()
        {
            return context.CreateObject<T>();
        }

        public override void SetNext<T>(T obj)
        {
            // no need for this with SQL Server auto-numbering
        }

        public override void Add<T>(T obj)
        {
            context.SetOf<T>().AddObject(obj);
        }

        public override void Remove<T>(T obj)
        {
            context.SetOf<T>().DeleteObject(obj);
        }

        public override void Commit()
        {
            context.SaveChanges();
        }
    }
}

Here is a test that shows how to use the SchoolRepository that we have created.

        [TestMethod]
        public void Test_SchoolRepository()
        {
            IRepository repo = new SchoolRespository();

            var count = repo.Query<Department>().Count();

            try
            {
                var math = repo.CreateNext<Department>(d =>
                {
                    d.Name = "Mathematics";
                });

                var algebra = repo.CreateNext<Course>(c =>
                {
                    c.Name = "Algebra";
                    c.Department = math;
                });

                repo.Commit();

                repo = new SchoolRespository();
                var course = (from c in repo.Query<Course>()
                              where c.Name == "Algebra"
                              select c).First();
                Assert.IsNotNull(course);
                Assert.IsTrue(course.Department.Id == math.Id);

                var dept = (from d in repo.Query<Department>()
                            where d.Name == "Mathematics"
                            select d).First();
                Assert.IsTrue(dept.Courses.Count == 1);
                Assert.IsTrue(dept.Courses[0] == course);

            }
            finally
            {
                repo = new SchoolRespository();

                // remove course and dept
                
                var course = repo.Query<Course>()
                    .Where(o => o.Name == "Algebra").FirstOrDefault();
                if (course != null) repo.Remove<Course>(course);
                
                var dept = repo.Query<Department>()
                    .Where(o => o.Name == "Mathematics").FirstOrDefault();
                if (dept != null) repo.Remove<Department>(dept);
                repo.Commit();
            }
        }

A Repository-like façade for mocking Entity Framework

2010-09-09T17:07:00.001-04:00

While I know there are a lot of people in the ALT.NET community who like to mock Enitity Framework, that is not what I am talking about.

The objective of this exercise is to develop an Interface that can be used by Business Logic to query and persist data as well as provide and in-memory “mock” for testing or prototyping without a database.

The paradigm used is that of object model aggregates typically found in Domain-driven designs (DDD). This is fortunate because it is the model used by EF, where the aggregates are called ObjectSets.

We want to take advantage of LINQ, because this will allow the consumer of the Repository to add query operators prior to executing the query. The Repository will provide a Query method, a New method, an Add method, a Remove method and a Commit method.

I used the term “a repository-like facade” in the title of this post because traditionally a Repository provides access to a single Aggregate. I have decided to allow an EF Context, which might have several aggregates, to be wrapped by my Repository-implementation. The root aggregate type is determined by the Type parameter affixed to the method. In addition, I will provide a number of convenience methods to chain some of these basic methods is a single method call.

Here is the interface:

using System;
using System.Linq;

namespace Interfaces
{
    public interface IRepository
    {
        // returns a query object for an aggregate root
        IQueryable<T> Query<T>();

        // returns a new object of the type requested
        T New<T>() where T : class;

        // returns a new object of the type requested (with the next id set)
        T Next<T>() where T : class;

        // adds the object to the aggregate root
        void Add<T>(T obj) where T : class;

        // gets a new object and Adds it to the collection
        T AddNew<T>() where T : class;

        // gets a new object (with next id set) and Adds it to the collection
        T AddNext<T>() where T : class;

        // adds a new object with the next id, runs initializer and persists it
        T CreateNext<T>(Action<T> initializer) where T : class;

        // remove an aggregate root
        void Remove<T>(T obj) where T : class;

        // persists any changes
        void Commit();
    }

}

The following code is an abstract implementation of the convenience methods, which are independent of the actual method of creating the new objects and managing them in the context. The methods that are declared abstract are the ones that will need to be implemented by a concrete Repository.

Note: The exception handling in these code listings has been omitted for brevity.

using System;
using System.Linq;

namespace Interfaces
{
    abstract public class BaseRepository : IRepository
    {
        abstract public IQueryable<T> Query<T>();

        abstract public T New<T>() where T : class;

        abstract public void SetNext<T>(T obj) where T : class;

        abstract public void Add<T>(T obj) where T : class;

        abstract public void Remove<T>(T obj) where T : class;

        abstract public void Commit();

        public T Next<T>() where T : class
        {
            var obj = New<T>();
            SetNext<T>(obj);   
            return obj;
        }

        public T AddNew<T>() where T : class
        {
            var obj = New<T>();
            Add<T>(obj);
            return obj;
        }

        public T AddNext<T>() where T : class
        {
            var obj = Next<T>();
            Add<T>(obj);
            return obj;
        }

        public T CreateNext<T>(Action<T> initializer) where T : class
        {
            var obj = AddNext<T>();
            if (initializer != null) initializer(obj);
            Commit();
            return obj;
        }      
    }
}

We can implement an in-memory repository that maintains each type of aggregate root in an ArrayList and uses the Type to find the correct List and operate on it accordingly. To simulate auto-numbered primary keys, we assume that auto-numbered entities will have a long Id property and maintain a single counter for all entities. Of course, you are free to implement this any way that works for you. The Commit() method is a no-op since we don’t plan on persisting the data to disk, but you can implement a Repository that does this if you like.

This implementation works with concrete entity classes (POCOs). I originally had a version that worked with interfaces and the repository mapped the interfaces to an implementation. This worked well with Entity Framework and its generated EntityObject classes, but fell down when I tried to use it with WCF RIA Services.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace Interfaces
{
    public class InMemRepository : BaseRepository
    {
        public InMemRepository()
        {
            // could data load from disk here
        }

        Dictionary<Type, ArrayList> roots = new Dictionary<Type, ArrayList>();
        long counter = DateTime.Now.Ticks;

        private ArrayList GetRootList<T>()
        {
            ArrayList list;
            if (!roots.TryGetValue(typeof(T), out list))
            {
                list = new ArrayList();
                roots[typeof(T)] = list;
            }
            return list;
        }

        public override IQueryable<T> Query<T>()
        {
            var list = GetRootList<T>();
            return list.Cast<T>().AsQueryable<T>();
        }

        public override T New<T>()
        {
            return Activator.CreateInstance<T>();
        }

        // assumes that there is an Id property (long)
        public override void SetNext<T>(T obj)
        {
            var idProperty = typeof(T).GetProperty("Id");
            idProperty.SetValue(obj, counter++, null);
        }

        public override void Add<T>(T obj)
        {
            var list = GetRootList<T>();
            list.Add(obj);
        }

        public override void Remove<T>(T obj)
        {
            var list = GetRootList<T>();
            list.Remove(obj);
        }

        public override void Commit()
        {
            // code here to write to disk
        }
    }
}

Here is a unit test that demonstrates how to work with the repository:

[TestClass()]
public class InMemRepositoryTest
{
    public class Department
    {
        public virtual long Id { get; set; }

        public virtual string Name { get; set; }

        private IList<Course> _courses = new List<Course>();
        public virtual IList<Course> Courses { get { return _courses; } }
    }

    public class Course
    {
        public virtual long Id { get; set; }

        public virtual string Name { get; set; }

        private Department _department;
        public virtual Department Department { get { return _department; }
            set
            {
                if (_department != null) _department.Courses.Remove(this);
                _department = value;
                if (_department != null) _department.Courses.Add(this);
            }
        }
    }

    [TestMethod]
    public void Test_InMemRepository()
    {
        IRepository repo = new InMemRepository();

        // create some departments
        var math = repo.AddNext<Department>();
        Assert.IsNotNull(math);
        Assert.IsInstanceOfType(math, typeof(Department));
        Assert.IsTrue(math.Id > 0);

        math.Name = "Mathematics";
        repo.Commit();

        // use the convenience method
        var compsci = repo.CreateNext<Department>(d =>
        {
            d.Name = "Computer Science";
        });
        Assert.IsNotNull(compsci);
        Assert.IsInstanceOfType(compsci, typeof(Department));
        Assert.IsTrue(compsci.Id > 0);
        Assert.IsTrue(compsci.Name == "Computer Science");

        var count = repo.Query<Department>().Count();
        Assert.AreEqual<int>(count, 2);

        // create some courses
        var algebra = repo.CreateNext<Course>(c =>
        {
            c.Name = "Algebra";
            c.Department = math;               
        });

        var trig = repo.CreateNext<Course>(c =>
        {
            c.Name = "Trigonometry";
            c.Department = math;
        });

        var lisp = repo.CreateNext<Course>(c =>
        {
            c.Name = "Lisp";
            c.Department = math;
        });

        Assert.AreEqual<int>(3, repo.Query<Course>().Count());
        Assert.AreEqual<int>(3, math.Courses.Count());
        Assert.AreEqual<int>(0, compsci.Courses.Count());

        lisp.Department = compsci;
        Assert.AreEqual<int>(2, math.Courses.Count());
        Assert.AreEqual<int>(1, compsci.Courses.Count());
    }
}

My next post will show how to write a Repository implementation for Entity Framework.

The future of Silverlight

2010-09-07T13:54:00.001-04:00

Due to rumors swiling about the demise of Silverlight at the hands of HTML 5, Microsoft felt compelled to publish the following on the Silverlight Blog:

In about half the time HTML 5 has been under design, we've created Silverlight and shipped four major versions of it. And it's still unclear exactly when HTML 5 and its related specs will be complete with full test suites. For HTML 5 to be really targetable, the spec has to stabilize, browsers have to all implement the specs in the same way, and over a billion people have to install a new browser or buy a new device or machine. That's going to take a while. And by the time HTML 5 is broadly targetable, Silverlight will have evolved significantly. Meanwhile, Silverlight is here now and works in all popular browsers and OS's.

…Silverlight is much more than a browser technology.

There are three areas of investment for Silverlight outside the browser: the desktop, the mobile device, and the living room. Powerful desktop applications can be created with Silverlight today. These applications don't require a separate download—any desktop user with Silverlight installed has these capabilities. These apps can be discovered and downloaded in the browser but are standalone applications that are painless to install and delete. Silverlight now also runs on mobile devices and is the main development platform for the new Windows Phone 7 devices. Developers that learned Silverlight instantly became mobile developers. Lastly, at NAB and the Silverlight 4 launch this year we showed how Silverlight can be used as a powerful, rich platform for living room devices as well.

Read the whole thing. It’s long but worth the time.

Silverlight 4 – September 2010 refresh

2010-09-07T13:41:00.001-04:00

Microsoft has released a refresh for Silverlight 4 to fix some bugs. Read Tim Heuer’s blog post.

If you are developing in LightSwitch, then you will need the new Developer Runtime and SDK.

The Silverlight Tools package has also been updated with the new SDK and runtime.

Windows Phone 7 RTM today

2010-09-02T17:12:00.001-04:00

According to a tweet from Scott Guthrie, Windows Phone 7 is released to manufacturing today. The final tools will be ready for download in two weeks, on September 16.

VS 2010 Express for Windows Phone 7 and Expression Blend for Phone 7 will be free.

Take a look at the Windows 7 Jump Start on-line training while you’re waiting.

Labs and code can be found in the Training Kit.

More LightSwitch commentary

2010-08-31T11:31:00.001-04:00

Tim Anderson has two informative posts about Microsoft’s LightSwitch. I’ll try to summarize them here.

Ten things you need to know about LightSwitch (Tim Anderson):

LightSwitch builds Silverlight apps for Windows, and to a lesser extent, Mac.
There is no visual forms designer.
However, you can customize your form while running in the debugger.
LightSwitch lets you build a model of your application behind the scenes.
It has built-in business data-types like E-mail Address and Phone Number.
LightSwitch tries to make it easier for non-developers to understand relational database design.
To that end, it uses LINQ and not SQL.
LightSwitch will be cheaper than VS Professional when it releases.
LightSwitch applications are cloud-ready, as long as you want to use Windows Azure.
Tim speculates that Windows Phone 7 will be added as a target platform.

Visual Studio LightSwitch – model-driven architecture for the mainstream (Tim Anderson):

Tim spoke to two LightSwitch team members. They couldn’t speculate on a release date, but did say that Windows Phone 7 will not be targeted in the first release. Perhaps it will be added later. The product was designed to allow different output formats for applications, but Mac is not considered high-priority. The development of LightSwitch had an influence on the design of some WCF RIA Services features.

While Microsoft seems to be positioning LightSwitch as a tool for the masses to develop departmental applications, it remains to be seen if it will catch on. Perhaps on a larger scale, Microsoft intends to deliver on the promise of model-driven application generation. And that would be no small feat.

Visual Studio LightSwitch Beta1

2010-08-28T22:32:00.001-04:00

Microsoft has released the first beta of its LightSwitch product.

LightSwitch allows you to create web-based data-driven applications, using industry-standard patterns and technologies: Entity Framework, WCF RIA Services and Silverlight.

WCF RIA Services

2009-11-18T17:48:00.001-05:00

What is WCF RIA Services? Well it is .NET RIA Service renamed, to more accurately represent the communications framework that is being used.

See: WCF RIA Services aka .NET RIA Services now available

The MSDN Doc page: http://msdn.microsoft.com/en-us/library/ee707344(VS.91).aspx

Get Started with WCF RIA Services: http://silverlight.net/getstarted/riaservices/

Silverlight 4 Beta Available

2009-11-18T17:39:00.001-05:00

Get the news here: Silverlight 4 Beta : The Official Microsoft Silverlight Site

Silverlight 4 development will require Visual Studio 2010.

Visual Studio 2010 can be installed side-by-side with Visual Studio 2008 SP1. Please read the known issue on installing Visual Studio 2010 if you already have the Silverlight 3 SDK installed.

Silverlight 4 on MDSN: http://msdn.microsoft.com/en-us/library/cc838158(VS.96).aspx

What’s New (partial listing)

Printing (finally): Silverlight 4 adds printing support that allows developers to control whether their Silverlight application can print itself, how the content is formatted when printed, and determine the content that will appear. For example, you could add a print button to your Silverlight application that opens the Print dialog allows the user to choose the printer, and then prints the Silverlight content.

Implicit Styles: Silverlight 4 introduces new styling features that allow you to create a style as a resource that can be used implicitly by all elements of a target type. This allows application developers to customize the look across multiple instances of a control and modify the appearance of these control instances by changing the implicit style.

Right Mouse Click: Silverlight 4 adds the ability to right click a visual element to perform custom actions such as displaying a menu that provides contextual commands or invoking commands for a Silverlight game.

Programmatic Clipboard Access: Silverlight 4 adds the ability to programmatically access the clipboard to format and modify data during copy, cut, and paste operations. To copy data from a Silverlight application to the clipboard use the Clipboard.SetText method

Silverlight as a Drop Target: Silverlight 4 now supports being a drop-target for the common drag-and-drop practice of clicking on a virtual object and dragging it to a different location or onto another virtual object. Both Windows and Mac platforms support this feature. Silverlight only supports dragging of file(s) from local client and dropping them onto a Silverlight application. It does not support dragging of folders (directories).

ObservableCollection<T> Constructor Accepts IList and IEnumerable (yay!): Silverlight 4 also can take advantage of new constructor overloads that allow it to initialize an ObservableCollection<T> from an IEnumerable or IList.

More can be found on Tim Heuer’s blog: http://timheuer.com/blog/archive/2009/11/18/whats-new-in-silverlight-4-complete-guide-new-features.aspx

RIA Services : The Official Microsoft Silverlight Site

2009-11-11T14:56:00.001-05:00

Brad Abrams announced last week that Microsoft has launched an official community site for RIA Services.

You will see that the latest version available of RIA Services is still the July 2009 CTP.

I expect to see a new release next week at PDC.

RIA Services : The Official Microsoft Silverlight Site

Silverlight 3 released and available for download.

2009-07-09T15:57:00.001-04:00

See Mary Jo Foley's piece here.

Also, tomorrow is the launch for SL3 and Expression 3. It starts at 10 AM PDT I am told - that's 1 PM on the East Coast.

Go to www.seethelight.com tomorrow to enjoy all the silvery goodness.

Entity Framework CTP 1

2009-06-24T22:39:00.001-04:00

The ADO.NET team at Microsoft has released an update to EF since the Beta release of VS2010/Net4.

They are calling it Entity Framework Feature CTP 1. Some of these features are not scheduled to be in .NET 4 when it releases, so if you want them, download the CTP and give them feedback.

Microsoft OracleClient Deprecated in .NET 4.0

2009-06-24T15:14:00.001-04:00

From InfoQ:

Microsoft announced System.Data.OracleClient will be deprecated after .NET 4.0. Classes in the namespace will be marked obsolete in .NET 4.0 and removed from future releases. OracleClient is the ADO.NET provider for Oracle developed by Microsoft and shipped as part of the .NET Framework Class Library.

Part of the reasoning for this decision is the increasingly availability and improvements of 3rd party ADO.NET data providers for Oracle. There have been significant performance improvements and enhanced multi-version compatibility among the popular Oracle providers:

Oracle's free Oracle Data Provider for .NET (ODP.NET) ODP.NET 11g is compatbile with all versions of Oracle Database back to 9.2, and multiple versions can coexist in a single OS

DataDirect ADO.NET Data Provider for Oracle 100% managed code, free trial

Devart dotConnect for Oracle Formerly known of as OraDirect.NET, free trial, supports Entity Framework, LINQ to Oracle, and ASP.NET Provider Model

Caliburn v1 Release Candidate available

2009-06-13T10:56:00.001-04:00

Rob Eisenberg has a blog post in which he details the important changes since the beta release of Caliburn.

What is Caliburn?

Caliburn is a toolkit to help you build Silverlight and WPF applications that are compliant with a number of UI design patterns (MVVM and Command Pattern being the relevant ones for me).

I’ve been working with Prism for a few weeks and now I have to figure out how to get Prism and Caliburn to play nice together.

.NET RIA Services V1 Roadmap

2009-06-09T10:00:00.002-04:00

Dinesh Kulkarni, from the RIA Services team, has published a roadmap for RIA Services. No guarantees here, but they hope to release a beta at PDC in November. The next CTP will be in July.

It's a bit disappointing to me. I had heard a rumor that RIA would release with Silverlight 3 in July. Perhaps it referred to the CTP. According to the roadmap, they are making changes to the underlying protocol (moving to ADO.NET Data Services), so you know that will take a lot of time.

Highlights from his post:

July 2009 CTP

This is a preview, not the V1 release. We plan to drop go-live restriction from EULA – still use it at your own risk.

Try to get significant known breaking changes (the ones we don’t know about will come later)

Feature enhancements (e.g. code-gen hookpoints to add your custom code, improved library support, better shared code support, query for singletons, cleaner user model and better extensibility support for Application Services etc.)

Usual fare of bug fixes, API improvements etc

Enable a first set of better together experiences with ADO.NET Data Services (add a DomainService to Data Service for writing app logic / expose DomainService as DataService)

PDC 2009 Beta

Additional core feature work (list TBD, under consideration – hierarchy support, presentation model)

Work on Visual Studio 2010 / .NET 4 support

Drag-drop support for databinding

Run in medium trust

Move to ADO.NET Data Services as the underlying protocol

First part of 2010: RTW

Polish beta release (bugs, perf, stress, security, localization, …)

Small design changes / tweaks

Keep up with changes in other products

A note on Platforms and tools

In each CTP, we will be keeping up with corresponding public Silverlight drops as and when they are scheduled (sorry, I don’t have that schedule)

For RTW, we are planning Visual Studio 2010 / .NET 4 as the primary story. Support for previous version TBD (depends on feedback about relative importance / cost / options)

Resources for Developing Silverlight/Prism Applications

2009-05-30T10:34:00.001-04:00

Prism for Silverlight - An Intro to Composite Applications (Video)
by Erik Mork
Modularity - Testing, Module Catalog and Unity in Prism
by Erik Mork
Prism Quick Start Kit
by David Hill
Building a Prism Application (4 short videos)
by Bob Brumfield and Erwin van der Valk
Patterns and practices in the Composite Application Library
by Pencho Popadiyn
Model – View – ViewModel in Silverlight
by Pencho Popadiyn
Developing Modular Applications Using Microsoft Silverlight and WPF (TechEd Video)
by Ward Bell
Programming Prism (Public online class)
by David Platt

Silverlight 3 and Expression Studio 3 to launch July 10, 2009

2009-05-29T10:39:00.001-04:00

Will Visual Studio 2010 put Expression Blend out of business?

2009-05-22T16:09:00.001-04:00

Not according to Jesse Liberty.

You will want Blend 3 for its terrific designer and animation capabilities and VS for its development capabilities. Microsoft is trying to make these tools the best for their target audience, rather than one tool that does everything merely adequately.

The other point Jesse makes: Because it is a few months old at this point, the Blend 3 beta won't work with .NET 4 projects yet. If you want to work on projects in VS 2010 and Blend 3, create them as .NET 3.5 projects.

Good news and bad news for Silverlight 3 development

2009-05-22T13:47:00.001-04:00

According to this post by Tim Heuer, the good news is that you can install the Silverlight 2 and 3 SDKs with Visual Studio 2010 Beta 1. You will get multi-targeted Silverlight development (i.e., either Silverlight 2 or 3) and an editable design surface.

Do not install the Silverlight 2 or 3 Tools packages, it won't work on VS 2010. And the Silverlight Navigation App template is not included with the SDK, only with the tools package.

You also need to install the Silverlight 3 Beta Developer runtime.

The bad news: .NET RIA Services will not install on VS 2010 Beta 1.

VS 2010 / .NET 4 Beta 1 now generally available

2009-05-20T13:56:00.002-04:00

Look here: http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx

You can find documentation here: http://msdn.microsoft.com/en-us/library/bb386063(VS.100).aspx

The next release of ADO.NET Entity Framework (EF) will be numbered 4.0 to sync to the .NET version and will be part of .NET 4.0

You can see some screenshots here: http://blogs.lessthandot.com/index.php/DesktopDev/MSTech/visual-studio-2010-screenshots

Visual Studio 2010 (.NET 4.0) Beta 1 released

2009-05-18T18:15:00.001-04:00

The first Beta release of VS 2010 is available starting today for MSDN subscribers.

There is a great write-up on Jason Zander's blog -
http://blogs.msdn.com/jasonz/archive/2009/05/18/announcing-vs2010-net-framework-4-0-beta-1.aspx

Highlights:

New templates and tools can be downloaded from VS Gallery within Visual Studio.
Support for TDD
dynamic keyword for Office programmability
many VB language improvements (I won't go into them 'cuz I'm a C# guy)
many improvements to C++ support (again, not my bag)
F# included with VS 2010
improvements to the WPF editor
Silverlight editor now built-in
HTML snippets for ASP.NET coding
JavaScript IntelliSense improvements
JQuery included
Team Arch does standard UML now. I'm not big into UML, but I find Sequence Diagrams pretty useful.
Architectural Explorer lets you browse through your Namespaces and view the structure of your app; then generate Sequence Diagrams automatically. Looks cool.
Test Plan management improvements ("Camano", now called Microsoft Test and Lab Manager, will be available as a scaled-down VS edition)
TFS improvements: branch management, visualizations, drag-drop merging.

Wow. I am looking forward to a test-drive.

.NET RIA Services minor bug fix release - May 2009 Preview

2009-05-18T11:13:00.001-04:00

See the announcement on Brad Abrams blog - http://blogs.msdn.com/brada/archive/2009/05/11/net-ria-services-may-2009-preview.aspx

Brad states that the Go Live for .NET RIA Services will be right around the time that Silverlight 3 releases.

Authorization Strategies for the Business Layer

2009-05-07T10:05:00.001-04:00

It's tempting to design a Business Layer that accepts User identity information and attempts to authenticate and authorize the user. However, security is a cross-cutting concern, and as such, should not be intertwined with your business logic.

The strategies presented here will extract the authorization component from the business logic and embed it as a separate concern within the Business Layer. I'm going to ignore the authentication function, and focus on determining what authority an authenticated user has to call functions in the Business Layer.

Two-step Business Layer Factory

try
{
 using(IFactory factory = AuthenticatedFactory.New(user, pw))
 {
   IOrderProcessing processing = factory.CreateOrderProcessing();
   return processing;
   // or 
   // container.RegisterInstance<IOrderProcessing>(processing);
 }
}
catch (AuthenticationError e) { }
catch (AuthorizationError e) { }
finally
{
  // clean up
}

The authentication is done in the AuthenticationFactory. If the AuthenticationFactory has dependencies on a data layer or LDAP provider, you can trade in the static New method approach for a dependency injection approach:

public class AuthenticatedFactory 
{
  public AuthenticatedFactory(IDataLayer dataLayer)
  {
    DataLayer = dataLayer;
  }
  // more code
}

Get your factory this way:

using (IFactory factory = container.Resolve<AuthenticatedFactory>())
{
  factory.User = user;
  factory.Password = pw;
  // get the business layer
}

Fine-grained Authorization using Sub-classes

One strategy for the Business Layer is to have coarse-grained authorization to the BusinessLayer. The user is either allowed to access that particular Business Layer, or an AuthorizationError is thrown. To make the access more fine-grained, the IOrderProcessing class that is returned can be tailored to the privileges that the authenticated user has. In either case, the factory method CreateOrderProcessing with determine the access level for the user.

For example suppose the IOrderProcessing interface offers three methods: LookupOrder(), EnterOrder() and ApproveOrder(). There are three levels of access: managers can access all three, clerks can access the first two, and salespeople can only access LookupOrder(). This can be accommodated by four classes and the factory determines which to return to the application.

public class NoAccessOrderProcessing : IOrderProcessing
{
    public virtual Order LookupOrder() { throw new AuthenticationError(); }
    public virtual void EnterOrder(Order o) { throw new AuthenticationError(); }
    public virtual void ApproveOrder(Order o) { throw new AuthenticationError(); }
}

public class SalespersonOrderProcessing : NoAccessOrderProcess
{
    public override Order LookupOrder() { /* code here */ }
}

public class ClerkOrderProcessing : SalespersonOrderProcessing
{
    public override void EnterOrder(Order o) { /* code here */ }
}

public class ManagerOrderProcessing : ClerkOrderProcessing
{
    public override void ApproveOrder(Order o) { /* code here */ }
}

This approach has the advantage of removing the authorization logic from the business logic, but it embeds the authorization logic in your class hierarchy. The designer of the business logic will need to be aware of the authorization model at design-time. However, if you know that the functions permitted to each role are going to be static, this approach has merit.

Single business class with Static-bound delegates

An alternate approach uses indirection through delegates. This strategy will move the logic entirely out of the class hierarchy and into the Factory class. The public methods on the business layer will call delegates that are, by default, set to the methods that perform the actual business logic. The Factory can disable certain methods by setting the delegates to null prior to handing the business layer object to the application.

public delegate Order LookupHandlerType();
public delegate void ProcessOrderType(Order o);

public class OrderProcessing : IOrderProcessing  
{
    public LookupHandlerType LookupHandler;
    public ProcessOrderType EnterHandler;
    public ProcessOrderType ApproveHandler;

    public OrderProcessing(IDataLayer dataLayer) {
        DataLayer = dataLayer;

        LookupHandler = _LookupOrder;
        EnterHandler = _EnterOrder;
        ApproveHandler = _ApproveOrder;

    }

    private IDataLayer DataLayer {  get;  set; }

    public Order LookupOrder() { 
        if (LookupHandler == null)
            throw new AuthorizationError();
        return LookupHandler();
    }
    
    public void EnterOrder(Order o) {
        if (EnterHandler == null)
            throw new AuthorizationError();
        EnterHandler(o);
    }
    
    public void ApproveOrder(Order o) {
        if (ApproveHandler == null)
            throw new AuthorizationError();
        ApproveOrder(o);
    }

    // business logic in these methods
    private Order _LookupOrder() { return new Order(); }
    private void _EnterOrder(Order o) { }
    private void _ApproveOrder(Order o) { }

}

public class Factory
{
    public IOrderProcessing CreateOrderProcessing()
    {
        // set these based on role user is in.
        bool manager = false;
        bool clerk = true;
        bool salesperson = true;

        //var processing = container.Resolve<IOrderProcessing>() as OrderProcessing;
        OrderProcessing processing = new OrderProcessing(new MyDataLayer());



        if (!manager) processing.ApproveHandler = null;
        if (!clerk) processing.EnterHandler = null;
        if (!salesperson) processing.LookupHandler = null;
        return processing;
    }
}

Dynamic-binding Authorization

As a further refinement, rather than statically binding to the Handler delegate properties, we could have the names of the Handlers stored in a database or file and use Reflection to set them to null if the role disallows access.

    public class DynamicFactory
    {
        public IOrderProcessing CreateOrderProcessing()
        {
            
            //var processing = container.Resolve<IOrderProcessing>() as OrderProcessing;
            OrderProcessing processing = new OrderProcessing(new MyDataLayer());

            //get user role, list of prohibited methods from authorization database
            //var prohibitedHandlers = new List<string>()
            //                       { "ApproveHandler", "EnterHandler" };
            //disable access
            foreach (string handler in prohibitedHandlers)
            {
                var field = processing.GetType().GetField(handler);
                field.SetValue(processing, null);
            }
            return processing;
        }
    }

I've presented some strategies for authorizing access to your business layer objects. It's important to keep authorization code separated from your business logic, since it is a cross-cutting concern and since security models will likely change over time, it makes sense to encapsulate the access in a Factory type object that can evolve over time. The key is that the business logic object that is handed to the application is already configured for the privileges that the user has and the authorization checking does not need to be embedded in the business logic.

Cool Google Chrome Tip

2009-05-06T08:41:00.001-04:00

Enter about:memory in the address bar.

Windows 7 news

2009-05-04T16:28:00.001-04:00

If you have installed the Windows 7 Beta, starting July 1, your computer will shut down every two hours, and it will expire on August 1, 2009.
Windows 7 Release Candidate is now available for MSDN subscription download.
Windows 7 Release Candidate will be available for public download tomorrow May 5.
Windows 7 Release Candidate will expire June 1, 2010. Bi-hourly shutdowns will start March 1, 2010.
In both cases (Beta and RC), there will be no upgrade path to a retail, licensed version. You will need to wipe and re-install.
Windows 7 includes IE 8, Windows Media Player 12 and .NET 3.5 SP1.

WPF Model-View-ViewModel Toolkit

2009-05-04T12:04:00.002-04:00

The WPF team at Microsoft has released a toolkit (version 0.1) that addresses developing UIs with the M-V-VM pattern.

It's definitely a first-pass (e.g. no VB.NET support), but they are looking for feedback on this effort. There is also a bit of confusion as to how this compares to the Silverlight development pattern in RIA Services. See this StackOverflow discussion.

The toolkit includes:

A Visual Studio 2008 template (Visual C# Express 2008 also supported)
Documentation
- General introduction to M-V-VM
- Walkthrough using the VS template
A complete WPF application demonstrating the M-V-VM pattern

Here's a post about ViewModel and how it enhances the UI's testability.

Check it out here: WPF Model-View-ViewModel Toolkit

Speed up your MSDN Library experience

2009-04-20T10:09:00.001-04:00

This tip comes courtesy of Scott Hanselman's blog.

MSDN is now available in a low-bandwidth mode.

Step 1) Goto http://msdn.microsoft.com/en-us/library/default(loband).aspx

Step 2) Click on the link Persist low bandwidth view. It is located in the upper right corner.

Step 3) Enjoy the speedy page access.

WPF and Silverlight Books

2009-04-18T13:00:00.001-04:00

Windows Presentation Foundation Unleashed (WPF)

Pro WPF: Windows Presentation Foundation in .NET 3.0

Programming WPF

Accelerated Silverlight 3

Pro Silverlight for the Enterprise

Pro Silverlight 2 in C# 2008 (Windows.Net)

Book Recommendation: Framework Design Guidelines (2nd ed.)

2009-04-11T13:03:00.001-04:00

The authoritative work by Brad Abrams and Krzysztof Cwalina on .NET framework design was recently updated.

The Book: Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (2nd Edition)

The Blog: http://blogs.msdn.com/brada/archive/tags/Framework+Design+Guidelines/default.aspx

The Blurb:

Framework Design Guidelines, Second Edition, teaches developers the best practices for designing reusable libraries for the Microsoft .NET Framework. Expanded and updated for .NET 3.5, this new edition focuses on the design issues that directly affect the programmability of a class library, specifically its publicly accessible APIs.

This book can improve the work of any .NET developer producing code that other developers will use. It includes copious annotations to the guidelines by thirty-five prominent architects and practitioners of the .NET Framework, providing a lively discussion of the reasons for the guidelines as well as examples of when to break those guidelines.

Microsoft architects Krzysztof Cwalina and Brad Abrams teach framework design from the top down. From their significant combined experience and deep insight, you will learn

The general philosophy and fundamental principles of framework design
Naming guidelines for the various parts of a framework
Guidelines for the design and extending of types and members of types
Issues affecting–and guidelines for ensuring–extensibility
How (and how not) to design exceptions
Guidelines for–and examples of–common framework design patterns

Enterprise Library 4.1 Hands-On Labs

2009-04-07T21:39:00.001-04:00

Microsoft Patterns and Practices has released some Hands-on Labs for Enterprise Library 4.1.

.NET 3.5 and VS 2008 are required.

This set of Hands-on Labs is a guide to learn about the application blocks included with Enterprise Library 4.1 and to leverage their capabilities in various application contexts. It includes Caching, Cryptography, Data Access, Exception Handling, Interception, Logging, Security, Validation, and Unity Hands-on Labs.

Docs for Enterprise Library 4.1 (10/2008) are here.

LINQ Links

2009-04-07T20:56:00.001-04:00

The MSDN Site: http://msdn.microsoft.com/en-us/vbasic/aa904594.aspx

Wikipedia: http://en.wikipedia.org/wiki/Language_Integrated_Query

LINQ (Language Integrated Query) was delivered in .NET 3.5 and Visual Studio 2008. It addreses O/R mapping issues by making query operations like SQL statements part of the programming language. It also offers built-in support for querying in-memory collections like arrays or lists, XML, DataSets, and relational databases.It also allows you to develop queries in your native development language (with IntelliSense).

LINQ to XML: It is recommended that developers switch over from coding against the XmlDocument DOM to LINQ's XDocument

LINQ to SQL: Deprecated... use LINQ to Entities

LINQ to Entities: Entity Framework Learning Guide

Books:

Silverlight 3 Beta

2009-04-01T07:57:00.001-04:00

http://silverlight.net/getstarted/silverlight3/default.aspx

Silverlight 3 Beta was unveiled at MIX09. It is a preview release which continues Silverlight’s track record of rapid innovation - introducing more than 50 new features, including support for running Silverlight applications out of the browser, dramatic video performance and quality improvements, and features that radically improve developer productivity.

Important notes:

This is a developer beta release only! This means there is no “go-live” licensing available and the end-user runtime of Silverlight 3 is not available. The tools below are intended for software developers only.
Once you install the Silverlight 3 Beta Tools for Visual Studio, your development environment will be a Silverlight 3 Beta environment. Visual Studio 2008 SP1 does not support multi-targeting for Silverlight applications so you will be unable to develop Silverlight 2 applications once these tools are installed. We recommend that you install the Silverlight 3 Beta tools on a separate environment if you still need to have the ability to develop Silverlight 2 applications.
Ensure that you have either Visual Studio 2008 SP1 or Visual Web Developer Express 2008 SP1 installed as it is a prerequisite for the Silverlight 3 Beta Tools for Visual Studio.

Google Chrome withstands security testing

2009-03-25T11:29:00.001-04:00

From Ars Technica:

A recent contest at CanSecWest, an event that brings together some of the most skilled experts in the security community, has demonstrated that the three most popular browser are susceptible to security bugs despite the vigilance and engineering prowess of their creators. Firefox, Safari, and Internet Explorer were all exploited during the Pwn2Own competition that took place at the conference. Google's Chrome browser, however, was the only one left standing—a victory that security researchers attribute to its innovative sandbox feature.

MIX09 Sessions

2009-03-24T15:13:00.001-04:00

Microsoft's MIX conference took place last week in Las Vegas, NV. It's a gathering of designers and developers who are focused on using Microsoft's latest and greatest tools to build web sites.

Silverlight and WPF are increasingly being seen as relevant tools for building line-of-business applications. Here are some of the talks that speak to Professional LOB app developers.

Web Development Using Microsoft Visual Studio: Now and in the Future

What's New in Windows Presentation Foundation (WPF) 4

What's New for Microsoft Silverlight and Microsoft Windows Presentation Foundation (WPF) Developers in Microsoft Visual Studio 2010

Automated User Interface (UI) Testing with Microsoft Visual Studio Team System 2010

Microsoft Silverlight Is Ready for Business

User Experience Design Patterns for Business Applications with Microsoft Silverlight 3

Building Amazing Business Centric Applications with Microsoft Silverlight 3

Building Out of Browser Experiences with Microsoft Silverlight 3

Microsoft Silverlight and Windows Presentation Foundation (WPF): Sharing Skills and Code

.NET RIA Services - Building Data-Driven Applications with Microsoft Silverlight and Microsoft ASP.NET [Added]

Dependency Injection, is it for you?

2009-03-23T15:50:00.001-04:00

People have been trying to convince you how great Dependency Injection is. Maybe they're calling it Inversion of Control. Either way, you're not buying it.

If you haven't been able to see the benefit, try reading Justin's blog post: To Inject or Not To Inject (warning: it is long, but worth it).

Justin focuses on complex configuration scenarios, but I like to recommend DI for its reusability. Self-configuring and "service locator" configuring tends to constrain you to using a particular type of configuration infrastructure, making it difficult to reuse your components, not to mention unit testing.

Roundup - .NET Application Development Platforms

2009-03-23T15:12:00.001-04:00

I've put together a collection of links from around the web on tools and technologies for developing .NET Line-of-business applications.

Silverlight 3 (beta) - Microsoft

Silverlight Labs - Microsoft

Silverlight Toolkit - CodePlex

WPF Hands-on lab (Southridge) - Microsoft Redmond

WPF Hands-on lab (Order Manager) - Microsoft Switzerland

WPF - CodePlex

Composite Application Guidance for WPF and Silverlight (Prism) - Microsoft P&P

Building a Framework for Silverlight - SilverlightShow

Caliburn - Rob Eisenberg

CSLA.NET (WPF and Silverlight) - Rocky Lhotka

DevForce WinClient - IdeaBlade

DevForce Silverlight - IdeaBlade

Nintex Workflow - Nintex

UPDATE: I added RIA services after listening to Brad Abram's talk on .NET Rocks. It was announced at MIX09.

RIA Services - Microsoft

RIA Services on SliverlightShow.

Welcome to Windows 7

2009-01-09T13:47:00.001-05:00

Do you like to get your hands on the latest and greatest?

Microsoft is posting a beta of its next generation Windows OS later today at the Windows 7 Web page.

Enjoy.

SharpDevelop

2009-01-08T15:02:00.001-05:00

If you are interested in a free Open Source Development Environment for .NET check out #develop (pronounced SharpDevelop). It supports C#. VB.NET and Boo.

Currently it only does .NET 1.1 and 2.0, but they are working on support for .NET 3.5, which will also add IronPython and F#.

Unity Application Block 1.2 for Silverlight - December 2008

2008-12-30T15:58:00.001-05:00

Not many changes here for Silverlight, just adjustments to the packaging to allow it to run in Silverlight...

Unity Application Block 1.2 for Silverlight - December 2008

And -- not sure how I missed it, but Unity 1.2 was released in October.

Ah, I remember, I was on vacation...

LINQ to SQL - Dead or alive?

2008-12-19T11:32:00.001-05:00

Microsoft claims that LINQ to SQL is not a dead technology, despite their focus on Entity Framework. From Redmond Developer News:

Tim Mallalieu, the program manager for both LINQ to SQL and the Entity Framework, ... says Microsoft anticipated the backlash but said both data access interfaces will be better off for this move. For those who don't think the Entity Framework is a suitable replacement, Mallalieu said stay tuned.

"There's some pretty nifty stuff we're doing in the beta 2 time frame that we are not speaking about as yet, I think it will give you a better experience and will reduce the anxiety that people have around the Entity Framework," Mallalieu said. "In terms of capabilities, I think will make the overall integrated experience of ASP.NET, Dynamic Data, MVC and these other things easier, we did a little bit of triaging and feedback, there is some valid feedback around complexity in the Entity Framework and we are doing things to address that. "

Especially in light of the fact that LINQ to SQL is specific to SQL Server, I think it's best to wait a while to see what happens with Entity Framework. Note that there are quite a few folks who aren't happy with the way it has turned out so far.

Silverlight 2 released

2008-10-21T10:10:00.001-04:00

Microsoft released Silverlight 2 last week. Install it from here.

More resources here. Tutorials and videos.

Unity 1.2 and Interception

2008-10-08T17:00:00.001-04:00

Unity 1.2 is under development, but we do know that it will support Interception.

David Hayden has a nice screencast showing how it works.

David shows how you can add an interceptor to time the execution of a method in an object that Unity has created for you. Cool stuff. Check it out!

Fun with C# 3.0 (#4) - Nullable types and the ?? operator

2008-10-06T10:23:00.001-04:00

C# has reference types and value types. Reference types are commonly called objects, and variables that are declared to be of a reference type can refer to an object or be null. Value types (int or bool, for example) can be stored in variables that contain the actual value, and therefore can never be null.

Sometimes it is useful to have a value type that can have a null value, so this feature has been added to C# 3.0.

This feature is implemented using generics and the type System.Nullable<T>, the shorthand for which is T?. The property HasValue can be used to see if the variable is null. Here's an example:

int? x = 10;
if (x.HasValue)
{
    System.Console.WriteLine(x.Value);
}
else
{
    System.Console.WriteLine("Undefined");
}

A nullable type can not be assigned to a value type. The following will not compile:

int? x = 10;
int y;
y = x;

Rather use the Value property:

int? x = 10;
int y;
y = x.Value;

Accessing Value will throw an InvalidOperationException if the nullable type is null. Use the ?? to assign a default value.

int? x = null;
int y;
y = x ?? 0;

This is equivalent to:

y = x.HasValue ? x.Value : 0;

Usage of the ?? operator is not limited to Nullable types. For example:

string name = enteredName ?? "Name not entered.";

The Common Service Locator

2008-10-03T15:14:00.002-04:00

I have argued against making 'hard' references to an underlying Dependency Injection (or IoC) container; rather, allow the container to do the work for you, namely, inject the dependencies. I realize that it can be difficult in practice, and apparently so have others.

A group of DI container authors have come together to define a common interface for using the underlying containers without creating a hard reference to a particular implementation. This is useful when you are writing code that needs to use a container to resolve a dependency (i.e. get an instance) but you don't know or care what container is being used.

So now we have the Common Service Locator library. Thanks to Ayende for blogging it. UPDATE: Also Glenn Block.

Each container needs an adapter to implement the interface and do the translation from the common method calls to the native container calls. This allows all container references to be declared as Microsoft.Practices.ServiceLocation.IServiceLocator.

Your code has two ways of getting the container:

The IServiceLocater reference can be supplied by the calling code and you just use it, or
You code can use a static property, ServiceLocator.Current.

Here is the interface that you will use (API Reference):

using System;
using System.Collections.Generic;

namespace Microsoft.Practices.ServiceLocation
{
    // Summary:
    //     The generic Service Locator interface. This interface is used to retrieve
    //     services (instances identified by type and optional name) from a container.
    public interface IServiceLocator : IServiceProvider
    {
        // Summary:
        //     Get all instances of the given TService currently registered in the container.
        //
        // Type parameters:
        //   TService:
        //     Type of object requested.
        //
        // Returns:
        //     A sequence of instances of the requested TService.
        //
        // Exceptions:
        //   Microsoft.Practices.ServiceLocation.ActivationException:
        //     if there is are errors resolving the service instance.
        IEnumerable<TService> GetAllInstances<TService>();
        //
        // Summary:
        //     Get all instances of the given serviceType currently registered in the container.
        //
        // Parameters:
        //   serviceType:
        //     Type of object requested.
        //
        // Returns:
        //     A sequence of instances of the requested serviceType.
        //
        // Exceptions:
        //   Microsoft.Practices.ServiceLocation.ActivationException:
        //     if there is are errors resolving the service instance.
        IEnumerable<object> GetAllInstances(Type serviceType);
        //
        // Summary:
        //     Get an instance of the given TService.
        //
        // Type parameters:
        //   TService:
        //     Type of object requested.
        //
        // Returns:
        //     The requested service instance.
        //
        // Exceptions:
        //   Microsoft.Practices.ServiceLocation.ActivationException:
        //     if there is are errors resolving the service instance.
        TService GetInstance<TService>();
        //
        // Summary:
        //     Get an instance of the given named TService.
        //
        // Parameters:
        //   key:
        //     Name the object was registered with.
        //
        // Type parameters:
        //   TService:
        //     Type of object requested.
        //
        // Returns:
        //     The requested service instance.
        //
        // Exceptions:
        //   Microsoft.Practices.ServiceLocation.ActivationException:
        //     if there is are errors resolving the service instance.
        TService GetInstance<TService>(string key);
        //
        // Summary:
        //     Get an instance of the given serviceType.
        //
        // Parameters:
        //   serviceType:
        //     Type of object requested.
        //
        // Returns:
        //     The requested service instance.
        //
        // Exceptions:
        //   Microsoft.Practices.ServiceLocation.ActivationException:
        //     if there is an error resolving the service instance.
        object GetInstance(Type serviceType);
        //
        // Summary:
        //     Get an instance of the given named serviceType.
        //
        // Parameters:
        //   serviceType:
        //     Type of object requested.
        //
        //   key:
        //     Name the object was registered with.
        //
        // Returns:
        //     The requested service instance.
        //
        // Exceptions:
        //   Microsoft.Practices.ServiceLocation.ActivationException:
        //     if there is an error resolving the service instance.
        object GetInstance(Type serviceType, string key);
    }
}

Here are the containers that have adapters at the moment:

Castle Windsor Adapter

Spring .NET Adapter

Unity Adapter

MEF Adapter (TBD)

StructureMap Adapter (TBD)

I recommend IServiceLocator be used in all components that might need a reference to a container. Note that they are no common calls for configuring the container because this is a container-specific task that should be handled in the calling code.

Microsoft "Dublin" addresses composite SOA applications

2008-10-02T14:26:00.001-04:00

Microsoft just released a white paper outlining how .NET Framework 4.0 and new Windows Server capabilities (code-named Dublin) will help developers design, build and maintain Composite Applications. The white paper is available here.

What are composite SOA applications? Applications that are composed by assembling and integrating reusable services. This makes the deployment and management of applications (and servers) more complex and creates new requirements to address scalability, performance and reliability.

Microsoft has announced .NET Framework 4.0 to add functionality to WCF and WF, and also "Dublin", an add-on to Windows Server 2008, that will make SOA applications and servers easier to deploy, configure, manage and scale. The first preview will be available at the PDC at the end of October.

See the chart below from the white paper:

Windows Communication Foundation 4.0

Windows Workflow
Foundation 4.0

Windows Server
"Dublin" technologies

RESTful enhancements

·   Simplifying the building of REST Singleton & Collection Services, ATOM Feed and Publishing Protocol Services, and HTTP Plain XML Services using WCF

·   WCF REST Starter Kit to be released on Codeplex to get early feedback

Messaging enhancements

·   Transports - UDP, MQ, Local in-process

·   Protocols - SOAP over UDP, WS-Discovery, WS-BusinessActivity, WS-I BP 1.2

·   Duplex durable messaging

Correlation enhancements

·   Content and context driven, One-way support

Declarative Workflow Services

·   Seamless integration between WF and WCF and unified XAML model

·   Build entire application in XAML, from presentation to data to services to workflow

Significant improvements in performance and scalability

·   Ten-fold improvement in performance

New workflow flow-control models and pre-built activities

·   Flowcharts, rules

·   Expanded built-in activities – PowerShell, database, messaging, etc.

Enhancements in workflow modeling

·   Persistence control, transaction flow, compensation support, data binding and scoping

·   Rules composable and seamlessly integrated with workflow engine

Updated visual designer

·   Easier to use by end-users

·   Easier to rehost by ISVs

·   Ability to debug XAML

Provide standard host for WF and WCF applications

Pre-built developer services

·   Message-based correlation

·   Message forwarding service

·   Content-based message routing

·   Compensation service for long-running transactions

Greater scalability and easier manageability

·   Enable scale-out of stateful workflow applications

·   Persisting and rehydrating state for high scalability

·   Enhanced management and monitoring functions

·   Tracking store for workflow events

Supports “Oslo” modeling platform

Key takeaways:

Microsoft will make it easier to design applications as WF workflows that are easily integrated into WCF services.
WCF and WF both use XAML. Microsoft will move to a "unified" XAML to make the integration easier.
Microsoft is moving more toward REST for web services due to its simplicity. The REST Starter Kit will be available on Codeplex in the near future.
The server infrastructure (Dublin) to host and manage these new types of applications will become available after .NET 4 and Visual Studio 2010 ship.

Links:

Visual Studio Training Kit updated for 2008 SP1 and .NET SP1

2008-10-01T11:49:00.001-04:00

Allan dCP has has a post about the updated (for SP1) Visual Studio 2008 training kit.

Notable:

Visual Studio 2010/.NET 4.0 Roundup

2008-09-29T14:15:00.001-04:00

Today Microsoft announced that, although recently referred to as Visual Studio 10 or "Hawaii", the official name of the next release will be Visual Studio 2010 and it will be accompanied by .NET Framework 4.0.

eWeek reports:

Microsoft announces Visual Studio 2010 and .NET Framework 4.0, and says the overall development strategy revolves around five pillars. The first pillar involves the Visual Studio Team System (VSTS) 2010, formerly codenamed “Rosario.”

Microsoft has announced the name of the next version of its developer tools and platform: Visual Studio 2010 and the .NET Framework 4.0.

In the announcement on Sept. 29, Microsoft also described the next release through the following five focus areas: riding the next-generation platform wave, inspiring developer delight, powering breakthrough departmental applications, enabling emerging trends such as cloud computing, and democratizing ALM (application life-cycle management), said Dave Mendlen, a director of product management in Microsoft’s Developer Division.

However, Mendlen did not give an actual date for when the new technology would become available, except to say that its name implies something about the time frame of its availability.

http://www.eweek.com/c/a/Application-Development/Microsoft-Announces-Visual-Studio-2010-and-NET-Framework-40/

From InformationWeek:

In Visual Studio 2010, Microsoft also will introduce a feature it likens to an airplane's black box. While running a test of an application, a "black box" records the state of the machine and the application. That way, a tester can look at a debug log running alongside a video replay of the application that was under test and dive into all layers of the computing stack to see where a bug might have occurred.

Visual Studio Team System 2010 will include some pieces of Microsoft's "Oslo" modeling strategy, as first demonstrated at Microsoft's TechEd conference earlier this year. The Architecture Explorer will allow architects and developers to build, customize, and see an architectural diagram of an application and enforce architectural consistency on builds of a piece of software. The software will support the Object Management Group's Unified Modeling Language and domain-specific languages.

More screenshots from Martin Heller at InfoWorld (click to enlarge):

Silverlight 2 Release Candidate Now Available

2008-09-29T14:14:00.001-04:00

Scott Guthrie announces.

There are some breaking changes between Beta2 and this RC, and we want to make sure that existing sites can update to the final release quickly once the final release is out. As such, you can only use the RC for development right now - you can't go live with the new APIs until the final release is shipped (which will be soon though).

You can download today's Silverlight Release Candidate and accompanying VS and Blend support for it here. Note that Expression Blend support for Silverlight 2 is now provided using Blend 2.0 SP1. You will need to install Blend 2.0 before applying the SP1 service pack that adds Silverlight 2 support. If you don't already have Blend 2.0 installed you can download a free trial of it here.

The final release of Silverlight is not that far off now. It has been a pretty amazing project that has come a long way in a pretty short amount of time.

Visual Studio 2008 SP1 Preparation Tool

2008-09-11T10:10:00.001-04:00

Microsoft has released a tool that will prepare your system for VS 2008 SP1. It's important to run it if you have installed any beta Visual Studio 2008 software since it went RTM.

http://www.microsoft.com/downloads/details.aspx?FamilyId=A494B0E0-EB07-4FF1-A21C-A4663E456D9D

The following pre-release programs and updates will prevent Visual Studio 2008 SP1 from installing successfully, so they must be removed prior to installation:

Microsoft Silverlight Tools Beta 1
Microsoft Visual Studio 2008 - KB949325
Microsoft Visual Studio 2008 - KB944899 (v1)
Microsoft Visual Studio 2008 - KB945140 (SP1 Beta)

To remove these programs, it is recommended that you run the automated Visual Studio 2008 Service Pack Preparation Tool. This tool will remove the specified updates and programs from your system and restore the integrity of any Visual Studio 2008 features that may have been compromised during manual removal of the Visual Studio 2008 SP1 Beta release.

NHibernate 2.0 has been released

2008-08-25T14:55:00.001-04:00

NHibernate is a port of the Java Hibernate ORM (Object-Relational Mapper) and has the feature set of Hibernate 3.2.

If you are looking for docs or tutorials, try Fabio's wiki: http://knol.google.com/k/fabio-maulo/-/1nr4enxv3dpeq/21

Download here: SourceForge.net: Files

SQL Server 2008 released

2008-08-12T13:00:00.001-04:00

Microsoft has released SQL Server 2008.

Evaluation download available here.

Hardware and Software requirements are here.

Note that if you have Visual Studio 2008 installed, you will need to upgrade to Visual Studio 2008 SP1 before installing SQL Server 2008.

Web Services Security Guide for WCF

2008-08-12T09:21:00.001-04:00

Microsoft Patterns and Practices has released the WCF security guide.

Parts

Part I, "Security Fundamentals for Web Services"
Part II, "Fundamentals of WCF Security"
Part III, "Intranet Application Scenarios"
Part IV, "Internet Application Scenarios"

Visual Studio 2008 Service Pack 1 available

2008-08-11T14:24:00.001-04:00

VS 2008 SP1 is now available for download with the .NET 3.5 SP1 framework.

More info here.

Visual Studio 2008 SP1 delivers:

Improved WPF designers
SQL Server 2008 support
ADO.NET Entity Designer
Visual Basic and Visual C++ components and tools (including an MFC-based Office 2007 style ‘Ribbon’)
Visual Studio Team System Team Foundation Server (TFS) addresses customer feedback on version control usability and performance, email integration with work item tracking and full support for hosting on SQL Server 2008
Richer JavaScript support, enhanced AJAX and data tools, and Web site deployment improvements

The .NET Framework 3.5 SP1 delivers:

Performance increases between 20-45% for WPF-based applications – without having to change any code
WCF improvements that give developers more control over the way they access data and services
Streamlined installation experience for client applications
Improvements in the area of data platform, such as the ADO.NET Entity Framework, ADO.NET Data Services and support for SQL Server 2008’s new features.

Unity 1.2 will support Interception

2008-08-10T22:21:00.003-04:00

Grigori blogs about it: http://blogs.msdn.com/agile/archive/2008/08/03/entlib4-1-kickoff.aspx

Ninject revisited

2008-07-12T18:25:00.002-04:00

In a previous post, I looked at Ninject, and based on a cursory look at the documentation, dismissed it as requiring me to decorate my component classes with attributes in order to use multi-parameter constructor injection. Thanks to a comment by ninject's author, Nate Kohari, I found that with a slight configuration change, we can duplicate the behavior of Unity.

The proof's in the pudding. Let's see if we can wire up the same components with both Unity and Ninject without having to make any changes to our component classes.

Here are some interfaces:

public interface IDataService
{
}

public interface ISecurityService
{
}

public interface ILogger
{
}

And here are some components that use them. The Business Logic requires all three, the Security service needs a DataService and Logger, and the DataService needs a Logger.

public class BusinessLogic
{
   protected IDataService DataService { set; get; }
   protected ILogger Logger { set; get; }
   protected ISecurityService SecurityService { set; get; }

   public BusinessLogic()
   {
   }

   public BusinessLogic(ILogger logger, IDataService dataService, ISecurityService securityService)
       :this()
   {
       this.Logger = logger;
       this.DataService = dataService;
       this.SecurityService = securityService;
   }


   public override string ToString()
   {
       return base.ToString() + '\n' +
           Logger.ToString() + '\n' +
           DataService.ToString() + '\n' +
           SecurityService.ToString() + '\n'
           ;
   }
}


public class DataService : IDataService
{
   protected ILogger Logger { set; get; }

   public DataService()
   {
   }

   public DataService(ILogger logger)
       :this()
   {
       this.Logger = logger;
   }
}

public class SecurityService : ISecurityService
{

   protected IDataService DataService { set; get; }
   protected ILogger Logger { set; get; }

   public SecurityService()
   {
   }

   public SecurityService(ILogger logger, IDataService dataService)
       : this()
   {
       this.Logger = logger;
       this.DataService = dataService;
   }
}

public class Logger : ILogger
{
}

If we don't want to use an auto-wring container, we need to know all the dependecies and create the Business object like so:

static BusinessLogic NormalWay()
{
   var logger = new Logger();
   var dataService = new DataService(logger);
   var securityService = new SecurityService(logger, dataService);
   var bizLogic = new BusinessLogic(logger, dataService, securityService);
   return bizLogic;
}

How do we configure and create a BusinessLogic object with Unity? Like so:

static BusinessLogic UnityWay(UnityContainer container)
{
       UnityContainer container = new UnityContainer();
       container
           .RegisterType<ILogger, Logger>()
           .RegisterType<IDataService, DataService>()
           .RegisterType<ISecurityService, SecurityService>()
           ;
       var bizLogic = container.Resolve<BusinessLogic>();
       return bizLogic;
   }
}

Likewise, we can create a method to create a BusinessLogic object using Ninject, all auto-wired are ready to go. This however, requires a configuration class (MyModule):

static BusinessLogic NinjectWay()
{
   var kernel = new StandardKernel(new MyModule(), new AutoWiringModule());
   var bizLogic = kernel.Get<BusinessLogic>();
   return bizLogic;

}
private class MyModule : StandardModule
{
   public override void Load()
   {
       Bind<ILogger>().To<Logger>();
       Bind<IDataService>().To<DataService>();
       Bind<ISecurityService>().To<SecurityService>();
   }
}

We can run the following to show that the objects get create and populate the services:

static void Main(string[] args)
{
   BusinessLogic bz;

   bz = NormalWay();
   System.Console.WriteLine(bz);

   bz = UnityWay();
   System.Console.WriteLine(bz);

   bz = NinjectWay();
   System.Console.WriteLine(bz);

}

So the end result is that we can design our components and use constructor-injection. So long as we keep container-dependencies out of our business components, an app can be assembled using the container of your choice.

Looking at Ninject

2008-07-03T22:17:00.001-04:00

Not to be too Microsoft-centric, I decided to look at the DI container Ninject, which has recently been released by Nate Kohari. After all, if we write our components correctly (POCOs), then swapping out containers should be a trivial exercise.

I looked at the docs on Ninject's constructor injection and found the following:

You also have the option to leave off the [Inject] attribute completely. This can help if you don't have access to the source code of a class, but you still want to inject dependencies into it. Here's the logic Ninject follows to choose which constructor to call, if none have an [Inject] attribute:

If the type only has a single constructor, Ninject will call it.

If the type has more than one constructor, but has a default (parameterless) constructor available, Ninject will call it. (This also applies to types that have no explicit constructors defined.)

I think that's a deal-breaker. Adding Attributes to my classes is not an option, because I want to maintain container-independency. In order to work correctly with constructor-injection, I need the container to call the container with as many parameters as it can satisfy. I will often have a parameterless constructor in my component to supply default values for the object for legacy code which is not using a container.

I'll take another look at Ninject if the constructor-injection strategy changes. The site has really sweet icons, by the way. Here's a sample:

Fun with C# 3.0 (#3) - Lambda expressions

2008-07-03T11:55:00.001-04:00

The addition of LINQ to C#/.NET has really improved the way that we can handle data in our applications. Here's an example.

Suppose we want to write a method to count the number of strings in a list which exceed a certain length. It's not to hard to do with C# 2.0; you iterate over the items, make the comparison, increment a counter and return it. But C# 3.0 makes it simple.

When the namespace System.Linq is included in your file, IEnumerable objects get a load of new extension methods. One of them is Where, which will return a sub-collection of items that match a filter. The filter is defined as a lambda expression that returns a bool. If the item causes the lambda expression to evaluate to true, then the item will be included in the sub-collection. Let's look at some code:

public int NumberLongerThan(List<string> list, int n)
{
   var subList = list.Where(
        (string str) => str.Length > n
   );
   return subList.Count();
}

Here we pass in a List<string> and a number. The subList will have the string items that are longer than n characters. Note that we don't have to define the type of subList; the compiler can infer it at compile-time.

Here is the code that uses the method.

List<string> list = new List<string>() { "abc", "def", "GH", "ijKL", "mnop", "QRSTUV", "Wxyz" };
Console.WriteLine(NumberLongerThan(list, 0));
Console.WriteLine(NumberLongerThan(list, 1));
Console.WriteLine(NumberLongerThan(list, 2));
Console.WriteLine(NumberLongerThan(list, 3));

This is the lambda expression:

(string str) => str.Length > n

It states that a string is passed in and returns a bool based on the test of the string Length. The Where() method takes an expression that expects a string and returns a bool. Since the compiler knows this, we can let it infer the type of the parameter and specify the expression like so:

str => str.Length > n

Also, note that if we have a named method that is of the correct delegate type (Func<T, bool>), we can pass it to Where(). Here, List<T> is List<string>, so the method must take a string parameter.

public bool TestString(string s) { return s.Length > 3; }

var filtered = list.Where(TestString);
//-- or --
Func<string, bool> f = TestString;
var list2 = list.Where(f);

The advantage of using the unnamed lambda expression is that we can reference the local variable n as a parameter in our test expression.

More info at Charlie Calvert's blog.

Making Your Resource Classes Public

2008-07-01T21:38:00.001-04:00

I recently posted on how to reference your Resources from a test assembly using the InternalsVisibleTo attribute.

The problem is that Visual Studio 2005 creates the Resource class with the internal access modifier. It turns out that this is configurable in Visual Studio 2008.

New Series on WCF

2008-07-01T21:31:00.001-04:00

Ron Jacobs has started a video series on WCF - The Total Noobs Guide to WCF.

Lesson 1: My First WCF Service (16:21)

WCF Security Guide

2008-06-28T11:47:00.001-04:00

The 2nd beta of the WCF Security Guide has been released by the Microsoft patterns and practices group.

Nice series on Separation of Concerns by bogardj

2008-06-27T22:57:00.001-04:00

Jimmy Bogard has written a great series of blog posts showing how to refactor some Data Access code to make it more readable, testable and maintainable. The offending (offensive?) code was found in ASP.NET Pro magazine and had static references that precluded doing any unit testing. Jimmy shows how to separate out those dependencies.

Fun with C# 3.0 (#2)

2008-06-24T18:31:00.000-04:00

This one is a quickie. Auto-implemented properties.

It allows you specify the property and have the compiler automatically define a backing private instance member. It is way cool.

public class Employee
{
    public string Name { set; get; }
    public string Job { set; get; }
    public int Age { set; get; }
}

Fun with C# 3.0 (#1)

2008-06-24T13:47:00.001-04:00

This is the first in a series of posts in which I explore new features of C# 3.0 available in Visual Studio 2008.

In this post, I introduce anonymous types and extension methods.

An anonymous type is an unnamed class that you can define simply by specifying the values of its properties. These properties are read-only and can be accessed through the usual property accessor syntax.

var employee = new { Name = "John Smith", Age = 44, Job = "Manager" };
Console.WriteLine(employee.Name);
Console.WriteLine(employee.Age);
Console.WriteLine(employee.Job);

ProcessData(employee);

The class is created at compile-time and the properties are available via IntelliSense. Note, however that if you want to pass the object to another method, it must be passed as an object, since the class is unnamed.

public void ProcessData(object data)

{

}

Once we have the object in our ProcessData method, we need to access the properties via Reflection. Here's where extension methods come in handy. An extension method is a method that is declared as a static method in static class and is in an accessible namespace. It will appear to add new methods to an object type. For example, I can add a method to the String class that removes spaces:

public static class Extend
{
    public static string RemoveSpaces(this string s)
    {
        return s.Replace(" ", "");
    }

}

The "this" parameter modifier indicates that it is an extension method and the type of the parameter (string) is the class that is modified. It is called like so:

Console.WriteLine(employee.Name.RemoveSpaces());

To ease the access to our anonymous type properties, we can create an extension method on the object class. The method will be called ValueOf() and will take the name of the property as a parameter:

public static class ReflectionExtensions
{
    public static object ValueOf(this object obj, string name)
    {
        if (name == null) throw new ArgumentNullException("Property Name");

        try
        {
            return obj.GetType().GetProperty(name).GetValue(obj, null);
        }
        catch (NullReferenceException)
        {
            return null;
        }
    }
}

Now in our ProcessData() method we can access the Property values:

public void ProcessData(object data)
{
    Console.WriteLine("Employee Name = " + data.ValueOf("Name"));
    Console.WriteLine("Employee Age = " + data.ValueOf("Age"));
    Console.WriteLine("Employee Job = " + data.ValueOf("Job"));

}

Configuring and Supplying a Factory with Unity

2008-06-18T10:08:00.002-04:00

Here is a code-sample which allows the Factory to be Container-dependent, and thus configurable in the container setup code. Notice that I registered the unity instance with itself. If you do not do this, when the Factory is created, Unity will see that a UnityContainer is needed by the constructor and instantiate a new UnityContainer, which will not have the correct configuration. If you have registered the configured unity instance, then it will be supplied to the Factory. Also note that the unity configuration can be changed by other parts of the application, so if you want to avoid that, you might want to make a copy of the container inside the Factory constructor.

using System;
using Microsoft.Practices.Unity;
namespace DI
{
    #region Container-independent

    public interface I { }
    public interface IFactory<T>
    {
        T Create();
    }

    public class A : I
    {
    }
    public class Aprime : I
    {
    }
    public class B
    {
        IFactory<I> Ifactory;

        public B(IFactory<I> f) { Ifactory = f; }

        public void SomeMethod()
        {
            I a = Ifactory.Create();
            Console.WriteLine(a.ToString());
        }
    }

    #endregion
//--------------------------------------------------------------------------------
    #region Unity container Dependent

    public class Factory<T> : IFactory<T> where T : class
    {  
        UnityContainer container;
        public Factory(UnityContainer unity) { this.container = unity; }
        public T Create() { return container.Resolve<T>(); }
    }
    class Program
    {
        static void Main(string[] args)
        {
            UnityContainer unity = new UnityContainer();

            // register the Unity container so that this instance is provided to factory
            unity.RegisterInstance(unity);

            // tell Unity to provide A when asked for interface I
            unity.RegisterType<I, A>();

            // use the Unity enabled factory
            unity.RegisterType(typeof(IFactory<I>), typeof(Factory<I>));

            B b = unity.Resolve<B>();
            b.SomeMethod();

            // now tell Unity to provide Aprime when asked for I
            unity.RegisterType<I, Aprime>();
            b.SomeMethod();
           
        }
    }
    #endregion
}

See: http://www.codeplex.com/unity/Thread/View.aspx?ThreadId=29697 for a discussion about this.

Container Dependency anti-pattern

2008-06-18T08:48:00.005-04:00

It is good design to minimize the number of dependencies between components in a system. Dependency Injection is used to decouple components from each other. A component should not specify, or require, a particular implementation of a Data Service, Logging Service or any other cross-cutting concern.

One solution to this problem is to use a DI container, such as Unity. This localizes all the dependencies in one place, the shell, or configuration point for your application. The components and services can be assembled and provided to the components as needed.

However, sometimes this leads to an anti-pattern in that components are built with a dependency on the container. This counteracts much of the advantage of using the container. It makes it difficult to share your components with another team that might be using a different container. Do not create container dependencies in your components!

The picocontainer example shows how to solve the problem with constructor injection, but assumes that the dependent container (B) only needs one instance of the A object. The question arises how can B create A objects on the fly as needed?

The solution is to inject a Factory into B via the constructor.

using System;
using Microsoft.Practices.Unity;

namespace DI
{
   public class A
   {
   }

   public class B
   {
       Factory<A> Afactory;

       public B(Factory<A> f) { Afactory = f; }

       public void SomeMethod()
       {
           A a = Afactory.Create();
           Console.WriteLine(a.ToString());
       }
   }

   public class Factory<T> where T : new()
   {
       public T Create() { return new T(); }
   }
   class Program
   {
       static void Main(string[] args)
       {
           UnityContainer unity = new UnityContainer();
           B b = unity.Resolve<B>();
           b.SomeMethod();
       }
   }
}

If you want to have the factory use a specific container, that could be an acceptable dependency, since it would be a trivial change to write a new Factory class for a different container. I will post this later.

See: http://www.codeplex.com/unity/Thread/View.aspx?ThreadId=29697 for a discussion about this.

UPDATE: See http://initializecomponent.blogspot.com/2008/10/common-service-locator.html

Stupid .NET Tricks #1

2008-06-17T16:08:00.001-04:00

If you like to Unit Test as much as I do, and you're obsessive about putting your strings in Resources files, it can be kind of tricky to make use of these Resources in your Unit Tests.

I'll show you what I mean. You want to unit test the following:

public string login(user, pw)
{
    if (!validUser(user, pw))
    {
        return "Invalid User";
    }
}

OK, so we write a test:

public void TestInvalidUser()
{
    MyClass m = new MyClass();
    Assert.AreEqual("Invalid User", m.login("Me","X"));
}

Now I want to move the error message into the Resources class that Visual Studio generates for you when you use the String editor on the Project Properties dialog. Now we have:

public string login(user, pw)
{
    if (!validUser(user, pw))
    {
        return Properties.Resources.INVALID_USER;
    }
}

and

public void TestInvalidUser()
{
    MyClass m = new MyClass();
    Assert.AreEqual(Properties.Resources.ERROR_INVALID_USER, m.login("Me","X"));
}

The problem is that the Resources class that VS generates for you will have the internal access modifier and will not be accessible to your test code (unless you include the test in the same assembly, which is sub-optimal). To the rescue comes the InternalsVisibleTo attribute. Add it to your production class, specifying the Test assembly as a friend and you code will compile. I've had mixed success getting Intellisense to recognize that it can access the other assembly, however. It doesn't stop it from compiling anyway.

[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("AcmeCorp.ProjectX.Tests.TestSecurity")]

Note, also, that if the production assembly is signed, then the test assembly will need to signed as well, and the public key of the friend assembly will need to be specified as part of the assembly name.

Silverlight 2 Beta 2 available

2008-06-07T18:03:00.003-04:00

Microsoft has released the Second Beta of Silverlight 2.

Announcement on Scott Guthrie's blog.

The highlights:

4.8 MB Download that does not require .NET Framework on the target system
The tools for VS 2008 will work with VS 2008 and VS 2008 SP1 beta
Adds more controls to beta 1
Cross-domain socket support
Background thread networking
Support for WCF duplex connections
Datagrid improvements
Databinding improvements
Isolated storage is now 1MB with ability to prompt user to increase storage space

Note that if you want to use VS 2008 SP1 with SL 2 Beta 2, you should install VS 2008 SP1 beta first then the SL2B2 tools.

Unity, WCF and IIS

2008-06-05T10:33:00.009-04:00

In a previous post, I showed how to integrate Unity with WCF when you are self-hosting a service. What's not clear is how to get IIS to use the Unity-enabled host when it starts hosting your service.

This is accomplished with a ServiceHostFactory. The @ServiceHost directive has an attribute named, curiously enough, Factory. This can be used to designate a class which will provide a configured ServiceHost. More on that in a moment. Let's see an example of a service that needs constructor-injection.

I've taken the default Service that Visual Studio 2008 gives you when you create a WCF Web Service, and added a SuffixProvider dependency that is satisfied in the constructor.


namespace WcfService1
{
    public class Service1 : IService1
    {
        private ISuffixProvider provider;
        public Service1(ISuffixProvider provider)
        {
            this.provider = provider;
        }

        public string GetData(int value)
        {
            return string.Format("You entered: {0}", value);
        }

        public CompositeType GetDataUsingDataContract(CompositeType composite)
        {
            if (composite.BoolValue)
            {
                composite.StringValue += provider.GetSuffix();
            }
            return composite;
        }
    }
}

namespace WcfService1
{
    public interface ISuffixProvider
    {
        string GetSuffix();
    }
}


namespace WcfService1
{
    public class MySuffixProvider : ISuffixProvider
    {
        #region ISuffixProvider Members

        public string GetSuffix()
        {
            return "estericize";
        }

        #endregion
    }
}

Using the UnityWCF project created in the previous post, I will create a factory that is derived from ServiceHostFactory, and configure a Unity container to supply a concrete implementation of ISuffixProvider. I have done this in code, most likely you will want to configure it from an XML file.


using System;
using System.ServiceModel;
using System.ServiceModel.Activation;
using Microsoft.Practices.Unity;
using UnityWCF;

namespace WcfService1
{
    public class UnityServiceHostFactory : ServiceHostFactory
    {
        protected override ServiceHost CreateServiceHost(
                                          Type serviceType, Uri[] baseAddresses)
        {
            UnityServiceHost host = new UnityServiceHost(serviceType, baseAddresses);
            UnityContainer unity = new UnityContainer();
            host.Container = unity;

            //configure container
            unity.RegisterType<ISuffixProvider,MySuffixProvider>();

            return host;
        }
    }
}

Finally, edit the Service1.svc file to reference the factory class:

<%@ ServiceHost Language="C#"
Debug="true"
Factory="WcfService1.UnityServiceHostFactory"
Service="WcfService1.Service1"
CodeBehind="Service1.svc.cs" %>

Unity and Interception

2008-06-05T10:28:00.003-04:00

Matthew Podwysocki has a good post on adding Interception capabilities to Unity via its extension model.

His conclusion:

As you can see, the extensibility model of Unity works in that we can add
interception to Unity. So, we can start thinking about moving our cross
cutting concerns to these layers should we so choose if Unity is your container
of choice. There are plenty of containers out there to choose from, so
it's best to give them all a try and pick one based upon features, programming
style, and heck, maybe even licensing.

UPDATE: It looks like the Interception Extensions that Matt mentions in his post only work with Unity 1.0. Hopefully someone will update them for Unity 1.1 soon.

Integrating Unity with WCF

2008-06-04T15:43:00.013-04:00

Update (Feb 14, 2012): I fixed an issue in the code.

You might think Unity is great and all, but how can you use it with your WCF services? You might have a service that depends on a data access object, a security object and a logger. How do you get references to these objects into your services when WCF is instanciating your service for you?

You could create static methods that locate and configure these services, like so:

MyLogger logger = MyLogger.getLogger();
MyDAO dao = MyDAO.getDao();
MySecurity security = MySecurity.getSecurityObject();

We all know why that's bad (tightly coupled). We can't change the implementation of any of these objects, or do unit testing with mocks, without changing the code.

With Unity, or any other DI container, we can configure the container and let it resolve the dependencies. Any object that is needs a reference to another object can have it injected through the constructor. All automatically. So how do we force WCF to use the Unity container to create a fully functional service instance for us with all the dependencies resolved? The key is through the magic of an InstanceProvider.

Before I reveal how this is done, I want to show three use cases that we want to be able to solve, and allude to a fourth. These three use cases will be for self-hosted WCF services.

We have a configured Unity container, and want to create a ServiceHost that will use it.
We have a configured Unity container, and an existing ServiceHost instance needs to use it.
We have an existing ServiceHost instance and want to configure it with a new Unity configuration.

Here is what these use cases will look like in code:

Case 1

// Create new ServiceHost
UnityServiceHost host = new UnityServiceHost(typeof(MyService));
host.AddServiceEndpoint(typeof(IService), binding, address);
// Set existing UnityContainer
host.Container = unity;
host.Open();

Case 2

// Create new ServiceBehavior
UnityServiceBehavior behavior = new UnityServiceBehavior();
// Set existing UnityContainer
behavior.InstanceProvider.Container = unity;
// Add behavior to ServiceHost
behavior.AddToHost(host);
host.Open();

Case 3

// let behavior create a new container
UnityServiceBehavior = new UnityServiceBehavior();
// configure new container
behavior.InstanceProvider.Container.RegisterInstance(logger);
behavior.InstanceProvider.Container.RegisterInstance(dao);
behavior.InstanceProvider.Container.RegisterType(typeof(MySecurity));
// Add behavior to ServiceHost
behavior.AddToHost(host);
host.Open();

The fourth use case is running as an IIS-hosted service, which I will leave for a future post.

Creating an InstanceProvider

When WCF needs to create an instance of a service it invokes an instance provider. The default will create the appropriate type using the default constructor, but we can add a ServiceBehavior that will substitute our custom InstanceProvider. Our provider will be configured with a Unity container and call Resolve() when asked for a new Instance.


using System;



using System.ServiceModel;

using System.ServiceModel.Channels;

using System.ServiceModel.Dispatcher;



using Microsoft.Practices.Unity;



namespace UnityWCF

{

    public class UnityInstanceProvider : IInstanceProvider

    {

        public UnityContainer Container { set; get; }

        public Type ServiceType { set; get; }



        public UnityInstanceProvider() : this(null) {

        }



        public UnityInstanceProvider(Type type)

        {

            ServiceType = type;

            Container = new UnityContainer();

        }



        #region IInstanceProvider Members



        public object GetInstance(

          InstanceContext instanceContext, Message message)

        {

            return Container.Resolve(ServiceType);

        }



        public object GetInstance(

          InstanceContext instanceContext)

        {

            return GetInstance(instanceContext, null);

        }

        public void ReleaseInstance(

          InstanceContext instanceContext, object instance)

        {

        }

        #endregion

    }

}

Create the Service Behavior

The Service Behavior's ApplyDispatchBehavior method will be called before the service is instanciated. This is the point where we create and configure our InstanceProvider. The AddToHost method is used to add the behavior to the ServiceHost, ensuring that it is only added once.






using System.ServiceModel;

using System.ServiceModel.Channels;

using System.ServiceModel.Description;

using System.ServiceModel.Dispatcher;



using Microsoft.Practices.Unity;

using System.Collections.ObjectModel;



namespace UnityWCF

{

    public class UnityServiceBehavior : IServiceBehavior

    {

        public UnityInstanceProvider InstanceProvider

               { get; set; }



        private ServiceHost serviceHost = null;



        public UnityServiceBehavior()

        {

            InstanceProvider = new UnityInstanceProvider();

        }

        public UnityServiceBehavior(UnityContainer unity)

        {

            InstanceProvider = new UnityInstanceProvider();

            InstanceProvider.Container = unity;

        }

        public void ApplyDispatchBehavior(

          ServiceDescription serviceDescription,

          ServiceHostBase serviceHostBase)

        {

            foreach (ChannelDispatcherBase cdb

                 in serviceHostBase.ChannelDispatchers)

            {

                ChannelDispatcher cd

                   = cdb as ChannelDispatcher;

                if (cd != null)

                {

                    foreach (EndpointDispatcher ed

                                    in cd.Endpoints)

                    {

                        InstanceProvider.ServiceType

                             = serviceDescription.ServiceType;

                        ed.DispatchRuntime.InstanceProvider

                             = InstanceProvider;



                    }

                }

            }

        }

        public void AddBindingParameters(

            ServiceDescription serviceDescription,

            ServiceHostBase serviceHostBase,

            Collection<ServiceEndpoint> endpoints,

            BindingParameterCollection bindingParameters) { }



        public void Validate(

            ServiceDescription serviceDescription,

            ServiceHostBase serviceHostBase) { }



        public void AddToHost(ServiceHost host)

        {

            // only add to host once

            if (serviceHost != null) return;

            host.Description.Behaviors.Add(this);

            serviceHost = host;

        }

     }

}

Creating the ServiceHost

The UnityServiceHost will encapsulate a UnityContainer and configure itself with the appropriate InstanceProvider and ServiceBehavior, so that the container will be used to Resolve instances when needed.


using System;

using System.ServiceModel;



using Microsoft.Practices.Unity;



namespace UnityWCF

{

    public class UnityServiceHost : ServiceHost

    {

        public UnityContainer Container { set; get; }



        public UnityServiceHost()

            : base()

        {

            Container = new UnityContainer();

        }



        public UnityServiceHost(

            Type serviceType,

            params Uri[] baseAddresses)

            : base(serviceType, baseAddresses)

        {

            Container = new UnityContainer();

        }



        protected override void OnOpening()

        {

            new UnityServiceBehavior(Container)

                       .AddToHost(this);

            base.OnOpening();

        }

    }

}

I have to credit Oran Dennison who showed how to integrate WCF and Spring.NET.

More on the Unity Application Block

2008-06-04T15:23:00.006-04:00

Microsoft has taken another stab at releasing a Dependency Injection container with the release of Unity. Unity 1.1 has been bundled into the Enterprise Library 4.0.

Unity is basically a slimmed-down version of ObjectBuilder without the support for interceptors.

Here's an interview with Chris Tavares, the lead developer of Unity.

RB: There are quite a few DI containers already, what was the motivation by your team in creating Unity?

CT: Patterns & practices has been giving guidance around dependency injection for a while now. CAB, Mobile client Software Factory, Smart Client Software Factory, Web Client Software Factory, and Enterprise Library have all used DI in various ways. That last word is the killer: “various”. Each project, although they were all build on ObjectBuilder, did DI differently and incompatibly. Having an explicit, fully featured container that we can use unencumbered allows us to provide better guidance around DI and container based architectures.

There are other reasons as well. We have customers that will not touch open source software for whatever reason. Having a DI container from Microsoft makes them feel safer and lets them get the advantages. It also puts them in a good position to later switch containers if they wish.

Another goal is to raise the profile of Dependency Injection both inside and outside of Microsoft. Having a container from Microsoft helps promote DI both to the general Microsoft .NET developer community and internal Microsoft developers as well.

Interceptors would be a good addition to Unity. This would allow deployment-time configuration of cross-cutting concerns, such as logging, performance monitoring, exception handling and security.

Common WCF Security Scenarios

2008-06-03T17:44:00.006-04:00

Internet Unsecured Client and Service

An example of a public, unsecured client and service.

Intranet Unsecured Client and Service

A basic Windows Communication Foundation (WCF) service developed to provide information on a secure private network to a WCF application.
Transport Security with Basic Authentication
The application allows clients to log on using custom authentication.

Transport Security with Windows Authentication
Shows a client and service secured by Windows security.

Transport Security with an Anonymous Client
This scenario uses transport security (such as HTTPS) to ensure confidentiality and integrity.

Transport Security with Certificate Authentication
Shows a client and service secured by a certificate.

Message Security with an Anonymous Client
Shows a client and service secured by WCF message security.

Message Security with a User Name Client
The client is a Windows Forms application that allows clients to log on using a domain user name and password.

Message Security with a Certificate Client
Servers have certificates, and each client has a certificate. A security context is established through Transport Layer Security (TLS) negotiation.

Message Security with a Windows Client
A variation of the certificate client. Servers have certificates, and each client has a certificate. A security context is established through TLS negotiation.

Message Security with a Windows Client without Credential Negotiation
Shows a client and service secured by a Kerberos domain.

Message Security with Mutual Certificates
Servers have certificates, and each client has a certificate. The server certificate is distributed with the application and is available out of band.

Message Security with Issued Tokens
Federated security that enables the establishment of trust between independent domains.

Trusted Subsystem
A client accesses one or more Web services that are distributed across a network. The Web services access additional resources (such as databases or other Web services) that must be secured.

from MSDN

Using a Client Certificate to Restrict Access to a WCF Service Method

2008-06-03T16:09:00.003-04:00

This post is based on this article.

Service Configuration

We are going to configure our service for Transport and Message Security with a client certificate, and we are going to add an attribute to a service method to restrict access only to clients that present the correct certificate. We will use the WSHttpBinding. The port is already configured for https from this post.

First configure the binding:

WSHttpBinding binding = new WSHttpBinding();
binding.Security.Mode = SecurityMode.TransportWithMessageCredential;
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate;
binding.Security.Message.ClientCredentialType = MessageCredentialType.Certificate;

To designate the certificate that is permitted to access the service method, you will need to know the subject name and thumbprint of the certificate. Import System.Security.Permissions and decorate the method with the following attribute:

[PrincipalPermission(SecurityAction.Demand,
Name = "CN=joeuser.example.com; ddf5066afceb34a95ff75795ced345ff549464202")]

Here the Name parameter is equal to the certificate Subject followed by a semi-colon, a space, then the certificate Thumbprint. Multiple attributes can be added to support more than one client certificate. The final configuration option is to set the mode on the service to map the certificate information to this format (Subject; Thumbprint). This is done through the ServiceBehaviorAuthorizationMode (set it to UseAspNetRoles). You will need to import System.ServiceModel.Description.

ServiceHost host = ...
ServiceAuthorizationBehavior b = host.Description.Behaviors.Find();
b.PrincipalPermissionMode = PrincipalPermissionMode.UseAspNetRoles;

Client Configuration

Now we need to tell the client which certificate to present to the service. The same method is called whether you are using a Client Proxy or have created a ChannelFactory. I will show the example using a ChannelFactory. This must be done before creating the Channel.

factory.Credentials.ClientCertificate.SetCertificate(
System.Security.Cryptography.X509Certificates.StoreLocation.LocalMachine,
System.Security.Cryptography.X509Certificates.StoreName.My,
System.Security.Cryptography.X509Certificates.X509FindType.FindBySerialNumber,
"1a2fa58b000000003a5c");

In this case, I am looking it up by Serial Number, but the certificate can be found by Thumbprint, Subject Name, or a number of other fields. Again, use the MMC Certificate Snap-in to look up the information.

That's all there is to it.

Configuring a WCF Binding for https

2008-06-03T12:50:00.005-04:00

Both BasicHttpBinding and WSHttpBinding support Transport Security (https). However, neither do it by default. The binding must be configured correctly. Here is how to do it in code:

BasicHttpBinding binding = new BasicHttpBinding();
binding.Security.Mode = BasicHttpSecurityMode.Transport;

or simply

BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);

For WSHttpBinding:

WSHttpBinding binding = new WSHttpBinding();
binding.Security.Mode = SecurityMode.
TransportWithMessageCredential;
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows;

Here is a summary of the System-provided Bindings. Note that the NetTcp bindings have Transport security (encryption) enabled by default.

Configuring a port for SSL/TLS

2008-06-03T10:54:00.015-04:00

Note that what we usually refer to as SSL is now really TLS (Transport Layer Security).
--------------
If you want to use Transport Security with your http WCF service, there are two options:

Host your service in IIS.
Configure a port for SSL/TLS and self-host your web service. This will allow you to create a Windows Service that runs your web service over https.

Either way, you will need a certificate that identifies your host as trusted to the client and provides the public and private keys that are used for negotiating the encrypted transfer. For a production environment you will need to obtain the certificate from a Certificate Authority (CA).

For development and testing, we can create our own CA and then issue a test certificate from that CA. It can't be used in production because the clients will not have a trusted relationship with that CA, but we will configure our test client to trust it. You will need the MMC snap-in from my previous post. Run MMC and Open the SSL Snap-in that you previously configured. This way you will see the certificates as they are created in the Certificate Store.

You will also need the makecert.exe tool. You will have it if you have Visual Studio or the .NET Framework SDK. Go to your Start Menu and run the appropriate Command Line Environment.

Finally, you will need httpcfg.exe (download for Windows XP SP2). Vista users will use netsh.exe. This tool will be used to associate the certificate with the port.

The instructions for creating the certificate are based on Chris Jackson's post.

Create the CA certificate

At the command line (all one command),

makecert -pe -n "CN=Test and Dev Root Authority" -ss my -sr LocalMachine -a sha1 -sky signature -r "Test and Dev Root Authority.cer"

Now, if you look in the Local Computer (-sr LocalMachine) section of the SSL Certificates MMC Console, you will find a certificate in the Personal\Certificates folder (-ss my). You may need to refresh (F5) the folder.

Create the Test Certificate

Next, we will create the certificate to be assigned to the port. The name of the certificate must match the hostname in the URL that the client will use to access the service. Otherwise, the client will refuse to complete the handshake. Sometimes you get this error in your browser when the certificate name does not match the URL. Just as in the browser scenario, it is possible to configure the WCF client to ignore the mismatch, but I will leave that to a future post.

If you want to access the service via https://testserver:8081/service, enter the following at the command line (all one command),

makecert -pe -n "CN=testserver" -ss my -sr LocalMachine -a sha1 -sky exchange -eku 1.3.6.1.5.5.7.3.1 -in "Test and Dev Root Authority" -is MY -ir LocalMachine -sp "Microsoft RSA SChannel Cryptographic Provider" -sy 12 "Test and Dev SSL.cer"

Again, you will find a new certificate in the Personal\Certificates folder on the Local Computer main node. If you double-click to view it you will see that it is not trusted. That is because your computer does not trust the CA certificate that we made and used to sign the testserver certificate.

Trust the CA

To trust the new CA certificate drag it from the Personal\Certificates folder to the Trusted Root Certificate Authorities\Certificates folder below it. Now if you open the testserver certificate, it will show as valid.

Configure the port for https

The last step is to configure a port (8081 in this example) to use the testserver certificate for SSL/TLS. The HTTP.SYS driver will use the certificate's thumbprint to look it up in the certificate store, so open the testserver certificate and go to the details tab. Scroll to the bottom and select the Thumbprint property. The text box below it will show the value with spaces:
71 d1 ea 2b 7d 2e cf 75 ac a5 60 1f 66 94 9b b6 ee aa be 44.

We will use the httpcfg.exe command to configure it. It is probably located in C:\Program Files\Support Tools. You will need to remove the spaces from the thumbprint hash value.

httpcfg set ssl -i 0.0.0.0:8081 -h 71d1ea2b7d2ecf75aca5601f66949bb6eeaabe44 -f 2

The -f 2 option will allow us to use client certificates to authenticte the client in a later post. The 0.0.0.0 IP address means all IP addesses on the computer. If you only want to associate it with a single IP address, use that one.

Now you can configure your service to listen on https.

Viewing SSL/TLS Certificates

2008-06-02T15:49:00.005-04:00

When setting up self-hosted WCF services to run under https, it's useful to be able to view the Certificates that are installed and discover their thumbprints (hash values).

These articles explain:

How to View Certificates with the MMC Snap-in.

How to retrieve the Thumbprint of a Certificate.

Once you have the hash value for the certificate, it is used as a lookup by the HTTP.SYS driver to locate the server certificate that will be used for https encryption/decryption. I'll explain how to configure the HTTP.SYS driver for SSL/TLS in a future post.

WCF Books

2008-05-31T20:02:00.005-04:00

Learning WCF: A Hands-on Guide by Michele Leroux Bustamante
A good beginners guide to WCF.

Programming WCF Services by Juval Lowy
Explains the architectural aspects of WCF and how it was engineered.

Essential Windows Communication Foundation (WCF): For .NET Framework 3.5 by Steve Resnick, Richard Crane, Chris Bowen
Good guide to the changes introduced by Visual Studio 2008 and .NET 3.5

Inside Windows Communication Foundation by Justin Smith
This is a great reference to WCF internals. Advanced programmers only.

New from Microsoft Patterns and Practices

2008-05-31T17:36:00.001-04:00

Microsoft p&p has recently released the following:

Enterprise Library 4.0 (VS 2008 support) – no public APIs have been changed from 3.1
Smart Client Software Factory (SCSF) for VS 2008
Web Service Software Factory Modeling Edition (WSSF:ME) for VS2008
Unity 1.1 – a new Dependency Injection container based on the old DI AppBlock

Visual Studio 2008 SP1 Beta and .NET 3.5 SP1 Beta

2008-05-31T17:31:00.000-04:00

Here is Scott Guthrie's announcement.

The service packs are scheduled to RTM this summer.

I think the following are useful features:
- Faster application startup times
- .NET Framework Client Profile: only includes the client side libraries for a smaller download.
- ClickOnce improvements
- WPF Improvements
- The ADO.NET Entity Framework and LINQ to Entities (yay!)
- Astoria: a REST-based data service
- WCF improvements

Microsoft Visual Studio 2008 Training Kit

2008-05-31T17:23:00.000-04:00

Microsoft has released a training kit for Visual Studio 2008.

Overview
The Visual Studio 2008 and .NET Framework 3.5 Training Kit includes presentations, hands-on labs, and demos. This content is designed to help you learn how to utilize the Visual Studio 2008 features and a variety of framework technologies including: LINQ, C# 3.0, Visual Basic 9, WCF, WF, WPF, ASP.NET AJAX, VSTO, CardSpace, SilverLight, Mobile and Application Lifecycle Management.