Here is what my old apartment looks like for example (and click the link to play yourself – routes, free form drawing of geometries, reverse geo-code, etc. etc.

Here is the link.

So how is this possible? I’ll keep this short and if anyone needs more I’d be happy to help.

Look close at the versions. You need the new CTP of Extended Modes and the 1.0.1.0 of the two map controls.

And using Prism makes Deep Earth a joy to work with:

The demo which shows off most of below (and much more including deep zoom) check out the Movie Trailer sample of our platform. This platform can be used by anyone as a site template for media, a personal app, and is fully customizable either as Expression Encoder 3 templates (no support for 2) or controls with template parts/skin exposed customizations just like Microsoft controls.

http://www.tangentux.com/

• True HD video

• Smooth Streaming

• Go out of browser

• Mac, Windows, and Linux

• Millions of skilled developers to help you

• Seamless Designer-Developer workflow

• Monetize your assets

• Silverlight DRM, Powered by PlayReady

• Compatible with Windows Media DRM 10

• Third Party DRM Providers

• Advertising

• Lower delivery costs

• Internet Information Services (IIS) 7.0 Media Services

• Windows Media Services 2008

• Multicast Support for Silverlight

True HD video

Customers can enjoy 720/1080p true HD-quality video using H.264 (MP4/F4V) or WMV/VC-1. Use your existing Windows Media library or add support for third-party codecs.

Silverlight 3 now supports H.264 natively for playback of MP4 or F4V files. Silverlight also supports Windows Media Video (WMV) 9, which is Microsoft’s implementation of the Society of Motion Picture and Television Engineers (SMPTE) VC-1 codec standard. In addition to WMA and WMA Pro audio codecs, Silverlight supports MP3 audio and with Silverlight 3 supports MP4 standard AAC audio.

With Silverlight 3 it’s easy to add in support for managed codecs. Developers can deliver non-native Silverlight codecs via an application, and using the new Raw AV pipeline audio or video is then rendered in Silverlight.

Leveraging graphics processor unit (GPU) hardware acceleration, Silverlight experiences can now be delivered in true full-screen HD (720p+). The GPU can be used for windowed or full-screen video scaling enabling smoother playback.

Silverlight’s support for VC-1 and legacy Windows Media Video formats means that existing WMV content libraries are Silverlight-ready. Video encoded for Silverlight can be simultaneously delivered to other Windows Media compatible players on a variety of platforms and devices.

Smooth Streaming

Extend viewing times using Smooth Streaming. Adjust the quality in real-time based upon the consumer’s changing bandwidth and CPU conditions. Get minimal buffering and quick start-up time using HTTP-based adaptive streaming.

Smooth Streaming is a new extension for Internet Information Services (IIS) 7.0 Media Services, enabling adaptive streaming of media to Silverlight clients via HTTP.

Smooth Streaming dynamically detects and seamlessly switches, in real time, the video quality of a media file that a Silverlight player receives based on local bandwidth and CPU conditions. Consumers with high bandwidth connections can experience HD quality streaming while others with lower bandwidth speeds receive the appropriate stream for their connectivity, allowing consumers across the board to enjoy a compelling, uninterrupted streaming experience which leads to extended audience engagement.

Media companies can boost advertising and subscription revenues by using true HD (720p+) video with uninterrupted delivery to extend viewing times. By using Smooth Streaming, leverage the massive scale of existing HTTP infrastructure. Proprietary streaming networks have much fewer resources than HTTP and network congestion can limit access to popular content.

Live Smooth Streaming (in-beta) also enables PVR-style access and navigation to live video streams. Join events in progress and quickly seek to the beginning, rewind the highlights and enjoy the Silverlight experience in your own way.

Go out of browser

Play video whether you are connected via the Web or not. Save content locally for disconnected scenarios and update when you connect.

Mac, Windows, and Linux

When you create applications for Silverlight you’re actually creating one application that will run equally on Internet Explorer, Firefox and Safari on Windows, Mac and Linux. Silverlight on different platforms and browsers has exactly the same functionality, ensuring the same experience for all your users. Microsoft is working with Novell to offer Silverlight support for the Linux platform. The Mono Project is an open-source initiative hosted at http://www.mono-project.com/Moonlight. This is available for all major Linux distributions. Moonlight 2.0 supports C# and other Dynamic Languages, and includes controls, layout and media.

Millions of skilled developers to help you

Tap into the talent pool of six million .NET developers to find the expertise you need. A vibrant ecosystem means it’s easy to find partners and pre-built components.

Seamless Designer-Developer workflow

Accelerate time to market as designers collaborate with developers using the integration between Expression Studio’s creative tools and the Visual Studio family of development tools.

Talk to anyone building interactive applications, and they will tell you about the promise and the frustration of user experience design. Concepts that look great in photo editing tools rarely lend themselves well to actual implementation, while tools that mash together designer and developer disciplines often fall short. In organizations lucky enough to have dedicated designers, they are often forced to spend more time on programming than on actual design. While the integration of developer and designer disciplines is increasing, it is hardly the norm. This is why Microsoft® Expression® Studio was created.

Whether developing applications for the desktop or the Web, the Expression products will allow designers to fully engage with developers to finally bridge the gap in the designer/developer workflow. This will bring together the best minds in design and development to create applications and sites with a focus on great User Experience (UX).

Expression Blend shares project format, XAML, and .NET development with Visual Studio for Designer-Developer workflow; and has added support for Silverlight. This means that the designer can work on the same project as the developer, and thus requires no re-writing of code or use of exporters or clunky add-ins. It also means that developer practices can be applied to the UI mark-up, such as diff’ing and source control.

Monetize your assets

Silverlight offers a choice of content protection techniques for subscriptions: End-user authentication, SSL, Web playlists, Silverlight DRM, and Windows Media DRM.

With the explosive growth in streaming online video and rich internet experiences, it’s critical to ensure your content and your business models are secure. The new peaks in online video audiences not only create a great opportunity to explore new revenue opportunities, but to also expose the challenges in managing and protecting valuable media assets. A variety of content protection schemes, including Digital Rights Management (DRM); end-user authentication and authorization; Web Playlists; and SSL ensure that content owners can fully monetize and protect their media assets.

Silverlight DRM, Powered by PlayReady

Silverlight DRM, Powered by PlayReady is a content encryption technology designed and optimized to enable key Silverlight online content distribution scenarios including live streaming, on-demand streaming, progressive download, and adaptive streaming (e.g., IIS7 Smooth Streaming). Unlike simple stream or link encryption technologies (e.g., Adobe’s RTMP/e), Silverlight DRM, encrypts the video and audio in a secure wrapper ensuring content, including advertising, stays protected from server to Silverlight plug-in until it is decompressed during playback.

Silverlight DRM is a small, cross-platform version of the PlayReady client used exclusively by the Silverlight Web browser plug-in. Analogous to other online content services, a Silverlight service that offers protected content uses the PlayReady Server SDK (or alternatively, the WM Rights Manager 10.1 SDK) to first package (encrypt) the Windows Media Audio (WMA) and Windows Media Video (WMV) content. When a consumer then wants to play that content a license is requested and obtained from a license acquisition server that uses the PlayReady Server SDK.

The Silverlight plug-in includes an individualized PlayReady client acquired from an online service, hosted by Microsoft. Individualization binds the run-time client to the computer on which the client was initially installed. Every end-user is given an individualized Playready component and different certified license keys. This significantly reduces the danger of global breaks. If a specific version of a PlayReady client becomes compromised, it can be barred from acquiring licenses for new digital media files unless the latest version of the PlayReady client is downloaded that is robust against the circumvention.

Compatible with Windows Media DRM 10

Silverlight DRM allows content owners to deliver their protected content using either legacy WMDRM10 or new PlayReady encryption. This enables content owners to deliver existing libraries of WMDRM10 content to Silverlight without having to re-encrypt anything and means that the same protected content can be played back in both Silverlight and Windows Media based-clients.

Third Party DRM Providers

With the extensibility and openness of Silverlight, third-parties are able to build content protection solutions, extending customer choice and opening up infrastructure options.

SKY player in Silverlight using Silverlight DRM, Powered by PlayReady

Advertising

Silverlight, approved by the Interactive Advertising Bureau (IAB), supports all leading advertising scenarios, including linear pre-rolls, post-rolls, interstitials as well as non-linear tickers, bugs and transparent overlays.

As the market for online advertising continues to grow, the technology powering rich media-based ads needs to be up for the challenge. Complex business needs and creative capabilities demand more than simple animation and basic tagging – which is where Silverlight comes in. Silverlight enables lightning-fast development through familiar markup and controls based on XML that, combined with integrated productivity tools such as Expression Studio and Visual Studio, helps designers and developers work better together and push the limits of interactive innovation.

When designers and developers work together to bring advertising ideas to life, campaigns can be more nimble, more powerful and more effective. Silverlight enables agencies and advertisers to create, launch, measure, and quickly respond to online advertising campaigns through powerful controls and fully integrated tools.

Benefits of Silverlight for Rich Media and In-stream Advertising

• User Engagement
  Silverlight powers the most compelling media experiences on the Web for rich media and in-stream advertising, offering the most effective engagement and conversion opportunities for advertisers
• Discoverability
  Silverlight is the most discoverable rich media ad platform with superior SEO capabilities
• Analytics
  Silverlight supports robust and complex online advertising reporting and analytics to enable effective campaign response and measurement

Online campaigns created with Silverlight can be more engaging, discoverable, and accountable than with other technologies

Lower delivery costs

Leverage existing HTTP infrastructure and improve delivery over proprietary streaming servers. Use multicast for Intranet-based executive broadcasts and online training.

Windows Server helps content providers realize new levels of reliability and scalability, all with lower-cost content delivery. Windows Server represents a significant competitive edge when delivering streaming media and/or applications cross-platform and cross-device, and is already in use by most major broadcasters around the world. Windows Server now powers HTTP-based adaptive streaming via Smooth Streaming.

Internet Information Services (IIS) 7.0 Media Services

IIS Media Services is the new name (previously IIS Media Pack) for the media-relevant extensions for IIS. With IIS Media Services, Microsoft is offering an integrated media delivery platform for customers interested in delivering media over HTTP-based adaptive streaming, a new hybrid technique for content delivery. IIS Media Services provides an easy to deploy and manage set of capabilities for companies interested in taking advantage of the inherent scale and availability advantages that come with using standards-based HTTP as a media delivery protocol.

IIS Media Services provides the fundamental features of a proprietary streaming solution: bit rate throttling, secure playlists and logging capabilities that are required for cost effectively delivering, measuring and monetizing media content. On top of these basic media delivery features, IIS Media Services offers enhanced media delivery capabilities such as on-demand and live adaptive streaming (Smooth Streaming) which makes true HD (720p+) media experiences practical as well as real-time logging and analytics capabilities for measuring and maximizing return on your media investment.

Windows Media Services 2008

Windows Media Services, like all of Windows Server 2008, is significantly more secure, reliable, and robust — and it is already considered by many customers to be the best in the market for live and n-demand streaming delivery using “traditional” streaming. The latest improvements provide twice the scalability over Windows Media Services 9.0.

In addition to its proven scalability and reliability, Windows Media Services now supports a Server Core installation, enabling reduced footprints for fixed-function streaming server scenarios, offering embedded appliance-like performance. Additionally, a cache/proxy plug-in is built in, making it easier to configure WMS for edge network enterprise and Internet topologies. Many features of Windows Media Services that were previously available only on Windows Server Enterprise and Datacenter are now available on Windows Server Standard, and all Standard features are now also available on Windows Web Server 2008. This makes the power of Windows Media Services 2008 available to a broader set of users at a lower cost.

Multicast Support for Silverlight

Windows Media Services, together with Silverlight and a third-party open-source plug-in from QUMU, can support multicast-enabled scenarios for executive broadcasts and training scenarios behind the firewall.

Click Here to Watch What’s New

9 our of 10 studies prove: Resharper make your your hair grow back, your dog come home (yes even if he died), your wife will love you again and your kids will listen to you.

OK perhaps it is not a country music song played backwards.

BUT your nuts to even think about wasting all that time not using it. For someone who knows it is people not tools that always win, this is my only exception in 20 years that I will stand behind.

Why stare at a keyboard for hours wondering how to navigate a nasty tangled refactoring you know you must do when you can do the right thing AND make the 5:30 train.

Me? I hit the shift-ctrl-space repeatedly and am shocked when nothing happens. Then I install it and life is good again.

ReSharper 4.5 Released

April 8, 2009

In This Issue

Introduction
Performance and Memory Usage Improvements
Solution-Wide Code Inspections

VB9 Support
Extended Naming Style Configuration
Other Enhancements

Introduction

ReSharper 4.5 is finally out, so your next productivity upgrade is just a mouse click away!

As announced, the new version features major improvements in performance and memory usage. After all, what is a productivity tool for if not for being agile, robust and responsive?

In addition to focusing on performance enhancements, we also added a number of intelligence features and improvements.

We’ve prepared a short Flash movie to introduce the new features in ReSharper 4.5. Get the hang of things in just a few minutes!

For users of older versions we have a ReSharper 3.0 vs. ReSharper 4.5 Comparison matrix.

However, if you believe a thousand words say more than a picture does, or even a movie, go ahead and read the descriptions below :)

Alex Morozov
NET product marketing manager 
JetBrains

Performance and Memory Usage Improvements

We have managed to make ReSharper load and work faster and more smoothly in general, particularly on big (and we mean BIG) solutions:

• Wall-time measurements of solution loading show 20 to 40 percent acceleration until the solution is ready for code editing.
• Web site loading time has also been reduced by a third.
• For instance, a certain mixed-language solution consisting of about 15 thousand classes now takes only 70 seconds to load, and this includes making every ReSharper feature available.

The list of significantly accelerated operations includes:

• renaming symbols
• finding commonly used symbols
• creating symbols from usage
• analyzing large XAML files.

We’ve also cut down the volume of memory resources required to analyze jumbo autogenerated code files, which should especially benefit those who work with ASP.NET and LINQ to SQL.

Solution-Wide Code Inspections

To enable you to detect unused non-private members on the fly, we have enlisted the help of our ever-improving solution-wide analysis. We have introduced a set of specialized code inspections that only work when you let ReSharper analyze your whole solution. They help you discover:

• Unused non-private declarations
• Unused return values of non-private methods
• Unaccessed non-private fields
• Unused parameters in non-private members
• Abstract or virtual events that are never invoked
• Unassigned fields
• Members and types that can be made internal instead of public

Look for these inspections in your code and on the Marker Bar, highlighted as warnings or suggestions. In addition, new code annotations are available that you can use to mark certain unused non-private types and members to prevent ReSharper from fussing about them.

VB9 Support – We can forgive this transgression (Damon)

Visual Basic .NET developers can now benefit from VB9 language support that includes implicitly typed local variables, object initializers, anonymous types, extension methods, lambda expressions, partial methods, and embedded XML. VB9 support is all around you, courtesy of new context actions, code completion, refactorings, and Parameter Info, among other supporting features.

Extended Naming Style Configuration

Now you can define custom naming style settings for different languages and symbols including:

• types
• namespaces
• interfaces
• parameters
• method properties and events
• static and instance fields, etc.

For every kind of symbol, you can configure one of five casing options, prefixes and suffixes, variations for different access rights, abbreviations to preserve, or enable naming inspections. As a result, you can precisely align the way ReSharper completes and generates code with your specific coding guidelines.

Other Enhancements

• Go to Implementation – This new navigation feature lets you jump from usage of a base type or member to any of its end implementations, bypassing intermediate steps in the inheritance chain.
• New and Improved Refactorings – ReSharper 4.5 has added Inline Field to its family of Inline refactorings. Rename refactoring now provides name completion, and some of the other refactorings were thoroughly refactored themselves, to make them perform faster.
• Native MSTest Support – Initially available through VstsUnit Plugin and then Gallio, MSTest support has finally made its way to being provided natively in ReSharper, on par with nUnit.
• Wider Cross-Language Capabilities – Quick-fixes and context actions work better in many cross-language scenarios: for example, you can extend a control written in VB.NET+XAML by choosing "create from usage" right from a C# usage. Add increased coverage for XAML and ASP.NET, and you get a substantial package of improvements.
• Smoother Language and Framework Support – Following the tradition of ReSharper 4.1, we have improved compatibility with F#, Compact Framework, Silverlight 2, and other languages and tools.

Grab your all-new productivity – download ReSharper 4.5 now at http://www.jetbrains.com/resharper/download.

ReSharper 4.5 is provided as a free upgrade from ReSharper 4.0. If you own an older version, please contact us to check your upgrade availability at sales@jetbrains.com.

JetBrains Team

• Sergey
  Anchipolevsky

• Igor
  Alshannikov

• Alexander
  Anisimov

• Dmitry
  Avdeev

• Sergey
  Baranov

• Yury
  Belyaev

• Natalia
  Belyaeva

• Elena
  Bukreeva

• Bulenkov
  Konstantin

• Jana
  Charif

• Nikolay
  Chashnikov

• Alexander
  Chernikov

• Roman
  Chernyatchik

• Sergey
  Coox

• Sergey
  Dmitriev

• Ilia
  Dumov

• Kirill
  Falk

• Michael
  Gerasimov

• Sergey
  Golovachev

• Alexey
  Gopachenko

• Peter
  Gromov

• Michaela
  Hroncová

• Dmitry
  Jemerov

• Maria
  Khalusova

• Valentin
  Kipiatkov

• Cyril
  Konopko

• Anna
  Kozlova

• Mikhail
  Kropotov

• Eugene
  Kudelevsky

• Alexey
  Kudravtsev

• Olga
  Lobacheva

• Vyacheslav
  Lukianov

• Anton
  Makeev

• Egor
  Malyshev

• Maria
  Marakulina

• Kirill
  Maximov

• Sasha
  Maximova

• Irina
  Megorskaya

• Lucie
  Morawiecova

• Alexander
  Morozov

• Maxim
  Mossienko

• Ekaterina
  Musienko

• Ann
  Oreshnikova

• Eugene
  Pasynkov

• Vaclav
  Pech

• Alexey
  Pegov

• Eugene
  Petrenko

• Irina
  Petrovskaya

• Mikhail
  Pilin

• Julia
  Repina

• Elizaveta
  Revyakina

• Ilya
  Ryzhenkov

• Andrew
  Serebryansky

• Ilya
  Sergey

• Maxim
  Shafirov

• Tatiana
  Slavina

• Olesya
  Smirnova

• Konstantin
  Solomatov

• Oleg
  Stepanov

• Pavel
  Sher

• Ekaterina
  Shliakhovetskaja

• Oleg
  Shpynov

• Gregory
  Shrago

• Eugene
  Toporov

• George
  Udov

• Sergey
  Vasiliev

• Natalie
  Yaremych

• Yegor
  Yarko

• Timur
  Zambalayev

• Sergey
  Zhukov

• Eugene
  Zhuravlev

• Alexander
  Zverev

But not just RIA style usability, I believe we pushed the envelope even further by incorporating not only DeepZoom (SeaDragon) for ‘zoom in to the pixel’ resolution, but the 3D extensions not present by default

(you have the essentials but only the amazingly talented people behind the Hard Rock Memorabilia site (vertigo) have shown this style of combined zoom/3d that we have seen in any largely deployed sample).

Click the image here to launch the Silverlight 2.0 cross-platform goodness.

NOTE: A prize goes to the first person to email us at: innovate@domaindotnet.com the exact number of seconds it would take to complete the ‘applying attributes’ to the .gif file (you need to see the demo to understand).

Related Posts

• Vertigo: DeepZoom

from tag wcf

• WCF Windsor Integration

from tag WCF

• Software as a Service – A Pattern Language Approach

from tag silverlight

• Will’s Blog – Silverlight 2 Birthday Widget, Part II
• The Official Microsoft Silverlight Site

from tag SOA

• Advanced Concepts in Software as a Service / Service Oriented Architecture
• The Collision of Software Project Management and Agile

from tag sharepoint

• Business Data Catalog
• SharePoint RSS Alpha
• Templates for SharePoint
• Creating a Web Part with Custom Properties
• SharePoint Creating XSLT DataView
• SmartPart for SharePoint – Home
• Windows SharePoint Services 3.0

from tag Linq

• Speed Dial
• CruiseControl.NET
• The Pragmatic Bookshelf
• map
• Register – InnerWorkings

 can

you

find

the

ghosts?

click me and be prepared

Send a screen shot if you find them to : innovate@domaindotnet.com and the best image will recieve some swag! Non-trivial swag as well! 

Related Posts

• Business Data Catalog
• SharePoint RSS Alpha
• Templates for SharePoint
• Creating a Web Part with Custom Properties
• SharePoint Creating XSLT DataView
• SmartPart for SharePoint – Home
• Windows SharePoint Services 3.0

from tag C#

• Video Favorites
• S#arp Architecture: ASP.NET MVC with NHibernate – Home
• Skills Matter OPEN SOURCE .NET
• Home :: Castle Project
• NHibernate 2.0 gold Released – Must Wait for ‘Linq to NHibernate’ « ubiquitous fluency

(more..)

This post gets you Linq access to the GAC with no fuss.

Fusion is wrapped for you so no need to understand the unmanaged stuff unless you want to. Your up and running with GAC as a new Linq to Objects source in minutes.

The Big Picture of the Project (You can skip to the next section if you just want the GAC code)

Note: The reason both the Gac and MyEnvironment IEnumerable<T> references below are different? See the reference on the bottom right of the picture into the entry point to all of it (ThisBox)?

Introduction to the Fusion  IEnumerable Wrapper

A simple case. I want to know how my GAC is broken into ‘Major Vendors’. We assume this is roughly the first part of the name. (i.e. Microsoft.System = Microsoft).

Oh yeah. Exclude the assemblies that only occur once. We are looking for the larger view here.

Here is an easy solution:

        [Fact]
        public void should_show_gac_by_vendor()
        {
            var result = from matchedAssembly in ThisBox.By<AssemblyDetail>()
                         group matchedAssembly by
                             matchedAssembly.MajorName
                             into grouping
                             where grouping.Count() > 1
                             orderby grouping.Count() descending
                             select grouping;

            var TotalSum = result.Sum(ad => ad.Count());

            Console.WriteLine("** ASSEMBLIES BY NAME WITH > 1 REGISTERED  = {0} ***", TotalSum);

            foreach (var firstGroup in result)
            {
                var groupCount = firstGroup.Count();
                Console.WriteLine("Group '{0}' Assemblies={1} Percent={2} Public Keys Used={3}",
                                    firstGroup.Key,
                                    groupCount,
                                    groupCount.ToPctString(TotalSum),
                                    firstGroup.Select(ad => ad.PublicKey).Distinct().Count()
                                    );
            }
        }

** ASSEMBLIES BY NAME WITH > 1 REGISTERED  = 664 ***

Group ‘Microsoft’ Assemblies=466 Percent=70.18% Public Keys Used=5
Group ‘DevExpress’ Assemblies=73 Percent=10.99% Public Keys Used=2
Group ‘System’ Assemblies=71 Percent=10.69% Public Keys Used=4
Group ‘Policy’ Assemblies=14 Percent=2.11% Public Keys Used=2
Group ‘FSharp’ Assemblies=11 Percent=1.66% Public Keys Used=1
Group ‘VLinq’ Assemblies=10 Percent=1.51% Public Keys Used=1
Group ‘policy’ Assemblies=6 Percent=0.9% Public Keys Used=2
Group ‘PresentationFramework’ Assemblies=5 Percent=0.75% Public Keys Used=1
Group ‘mscorcfg’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘WebDev’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘VSTADTEProvider’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘VsWebSite’ Assemblies=2 Percent=0.3% Public Keys Used=1

Try that with GacUtil (grin)..

C# GAC IEnumerable<Assembly> implementation

Ah yes the GAC Fusion wrapper code.  Thanks to Debasish Bose for his help here.

C# Fusion Gac Enumerable : Domain.Dot.Net Team

    /// <summary>
    /// Just to have some room to breath
    /// </summary>
    public class AssemblyDetail : AssemblyDetailBase
    {
        public AssemblyDetail(IAssemblyName currentAssembly) : base(currentAssembly) {}

        public override String FullName
        {
            get
            {
                return _fullName;
            }
        }
        public override string Version
        {
            get
            {
                return _versionString;
            }
        }
        public override int Major
        {
            get
            {
                return VersionComponent(0);
            }
        }
        public override int Minor
        {
            get
            {
                return VersionComponent(1);
            }
        }
        public override int Revision
        {
            get
            {
                return VersionComponent(2);
            }
        }
        public override int Build
        {
            get
            {
                return VersionComponent(3);
            }
        }

        public override string PublicKey
        {
            get
            {
                return _pkey;
            }
        }
        public override string MajorName
        {
            get
            {
                return _majorName;
            }
        }
        public String Name
        {
            get
            {
                return _fullName;
            }
        }

        int VersionComponent(int position)
        {
            return _version.Length <= position + 1
                           ? Convert.ToInt32(_version[position]) : 0;
        }
    }

    #region

    using System;
    using System.Runtime.InteropServices;

    #endregion

    /// <summary>
    /// Alpha - Comment and Add Regressions
    /// </summary>
    public abstract class AssemblyDetailBase
    {
        protected string _fullName;
        protected string _majorName;
        string[] _nameSplit;
        protected string _pkey;
        string _rawname;
        protected string[] _version;
        protected string _versionString;

        /// <summary>
        /// Initializes a new instance of the <see cref="AssemblyDetailBase"/> class.
        /// </summary>
        /// <param name="Current">The current.</param>
        protected AssemblyDetailBase(IAssemblyName Current)
        {
            ExtractParsedDetail(Current);
        }

        public abstract string FullName
        {
            get;
        }
        public abstract string Version
        {
            get;
        }
        public abstract int Major
        {
            get;
        }
        public abstract int Minor
        {
            get;
        }
        public abstract int Revision
        {
            get;
        }
        public abstract int Build
        {
            get;
        }
        public abstract string PublicKey
        {
            get;
        }
        public abstract string MajorName
        {
            get;
        }

        /// <summary>
        /// I do not want to persist the IAssemblyName
        /// as it might introduce a COM reference when
        /// we just can extract what we need and let it
        /// pass away into whatever...
        ///
        /// Extracts the parsed detail.
        /// </summary>
        /// <param name="Current">The current.</param>
        void ExtractParsedDetail(IAssemblyName Current)
        {
            const int stongKeyPosition = 3;
            const int versionPosition = 1;

            // Main Work Happens Here
            _fullName = GetDisplayName(Current);

            // Simply parse the ", " that seperates the full
            // name
            var _parsedDetails = _fullName.Split(new[]
                                                 {
                                                         ", "
                                                 }, StringSplitOptions.RemoveEmptyEntries);

            ExtractVersionInfo(versionPosition, _parsedDetails);
            ExtractAddition(stongKeyPosition, _parsedDetails);
        }

        void ExtractAddition(int stongKeyPosition, string[] parsedDetails)
        {
            _pkey = parsedDetails[stongKeyPosition];
            _rawname = parsedDetails[0].Trim();
            _nameSplit = _rawname.Split('.');
            _majorName = _nameSplit[0].Trim();
        }

        /// <summary>
        /// Gets the display name from the unmanaged pointer
        /// </summary>
        /// <param name="aName">A name.</param>
        /// <returns></returns>
        static string GetDisplayName(IAssemblyName aName)
        {
            var displayFlags = AssemblyNameDisplayFlags.ALL;

            uint uiLen = 0;

            string _displayAssemblyName = null;

            // Get the length
            aName.GetDisplayName(IntPtr.Zero, ref uiLen, (uint) displayFlags);

            if (uiLen > 0)
            {
                var byteBuffer = new byte[(uiLen + 1)*2];
                unsafe //turn on sunsafe in project properties
                {
                    fixed (byte* numRef1 = byteBuffer)
                    {
                        var ptr1 = new IntPtr(numRef1);
                        aName.GetDisplayName(ptr1, ref uiLen, (uint) displayFlags);
                        _displayAssemblyName = Marshal.PtrToStringUni(ptr1);
                    }
                }
            }

            return _displayAssemblyName;
        }

        /// <summary>
        /// Extracts the version info.
        /// </summary>
        /// <param name="versionPosition">The version position.</param>
        /// <param name="parsedDetails">The parsed details.</param>
        void ExtractVersionInfo(int versionPosition, string[] parsedDetails)
        {
            var versionLiteral = parsedDetails[versionPosition];
            _versionString = ToCoreVersion(versionPosition, versionLiteral);
            if (_versionString != String.Empty)
                _version = _versionString.Split('.');
        }

        /// <summary>
        /// Gets the nice clean x.x.x.x string
        /// </summary>
        /// <param name="versionPosition">The version position.</param>
        /// <param name="versionLiteral">The version literal.</param>
        /// <returns></returns>
        static string ToCoreVersion(int versionPosition, string versionLiteral)
        {
            var returnVal = String.Empty;

            if (!String.IsNullOrEmpty(versionLiteral))
            {
                var _indexOf = versionLiteral.IndexOf("=");

                if (_indexOf != -1)
                    returnVal = versionLiteral.Substring(_indexOf + versionPosition);
            }

            return returnVal;
        }
    }

#region

using System.Runtime.InteropServices;

#endregion

class GAC
{
    GAC() {}

    [DllImport("Fusion.dll", CharSet = CharSet.Auto)]
    public static extern int CreateAssemblyEnum(out IAssemblyEnum ppEnum,
                                                IApplicationContext pAppCtx,
                                                IAssemblyName pName, uint dwFlags,
                                                int pvReserved);
}

#region

using System.Runtime.InteropServices;
using System.Security;

#endregion

[SuppressUnmanagedCodeSecurity, ComImport, Guid("7C23FF90-33AF-11D3-95DA-00A024A85B51"),
 InterfaceType(1)]
public interface IApplicationContext
{
    void SetContextNameObject(IAssemblyName pName);

    void GetContextNameObject([Out] out IAssemblyName ppName);

    void Set([MarshalAs(UnmanagedType.LPWStr)] string szName, int pvValue, uint cbValue,
             uint dwFlags);

    void Get([MarshalAs(UnmanagedType.LPWStr)] string szName, [Out] out int pvValue,
             ref uint pcbValue, uint dwFlags);

    void GetDynamicDirectory([Out] out int wzDynamicDir, ref uint pdwSize);
}

#region

using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;

#endregion

/// <summary>
/// IAssemblyName from Fusion
/// </summary>
[SuppressUnmanagedCodeSecurity, ComImport, Guid("CD193BC0-B4BC-11D2-9833-00C04FC31D2E"),
 InterfaceType(1)]
public interface IAssemblyName
{
    [PreserveSig]
    int SetProperty(uint PropertyId, IntPtr pvProperty, uint cbProperty);

    [PreserveSig]
    int GetProperty(uint PropertyId, IntPtr pvProperty, ref uint pcbProperty);

    [PreserveSig]
    int Finalize();

    [PreserveSig]
    int GetDisplayName(IntPtr szDisplayName, ref uint pccDisplayName, uint dwDisplayFlags);

    [PreserveSig]
    int BindToObject(object refIID, object pAsmBindSink,
                     IApplicationContext pApplicationContext,
                     [MarshalAs(UnmanagedType.LPWStr)] string szCodeBase, long llFlags,
                     int pvReserved, uint cbReserved, [Out] out int ppv);

    [PreserveSig]
    int GetName(ref uint lpcwBuffer,
                [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwzName);

    [PreserveSig]
    int GetVersion([Out] out uint pdwVersionHi, [Out] out uint pdwVersionLow);

    [PreserveSig]
    int IsEqual(IAssemblyName pName, uint dwCmpFlags);

    [PreserveSig]
    int Clone([Out] out IAssemblyName pName);
}

#region

using System.Runtime.InteropServices;
using System.Security;

#endregion

[SuppressUnmanagedCodeSecurity, ComImport, Guid("21B8916C-F28E-11D2-A473-00C04F8EF448"),
 InterfaceType(1)]
interface IAssemblyEnum
{
    [PreserveSig]
    int GetNextAssembly([Out] out IApplicationContext ppAppCtx,
                        [Out] out IAssemblyName ppName, uint dwFlags);

    [PreserveSig]
    int Reset();

    [PreserveSig]
    int Clone([Out] out IAssemblyEnum ppEnum);
}

#region

using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;

#endregion

/// <summary>
/// Fairly basic stuff once the
/// unmanaged stuff is all mapped
/// </summary>
public class GacEnumerable : IEnumerator<IAssemblyName>, IEnumerable<IAssemblyName>
{
    readonly IAssemblyEnum _enumeration;
    IAssemblyName _enumCurrentAssembly;

    GacEnumerable()
    {
        HandleCom(GAC.CreateAssemblyEnum(out _enumeration, null, null,
                                         (uint) AssemblyCacheFlags.GAC, 0));
    }

    public static GacEnumerable New
    {
        get
        {
            return new GacEnumerable();
        }
    }

    #region IEnumerable<IAssemblyName> Members

    /// <summary>
    /// Returns an enumerator that iterates through the collection.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
    /// </returns>
    public IEnumerator<IAssemblyName> GetEnumerator()
    {
        return this;
    }

    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>
    /// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
    /// </returns>
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion

    #region IEnumerator<IAssemblyName> Members

    /// <summary>
    /// Advances the enumerator to the next element of the collection.
    /// </summary>
    /// <returns>
    /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
    /// </returns>
    /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
    bool IEnumerator.MoveNext()
    {
        IApplicationContext context1;
        return (0 ==
                _enumeration.GetNextAssembly(out context1, out _enumCurrentAssembly, 0));
    }

    /// <summary>
    /// Sets the enumerator to its initial position, which is before the first element in the collection.
    /// </summary>
    /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
    void IEnumerator.Reset()
    {
        _enumeration.Reset();
    }

    /// <summary>
    /// IAssemblyName is a Fusion interface
    /// Gets the element in the collection at the current position of the enumerator.
    /// </summary>
    /// <value></value>
    /// <returns>The element in the collection at the current position of the enumerator.</returns>
    public IAssemblyName Current
    {
        get
        {
            return _enumCurrentAssembly;
        }
    }
    // Properties
    object IEnumerator.Current
    {
        // Go to the other darn Current not this one
        get
        {
            return Current;
        }
    }
    // Fields
    public void Dispose()
    {
        _enumCurrentAssembly = null;
    }

    #endregion

    internal static void HandleCom(int hResult)
    {
        if (hResult < 0)
            Marshal.ThrowExceptionForHR(hResult);
    }
}

[Flags]
enum AssemblyCacheFlags
{
    NGenCache = 0x1,
    GAC = 0x2,
    DownloadCache = 0x4
}

[Flags]
public enum AssemblyNameDisplayFlags
{
    VERSION = 0x01,
    CULTURE = 0x02,
    PUBLIC_KEY_TOKEN = 0x04,
    PROCESSORARCHITECTURE = 0x20,
    RETARGETABLE = 0x80,
    ALL = VERSION |
        CULTURE | PROCESSORARCHITECTURE |
        PUBLIC_KEY_TOKEN | RETARGETABLE
}

More to Come

This is the tip of the iceberg so to speak. Here is a test case to show you what this now is doing and perhaps you can give us ideas where to take it. There is a lot of code. Should it be up on CodePlex? Google Code? Your Environment Variables:

       [Fact]
        public void should_show_my_env()
        {
            var sw = Stopwatch.StartNew();
            var dirs = from env in ThisBox.By<EnvironmentVariable>()
                       select env;
            foreach (var s in dirs)
            {
                Console.WriteLine(s.TypeOfEnv + " " + s.KeyName);
                Console.WriteLine("  ==>" + s.Value);
            }
            Console.WriteLine("Count : " + dirs.Count());
            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");
            sw.Stop();
        }

Let’s join our GAC with our registry!

NOTE: we get 592 hits in 20 or so seconds…

        [Fact]
        public void should_join_policy_registry_section()
        {
            var sw = Stopwatch.StartNew();

            var result = from
                             gac in ThisBox.By<AssemblyDetail>()
                         join
                             registryKey in ThisBox.By<RegistryKey>() 

                         on gac.MajorName equals registryKey.FirstRegValue()

                         select new
                                {
                                        gac, RegVal=registryKey.FirstRegValue()
                                };

            Console.WriteLine("Count : " + result.Count());
            sw.Stop();
            foreach (var a in result)
            {
                Console.WriteLine(a.gac.MajorName + " == " + a.RegVal);
                Console.WriteLine(" ==>" + a.gac.FullName);
            }

            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");
        }

Appendix : A Few Extension Methods we Use

  static class LinqProviderTestExtensions
    {
        /// <summary>
        /// Will perform each action for each
        /// 'row' in the included collection
        /// Each 'row' is of Type TTreeNode
        /// Will typically only be one action
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="items"></param>
        /// <param name="actions"></param>
        static internal void ForEach<T>(this IEnumerable<T> items, params Action<T>[] actions)
        {
            foreach (var t in items)
                foreach (var act in actions)
                    act.Invoke(t);
        }

        public static string FirstRegValue(this RegistryKey registryKey)
        {
            return registryKey.ValueCount > 0
                           ? (string) registryKey.GetValueNames().GetValue(0) : String.Empty;
        }

        public static double ToPercent(this int target, int total)
        {
            return target.ToPercent((double) total);
        }

        public static String ToPctString(this int target, int total)
        {
            return target.ToPercent((double) total) + "%";
        }

        public static double ToPercent(this int target, double total)
        {
            return Math.Round((target/total)*100, 2);
        }
    }

A huge Thanks:

Debasish Bose

del.icio.us Tags: Advanced C#,C# Unmanaged Wrapper,Fusion,GAC,Global Assembly Cache,IEnumerable,IEnumerator,Internals,Lambada,Linq to Gac,Linq to Objects,Machine,Registry
Technorati Tags: Advanced C#,C# Unmanaged Wrapper,Fusion,GAC,Global Assembly Cache,IEnumerable,IEnumerator,Internals,Lambada,Linq to Gac,Linq to Objects,Machine,Registry

Related Posts

Look for this content (as shared here from their internal work) in the next version of the book

A Quick Overview

• The Query Pattern, a specification of the set of methods a type must provide in order to be considered as a LINQ provider. The names of these methods can be found in System.Linq.Enumerable (found in System.Core). Their signature follows a pattern that will be discussed later in this chapter.
  
• A definition of a new interface, IQueryable<T> :I Enumerable<T>
  
• New types representing generic delegates: Func<> and Action<>
  
• Lambda expressions, a language feature in VB and C# for defining anonymous delegate types representing the notion of a delay-compiled delegate, the Expression<> family of types.
  
• An extension to the C# and VB syntax allowing for queries to be expressed in an alternative, SQL-like format. For example (C#):

The interplay between these features is the following: any IEnumerable<> can be queried upon using the LINQ extension methods, most of which require one or more lambda expressions as parameters; this leads to an in-memory, generic evaluation of the queries. For cases where the set of data is not in memory (e.g. in a database), and/or queries may be optimized, the set of data is presented as an IQueryable<>. If lambda expressions are given as parameters, they are transformed by the compiler to Expression<> objects. The implementation of IQueryable<> is responsible for processing said expressions. For example, the implementation of an IQueryable<> representing a database table would translate Expression<> objects to SQL queries.

2. Extension Methods, Func<>, Action<>, and Expression<>

Extension methods constitute a language feature that allows static methods to be invoked on instance variables. These methods must take at least one parameter, which represents the instance the method is to operate on. For example, in C#, this is done by using the this modifier on such a parameter, when defining the method:

}

…which in this case would result in false

In this example, divide is a function that takes two integers and returns a double. The last parameter in the generic definition of a Func<> is always the return type. To represent void-returning functions, use Action<>

Notice how the syntax for constructing an Expression<> object is very similar to the one used to construct a Func<> object; in fact, the only difference is the static type declaration of the variable (Expression<> instead of Func<>

Expressions may also be constructed programmatically, using the predefined static methods of the non-generic Expression

ý

þ

· to provide helper functionality relevant to every implementation of an interface, if said functionality can be written in terms of the core interface. This is because concrete implementations cannot otherwise be assigned to interfaces. For example, the LINQ to Objects operators are implemented as extension methods for all IEnumerable<T> types. Thus, any IEnumerable<>

·

For example, consider the domain of telecommunications. Let us consider that a core domain-specific model is that of network nodes. A library is defined for this domain, called nodes.dll. The library contains types such as Node. Node may have properties such as “address” and “manufacturer”, etc. Now consider the problem of establishing communication paths through such a network (i.e. routing). A second library, routing.dll, is thus developed, taking a dependency on nodes.dll. Good engineering practice dictates that nodes.dll not take a dependency on routing.dll. However, it could be imagined that, in the domain of path routing, the model for network nodes may have new characteristics, namely, that of being or not a path endpoint, and that of being associated with a number of paths. To maintain clean dependencies, a possibility is to have static methods defined in routing.dll, e.g. Paths.IsNodePathEndpoint(Node n) or Paths.GetListOfPathsCrossingNode(Node n). However, it may be considered more natural to simply have methods like IsEndpoint() defined on Node

ý Avoid defining extension methods on System.Object

This is because, in VB, declaring a variable as object

In this example, the call to Foo

ý

ý Avoid redefining extension methods on a type T

This will fail at compile time, since ExtMethod

þ Do

ý Do not

For example, do not define extension methods for Telecom.Node in the Telecom namespace, but in a separate namespace, e.g. Routing

ý Avoid generic naming of namespaces dedicated to extension methods (e.g. “Extensions”) – rather, use a descriptive name – e.g. “Routing

þ Do use the new LINQ types “Func<>” and “Expression<>” instead of custom delegates and predicates, when defining new APIs. The example below illustrates this point:

Benefits of using Func<>, in this case, include minimizing the concept count by employing an existing abstraction, as well as eliminating the dependency on the definition of Tester.

3. Extending on LINQ

There are three means by which a type can be designed to participate in LINQ queries: implementing IEnumerable<> (or interfaces derived from it), implementing IQueryable<>

- Extend IEnumerable<>

o

- Extend IQueryable<>

- Define the Query Pattern on the new type if the domain makes it impossible or undesirable to implement IEnumerable<> or IQueryable<>

The query methods are those defined by the sponsor class System.Linq.Enumerable, as extension methods to IEnumerable<>

þ Do respect the signature pattern in Figure 1

We use S with or without subscript to indicate a collection type (e.g. IEnumerable<>, ICollection<>) and T, with or without subscript, to indicate the type of elements in that collection. Additionally, we use O<T> to represent subtypes of S<T> that are ordered. For example, S<T> is a notation that could be substituted with IEnumerable<int>. The first parameter of all the methods is the type of the object the method is applied on, and it is marked accordingly by prefixing with “this” – whether one chooses to implement these methods as extension methods or as member methods. Also, anywhere Func<> is being used, one may substitute accordingly with Expression<Func<>>

Figure 1 Query Pattern Method Signatures

Extending IEnumerable<>

þ Do implement IEnumerable<T> to enable basic LINQ support. Such basic support should be sufficient for most in-memory data sets. The basic LINQ support will use the default -provided extension methods on IEnumerable<T>

p

Although RangeOfInts did not implement a “Where

þ Consider redefining the methods in the LINQ pattern on new types implementing IEnumerable<T>

þ Consider implementing ICollection<T>

For example, the Count<> method default behavior (as defined in System.Linq) is to simply walk the IEnumerable

Extending IQueryable<>

þ Consider implementing IQueryable<T>

ý Do not implement IQueryable<T>

· Building and parsing expression trees is expensive and many queries can actually get slower when IQueryable<T>

·

þ Do throw NotSupportedException from IQueryable<T>

For example, imagine representing a media stream (like internet radio) as an IQueryable<>. The Count

Implementing the Query Pattern

The Query Pattern refers to defining the methods in Figure 1 without implemeting the IEnumerable<> or IQueryable<>

þ Do implement at least the enumerable pattern (i.e. provide a GetEnumerator

þ Do

þ Do represent ordered sequences as a separate type. Define on this type the “ThenBy

This follows the current pattern in the LINQ-to objects implementation, as well as allows for early (compile-time) detection of errors such as applying “ThenBy” to a not “OrderBy

For example, the framework provides the IOrderedEnumerable<> type, which is returned by “OrderBy”. The “ThenBy” extension method is defined for this type, and not for IEnumerable<>

þ Consider designing the LINQ operators to return specific enumerable types for domains that should be restricted. Essentially, one is free to return anything from a Select query method, however, the expectation is that the query result type should be at least enumerable in a foreach

þ Do

The following methods are exception from this rule: All, Any, Average, Contains, Count, ElementAt, Empty, First, FirstOrDefault, Last, LastOrDefault, Max, Min, Single, Sum.

In the example above, the expectation is that the time necessary for evaluating the second line be be independent from the size or nature (e.g. in-memory or remote server) of set1. The general expectation is that this line simply prepares set2

ý Avoid implementing just a part of the Query Pattern, if fallback to the basic IEnumerable<T>

For example, consider a user-defined type T, which implements IEnumerable<>. T has an override for Count, but not for Where

In this example, any opportunities for optimization are lost after the Where call. The Count version used is the one defined for IEnumerable<>.

þ Do place query extensions methods in a “Linq” sub-namespace of the main namespace. For example, extension methods for System.Data features reside in System.Data.Linq

þ Do use Expression<Func<>> as a parameter instead of Func<>

As it was discussed, interacting with an SQL database is already done through IQueryable<T> rather than IEnumerable<T>

An alternative reason for implementing IQueryable<T> is performing optimizations. For example, a sorted list can implement lookup (“Where” clauses) with binary search, which can be much more efficient than the standard IEnumerable<T> or IQueryable<T> implementations.

They could of however made the interface open, enabling a ‘provider/consumer’ style interface as they have so often before. We know in software that the strategy design pattern is often at the heart of well architected enterprise software (which is a technique to empower dynamic change and flexibility in your solution – considering your OK in areas such as security, production deployment, scalability, etc.).

My clients often have their core information as ‘domain entities’ and this all but eliminates the disconnects caused by having to translate a ‘customer’ to an Oracle structure (for example) It’s JUST A CUSTOMER. Let the domain layer do the mapping, persistence and other work that is non-value added now. And their web service demands on the organization in my experience require a compeletely new development effort in most cases… Not good…Better then nothing but we can do better.

In this spirit, I am working on a utility to automate the importing of information from the following sources:

Keep in mind, this post is not focused on DSL topics (one any developer cannot really afford to miss now), so one could debate the merits of the link I make. My argument is this:

My definition of a DSL is very simply :

A Domain Specific Language is a way, typically using a combination of visual and textual methods, or just textual, to solve a limited but typically non-trivial set of problems. It is typically a smaller stand-alone ‘language’ or language-extension to a larger more horizontal language such as C# (the point I make here is C# has evolved to allow you to expand C# with DSLs you write in C#. This is very different the the DSL Toolkit and I have never had this opinion until I finally got to be immersed deeply in functional style programming enhancements to C# and the ease of extending just about any API with extensions..

I continue the discussion of what a DSL is here. I will be adding to this section of the site over time but if you just want the listed info, no need to go on a tangent now.

Now that new .NET 3.5 C# 3.0 features are allowing us to make the Framework API of .NET work in ways not present ‘out of the box’ the scope of what is possible can be deep and broad.

Part 1 : The DSL Perspective – A Real Example

I’ll use a project we are working on now, which is quite specifically aimed to

• Minimize the configuration overhead of using an Inversion of Control container
• Provide the benefit of ‘provider/container’ independence
• Allow the consumer to change ‘container provider’ vendors with a simple change in ‘meta configuration’

In other words, we are trying to create an abstraction on top of an abstraction, as we believe this particular area is now mature enough (and indeed this is how software engineering historically more then not progresses over time) to do so.

This project has no intention of BEING an inversion of control container nor a dependency injector, rather its aim is to allow people to make use of these critical concepts in much easier ways while eliminating hesitation related to provider lock-in.

It’s no secret we are massive fans of the work of the Castle Project and they are indeed the first ‘plug-in’ adapter we are on schedule to deliver. However the architecture (something this post is NOT trying to explain) of our solution models the DOMAIN of this area, and is not specific to any particular offering (although to be blunt I would say if any bias existed it would be from the conceptual framework that exists now in the Windsor Container/MicroKernal trunk).

A domain specific example

In the area of ASP.NET one technique for loading our solution into memory is via the IHttpModule implementation we provide. Here is what the custom global.asax.cs code looks like:

public abstract class IntegrationPoint : HttpApplication, IDomainApplication {

private static IZeroConfigDI _container;

/// <summary>
/// Executes custom initialization code after
/// all event handler
/// modules have been added.
/// Also acquire a reference to the HttpModule
/// for IoC / DI if present as a module
/// </summary>
 public override void Init() {        

The interesting areas which are not provided by Microsoft include:

1. IDomainApplication interface
2. IZeriConfigDI Interface static reference
3. Modules.GetIoCModule()

The first two have more to do with our solution then the topic of this post, so I’ll focus on #3.

As this code is inside the HttpApplication, we have access to the Modules property which is read-only. Here is the documentation:

Your first reaction if your familiar with this collection is that it does not have anything even close to the GetIoCModule() method we are calling above.

Indeed this is our ‘domain specific’ extension to the .NET Framework API (one of many for this solution).

Here is the implementation of this ‘DSL’ extension:

/// <summary>
/// Provides ‘DSL specific’ extensions to the ASP.NET environment for
/// the IoC Zero Config environment which is not new (after all this becomes a static)
/// </summary>
/// The entire point for extension methods is ‘Fluency in API’ as it allows ‘shorthand’ code

public static class ZeroConfigInstanceResolver {

private const string ZeroConfigTypeString = "IoCConfigModule.IHttpModel";

 /// <summary>
/// Gets the IZeroConfigDI reference
/// (using domain specific logic and the 
/// generic logic extending the container)
/// </summary>
/// <param name="container">The container.</param>
/// <returns></returns>

public static IZeroConfigDI GetIoCModule(this HttpModuleCollection container) {

                        return
                              container.FindInstance(
                                () =>
                                        container.Get(ZeroConfigTypeString)
                                                    as IZeroConfigDI);

}

As you can see above we are very specific in our intent to add this to the HttpModuleCollection. There is nothing that interesting above except for the method call FindInstance(Func<TResult>) off the target ‘container’. This is a peek into the non-DSL related extension that represents. You might be aware that there is no such FindInstance available off the HttpModuleCollection.

One of our many goals in creating a fluent, easily used API is reducing complexity and providing very maintainable code. Here you can see the Lambada expression required to locate our service is hidden from the developer completely, yet this code is not a ‘one-off’ as we have provided both a DSL level extension in concert with a far more generic extension.

Part 2: Extending the Horizontal to Empower the Domain Specific

In looking at the HttpModuleCollection, and in our desire to facilitate other sources of resolving our module, it inherits from the abstract parent NameObjectCollectionBase.

Here is the definition of what inherits from this abstract parent:

The issue arises as this abstract base leaves it up to its concrete implementer to provide the indexer (or say Get() method) to access the object desired. Therefore a nice way to enhance this abstract type to work across all of the children is to literally pass in the method to resolve the object desired.

Part 3 : The Generic Extension

Here is the trivial extension method used to ‘open up’ the NameObjectCollectionBase and which is used above:

/// <summary>
/// Finds the instance in the NameObjectCollectionBase
/// using the Functor
/// </summary>
/// <typeparam name="TContainer">The type of the container.</typeparam>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="container">The container.</param>
/// <param name="finder">The finder.</param>
/// <returns></returns>
public static TResult FindInstance<TContainer, TResult>
       (this TContainer container, Func<TResult> finder)
              where TContainer : NameObjectCollectionBase where TResult : class {

                    return finder();

}

Since we cannot abstract up the get method, we take a page from Functional Programming and literally pass in the code to execute (which we do above).

A common pattern is to expose methods like the above, but add additional versions that allow more parameters into the Func<TResult>. This is well covered well by many of the Linq references and books available.

Part 4: How this allows us to embrace deep/wide change

A simplistic example is supporting the acquisitions of our target reference (IZeroConfigDI) if it is set as ApplicationState or as an IHttpModule. We could make the design decision to allow our find method to reside literally as an extension method of our HttpApplication (and indeed this turns out to be a reasonable choice as the valid inheritors from NameObjectCollectionBase are sealed and therefore invalid as generic constraints). Here is one approach (not ideal and not our final code but this illustrates the point.) Why not offer your optimized solution?

CODE:

public abstract class IntegrationPoint : HttpApplication, IDomainApplication {

private static IZeroConfigDI _container;

/// <summary>
/// Executes custom initialization code after
/// all event handler
/// modules have been added.
/// Also acquire a reference to the HttpModule
/// or Application State
/// for IoC / DI if present
/// </summary>
public override void Init() {

                  _container = this.GetIoCModule(); base.Init();

}

And the extension on HttpApplication:

public static class ZeroConfigInstanceResolver {

private const string ZeroConfigTypeString = "IoCConfigModule.IHttpModel";

/// <summary>
/// Gets the IZeroConfigDI reference if possible (null if not found)
/// using domain specific logic and the
/// generic logic extending the container.
/// </summary>
/// <param name="container">The container.</param>
/// <returns></returns>
public static IZeroConfigDI GetIoCModule(this HttpApplication container) {

                       var modules = container.Modules;
                       var applicationState = container.Application; 
                     

                        var resultVar = modules.ToInstance(
                                   () => modules.Get(ZeroConfigTypeString)
                         )
                        ?? 
                        applicationState.ToInstance(
                                   () => applicationState.Get(ZeroConfigTypeString)
                         );

                       return resultVar as IZeroConfigDI;

}

No change is required on the extension to the FindInstance extension.

Can you see how the above can be improved?

We expand this to make the ‘rule for finding the IZeroConfigDI external. To be specific, above we have a business rule implemented that we typically would not want ‘hard coded’. In fact more then not all things considered we want this. So we do the4 following:

• Determine the Delegate signature for the business rule.
• For the above, we need as input (at a minimum) an HttpApplication instance as that is the container for the models and state, and those two items lack a shared interface or base (or we could use that).
• The signature returns (in all cases) an instance cast where it implement IZeroConfigDI to resolve this business rule.
• Therefore the business rule signature is Func<HttpApplication ,IZeroConfigDI>

The world’s most common extension method and an attempt at a definitive version.

In this post I’ll be digging deeper into doing things I’ve always wanted to have in .NET yet didn’t. For example, I know I am not alone in wanting an IList (be it an IList<T> or a simple non-generic IList) to provide me a .foreach method as you get in a List<T>). This is just one of many things we address here (and more).

From the concrete to the abstract

I was having problems with entries in my path environmental variable, and I wanted an easy way to flag bad entries and also allow me to move the entries in the list up or down easily. This was made apparent by my use of a tool called ‘Dependency Walker’. It’s hard to live without but that’s another post. See the screen shot below:

Click here to go to ‘Dependency Walker’

Test to Code

    /// <summary>
    /// Unit Test to Validate that the logic related to     /// 'show combined extensions using paths' is functioning
    /// </summary>
    /// Documentation Created 5/22/2008
    [Test]
    public void shouldShowCombinedExtensionsUsingPaths()
    {
        var _directoriesInPath = EnvironmentVariableTarget.             Process.GetParsedValues("PATH");

        Assert.That(_directoriesInPath, Is.                TypeOf(typeof(String[])));
        Assert.IsTrue(!_directoriesInPath.IsNullOrEmpty());

        _directoriesInPath.ForEach(
            x =>
            {
                if (!Directory.Exists(x))
                    Console.WriteLine("MIssing Directory! " + x);
            });
    }

Above is the test (that also works). Before I launch into why this is interesting, what looks different?

1) EnvironmentVariableTarget : This is Microsoft’s type not mine. It’s the enum used to specify the target search on the environmentals.

2) _directoriesInPath : This is a string[] as you can see from the Assertion. But how does it support ForEach?

3) GetParsedValues() : What is that exactly?

*** As this is so common I decided to try to craft a definitive version of ForEach that would work across non-generic collections, generic collection, and specific type specification on the targeted items in the collection for generics .  ***

In order to enable ForEach behavior I needed to this code which is by far the most common extension method in all the C# 3.0 code alive today.

    /// <summary>
    /// Requires generic IEnumerable and is most common now
    /// </summary>
    /// <typeparam name="TContainedType">The type of the contained type.</typeparam>
    /// <param name="baseEnum">The base enum.</param>
    /// <param name="actionPerform">The action perform.</param>
    /// <returns></returns>
    /// Documentation Created 7/20/2008
    public static IEnumerable<TContainedType> ForEach<TContainedType>(
           this IEnumerable<TContainedType> baseEnum,
               Action<TContainedType> actionPerform) {

        return ForEachInner(baseEnum, actionPerform);
    }

    /// <summary>
    /// The most explicit case
    /// </summary>
    /// <typeparam name="TBase">The type of the base.</typeparam>
    /// <typeparam name="TContainedType">The type of the contained type.</typeparam>
    /// <param name="baselineEnumerable">The baseline enumerable.</param>
    /// <param name="actionPerform">The action perform.</param>
    /// <returns></returns>
    /// Documentation Created 7/20/2008
    public static IEnumerable<TContainedType> ForEach<TBase, TContainedType>(
              this TBase baselineEnumerable, Action<TContainedType> actionPerform)
                   where TBase : IEnumerable {

        return ForEachInner(baselineEnumerable.OfType<TContainedType>(), actionPerform);
    }

    /// <summary>
    /// The least restrictive case
    /// </summary>
    /// <param name="baseEnum">The base enum.</param>
    /// <param name="actionPerform">The action perform.</param>
    /// <returns></returns>
    /// Documentation Created 7/20/2008
    public static IEnumerable<Object> ForEach(this IEnumerable baseEnum,                Action<Object>  actionPerform) {

        return ForEachInner(baseEnum.OfType<Object>(), actionPerform);
    }

    /// <summary>
    /// Do the actual work
    /// </summary>
    /// <typeparam name="TContainedType">The type of the contained type.</typeparam>
    /// <param name="baseEnum">The base enum.</param>
    /// <param name="actionPerform">The action perform.</param>
    /// <returns></returns>
    /// Documentation Created 7/20/2008
    private static IEnumerable<TContainedType> ForEachInner<TContainedType>(
        IEnumerable<TContainedType> baseEnum,
                       Action<TContainedType> actionPerform) {

        var getEnumerate = baseEnum.ToList();
        getEnumerate.ForEach(actionPerform);

        return getEnumerate;
    }

Notice that anything which implements IEnumerable is caught above, regardless of what the collection.

This content assumes you have an introductory knowledge of C# 3.0 language features in .NET 3.5 and mastery of legacy C# 2.0 Generics, Generic Type Constraints, Anonymous Delegates and related material.

I use a ‘pair programming’ approach with continued refactoring as this is how I would discuss it if you were coding with me, with an unfortunate one-way delivery.

The Brief Strategic View

Microsoft has slowly been moving C# in a very productive direction (this is not new, as these features existed in 2.0 although not nearly as well integrated) to provide ‘Functional Language’ features. If you don’t know or care about language semantics, just know that Linq and especially Lambada Expressions are about empowering you to use executable code like a variable, aka to leverage the power of functional programming. For more on this, read this MSDN article by Joel Pobar (former CLR Team) or read the next set of posts (part 2 onward) as I will go into the depths of this.

Painless Intro

I’ll start with a fairly trivial, yet important example (I use it every day). Many times when comparing Strings I want to ignore case and culture (the InvariantCulture). This is provided by an overload as such as you likely know:

[Test,Category("BaselineCore")]
public void shouldAsserStringCloneInvokeEqual() {

var baselineString = “This is a TEST CASE to IgnOrE Casing”;

var stringUpper = baselineString.ToUpperInvariant();

Assert.IsTrue(baselineString.Equals(stringUpper,
StringComparison.InvariantCultureIgnoreCase));

The test results are shown above. Pass. Ok so I really like short, concise code that is understandable at a glance. Also it’s a pain to always (even with ReSharper) use this (and I have seen people use RegEx for this! RegEx is awesome but overkill for this issue).

Refactoring

• Create an extension method on String
• Decide on a good name for the method (this is SO important and for most an afterthought!)

I’ve settled on calling this new method on String ‘EqualsCore’ as that is what we are doing, making the conditions for a match ’simpler’ and seeing ‘just the core values’ are the same (anyway it makes sense to me)., I suppose this could be ‘EqualsRelaxed’ or whatever..

Here is the test case (no code yet):

[Test, Category("BaselineCore")]
public void shouldAsserStringsEqualUsingExtension() {
var baselineString = “This is a TEST CASE to IgnOrE Casing”;
Assert.IsTrue(baselineString. EqualsSimple(baselineString.ToUpperInvariant())); }

Now we write the code. Here is the container for the extension method:

public static class StringExtensions {

public static bool EqualsSimple(this string sTarget, string compare) {

return sTarget.Equals(compare, StringComparison.InvariantCultureIgnoreCase); }

}

Indeed they both pass:

Since every type inherits from Object, and Equals is defined on Object, all instances should support this approach, and I could be early bound by using Generics…. Hmm…

I tried this (note: I gave it a new new ‘EqualsThis’ to separate them.

public static bool EqualsThis<TTarget>(this TTarget sTarget, TTarget compare){

return sTarget.Equals(compare);

}

Functionally not that interesting at all, but a test. So I typed in the following and wow… It works from Intellisense’s view… Ok it compiled! Wait…..FAIL! But why:?

OK here is the new test:

[Test, Category("BaselineCore")]

public void shouldAsserANYTHINGEqualUsingExtension() {

const String baselineString =”This is a TEST CASE to IgnOrE Casing”;

var sb = new StringBuilder(baselineString);

Assert.IsTrue(sb.EqualsThis(new StringBuilder(sb.ToString())));

}

Interesting…

Here is the documentation for what Equals means by default from Microsoft:

So our code fails using the extension yet this returns true:

[Test] public void shouldAssertStringBuilderExplicit() {

const String baselineString = “This is a TEST CASE to IgnOrE Casing”;

var sb = new StringBuilder(baselineString);

var sb2 = new StringBuilder(baselineString); Assert.IsTrue(sb.Equals(sb2));

}

So Reflector to the rescue once again. I could see in Reflector what I believed the issue was. Indeed the StringBuilder class has an overloaded Equals, and even making the extension method cast to the generic type directly was a no go.

This exposes one of the dangers that we must be incredibly careful with. It has always been poor design in my opinion to encourage developers to override common methods such as ToString() and Equals(object X) with their own behaviors as you force consumers of the API to understand IMPLEMENTATION. You cannot ensure your OK simply from a contract. This is known to be evil….

Of course this is a legacy style and will be slowly phased out.

Spin up reflector and look at the code for the OVERLOAD that StringBuilder has:

busy developing ReSharper 4 :) Here is quick update. We are currently working on preparing ReSharper for Beta – performance, memory, overall stability and reliability. Beta should be out very soon. Then we will have

post-Beta cleanup, more stabilization for Release, fill in missing bricks found during Beta, and then … Well, overall time scope for ReSharper 4 release is about a month. Thank you for your patience, we really appreciate your participation in our early access program! We are doing our best to deliver smart and quality product. And while we are here, what is *single* most important thing you want to be fixed/changed before release?

Sincerely,

Ilya Ryzhenkov

JetBrains, Inc

http://www.jetbrains.com “Develop with pleasure!”

With .NET 3.5 and C# 3.0 released now, it was time for an update. As part of the update, I also improved the API a little bit. Usage now is:

MethodInfo toString = Reflect<object>.GetMethod(x => x.ToString());

The renamed Reflect<TTarget> class receives the type you want to reflect as a generic parameter. Then you can use GetMethod, GetField or GetProperty.

Other examples:

MethodInfo clone = Reflect<ICloneable>.GetMethod(x => x.Clone());
PropertyInfo prop = Reflect<AppDomain>.GetProperty(x => x.BaseDirectory);
FieldInfo field = Reflect<Mock>.GetField(x => x.PublicField);

Working principle is the same: the lambda you pass to the methods is actually an expression

which I analyze to retrieve the underlying reflection object that is already exposed by the LINQ Expression API. For example, once you get to a MethodCallExpression, you can get the method being called through its Method property:

((MethodCallExpression)lambda.Body).Method;

It’s interesting to see how this works actually, and what’s the compiler generating for those lambda expressions invoking methods.

In Reflector, the following C# code:

MethodInfo clone = Reflect<ICloneable>.GetMethod(x => x.Clone());

is decompiled as (indented for readability):

ParameterExpression CS$0$0000;
MethodInfo clone = Reflect<ICloneable>.GetMethod(
Expression.Lambda<Action<ICloneable>>(Expression.Call(CS$0$0000 =
Expression.Parameter(typeof(ICloneable), "x"),
 (MethodInfo) methodof(ICloneable.Clone), new Expression[0] ),
new ParameterExpression[] { CS$0$0000 }  ));

Note how the MethodInfo is retrieved directly from the interface by using a methodof operator. It’s not a valid C# keyword, but given that Lutz Roeder works for Microsoft (not on the C# team, though), let’s hope it will get eventually in the language :).

That methodof translation is actually the conversion from the following two IL lines:

L_0017: ldtoken instance object [mscorlib]System.ICloneable::Clone()L_001c: call class
 [mscorlib]System.Reflection.MethodBase

[mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype

[mscorlib]System.RuntimeMethodHandle)

ldtoken is the key there, let’s hope it gets promoted to C# in some way eventually.

Anyway, since I wrote my original article, I realized through Ayende’s blog that you can also do static reflection without LINQ. It only works for methods though, and you cannot use the lambda syntax because it results in method infos that are actually from a compiler-generated type (the one that contains the closures too if any).

As I’m so in love with the lambda syntax, I’ll keep my implementation based on expression trees instead of delegates.

It’s released now as part of Clarius Labs projects. Get the source and have fun!”

Daniel Cazzulino’s Blog : Statically-typed reflection with LINQ

 How do we get people to commit to something when everyone has a different perspective based on role or even political leanings for larger companies” “Our stakeholders are petrified to commit to a final stake in the ground for fear they will not be able to modify it based on I.T.’s inflexibility and inability to change”

I though perhaps these were problems we had overcome in our industry, as the solutions are fairly well understood. I was wrong. What is the bottom line break-down between I.T. and the Business? That is a long and colorful debate. However I offer this:

• 
  
  Most organizations punish those who are bad at PREDICTING THE FUTURE in software engineering. Of course these are smart people but they continue to demand clairvoyance with a lack of statistics.


• 
  
  What happens? Padding of the schedule and bitter fights for every last month, when nobody has any idea what the effort is, not can they quantify the quality, and more importantly maintainability requirements around a software initiative.


• 
  
  The fact is you cannot know at a micro level about a project until you are well into building it. This is something I have never met a receptive audience for, however it proves itself time and time again.


• 
  
  “How do we give people the freedom to change their minds, yet deliver concrete estimates on time and cost to our managers?”


• 
  
  “How much will this cost us and how can we estimate it knowing we will likely change our minds during the project based on previous projects, and how can we get early and consistent involvement in the development process?”


• 
  
  “How can we ensure that necessary quality is met when we always enter risk mode at the end and quality goes out the window? Can’t we manage with quality at every single stage, even every day?!”

Whatever you do (in my opinion anyway) Don’t say Agile…Nobody on the business side cares. In fact for whatever reason, software causes perfectly rational people to loose their mind (I cannot really blame them).

What I have to say on the matter is accompanied by deep battle-scars. What I have to say is definitely not what most want to hear, and even the technologists want to argue that they CAN come close to prediction. However what I say has the ‘added moral quality of being true’. This is hard to argue in light of the facts. That still often changes nothing, as companies firmly plant their head in the sand again and hope for the best with no real way of knowing what will happen and no practical way of really tracking in real time how their exposure to risk is changing.

I know… I know… Agile is 100% about that but not in the way (typically) this group wants to hear, no that is why a knockout one-two punch is as follows (to be insanely overly simplistic):

1) Heavy Statistical Metrics for the ‘Planning’ View Inclined

2) Of course, Agile Practices to Provide the Inputs to (1) and to Optimize your Chances on the Execution Side

This article is about some detail around (1) that far too many miss in my opinion and why it doesn’t serve you to mix the terminology of these two groups (one of the only occurrences where I recommend that as I am typically the one pushing everyone into ‘one common Domain Driven language’)

The Four Critical Dimensions

When addressing the concerns of a new custom software project these are the four key elements that must always be addressed (there are others such as security, scalability, etc. but those are included in ‘Scope’ as functional and non-functional requirements):

• 
  
  Time (cannot be made)


• 
  
  Scope/Features (you cannot know it until your done, so now what?


• 
  
  Quality (not typically discussed, as who wants ‘bad or sort of low’ quality)


• 
  
  Cost (Since you have almost nothing to go on here, what to do? Your agile consultant says the system is ‘done when it is done, not when some arbitrary date is set’ and he is 100% correct. However the business gets to decide when it is ‘done enough’ not I.T. (with exceptions of course)

As Quality is not usually debated (I have never had a client say that the software could be poor quality), that leaves Time, Scope and Cost as the main moving parts to work with.

The diagram above is where many stop. That is missing the entire point, as the DRIVERS that facilitate your ability to do well are missing. For example:

1) A lack of a continuous integration environment with regression tests will severely hurt your ability to achieve quality (all things being equal)

2) A bad process / culture kills just about all of it

3) Bad team morale is the same coin, different side.

4) A process that cannot manage the inevitable change in scope as we ‘discover’ what the project is all about, will kill just about all of it.

5) A team lacking in solid design skills (design for change) such as a mastery of the important design patterns (Strategy Pattern Anyone?) as well as a lack of a Dependency Injection Container (there is just no good reason not to use one)

6) Lack of an Object to Relational Mapping Abstraction Layer. Deal Breaker as of today (perhaps not a year ago).

There is no real doubt by anyone (except for a few people who also are not so sure on the whole evolution thing) that Agile practices provide the common sense way to address the same concerns most of us have around software.

You know it, I know it, we all know it. However they don’t care (and really have likely heard some bad things about it).

My assumption is you are a person on the software side in a managerial capacity of some sort. I made this mistake for you many times. Resist the urge to ‘set them straight’ or to explain the wonders of Agile when asked these questions (or even when not) and instead… I’ll be getting to that….

Anyway, they would probably just think ‘how 2004’ and ask about SOA or something….

There are some real deal-breaker assumptions around project planning with or without Agile execution (and without agile is very well might be an execution.. OK enough biased injection for one article).

There is often an unspoken (and unrecognized) characteristic that you should be able to ‘tell the future’. And many will think that the worse you are at it, the more likely it is you just might be lazy and/or stupid. I’ve seen it over and over and over. Those who spin, those who pad, those who create fluff to buy time win. Those who really try and don’t play games get nailed to the wall.

Count me in the ‘dumb and lazy’ group because I am terrible at predicting the future.

In high school I was certain this really cute cheerleader would accept my invitation to the prom. I was also certain a few years ago that a system could be built for W dollars, in X months with Y people and Z quality. After all, that is all I could get from the customer as they were taking no input from vendors. Sure it was aggressive but we were so smart! We could do anything!

Both had similar endings.

“In order to succeed in complex software planning, just like in Agile, you have to give up. You have to completely accept the fact that you cannot possible know what you are really doing until you are already well into a solution, at least not at any detailed level”

Sound familiar? But you know you need these Agile ideas on the ‘other side’ and you also know it would be self-defeating to wave that flag..

Nobody wants to admit they lack power, especially in areas they have devoted their life to mastering. But why does this not only empower you, but create the bedrock of extreme competence and success? Is this like the alcoholic finally admitting he is powerless over the bottle? Only then can things get better? I doubt it. This is only software.

·

The Monetary Stakeholders

And for they people either funding and/or profiting from this exercise the concerns can be quite different.

“How can we ensure profitability on our work when we know change will occur? (For internal IT they may be managed and accountable for profitability if they are run like a profit center). If not profitability then “How can we possibly commit to a date and cost when we know this will be a moving target as we evolve the solution?”

“We have an abysmal record of missed deadlines, cost over-runs, quality problems and our users not being happy with our delivered systems. What can we do to improve this?”

“How do we manage the scope changes and ‘feature creep’ placed on us by the business people/stakeholders? This is what typically destroys our profits and/or time commitments and cost commitments, often resulting is a severe quality issues as well. How can we give people what they want but manage this change?”

This article is about bring these two groups together and keeping them just apart enough. This article is targeted to the people who must deliver software to their clients (be it internal IT or an outside Agile consulting firm doing the work). I assume these concepts would work in a non-Agile Process environment but I have cannot remember much luck (or for anyone I knew) in those days without resorting to what I call ‘white tricks’ so I will not comment.

A Framework for Project Statistical Success Optimization

We know that these two very distinct groups will need to work closely together in an Agile environment if we want to optimize our chances. The days of separating the business experts from IT is long gone. In fact, for an Agile project to succeed it is typical to actually have a business domain expert on the development team as a fully fledged member.

‘High Ceremony’ software processes may work (it is really dependent on who is doing the work as an amazing team will almost always succeed – see Peopleware by DeMarco and Lister) but at a large opportunity cost in almost all cases.

Any assigned domain expert should have the reach to get answers to questions quickly outside their domain knowledge when required. For a non-trivial project it will likely cover many domains and it may not be possible for that individual to have a mastery of all of them, however this person should be able to expeditiously get answers from others when required, This is a critical success factor to any Agile project.

I have evolved over many years this approach to software profitability and risk management in a very well tested and disciplined way. It has evolved since 1998 when I was CTO of a niche financial services software firm, which was sold in 2004. I then started the firm agilefactor and significantly evolved these ideas further as I still do literally almost every day! It’s 2007 and there are many war wounds.

If any of this content seems like ‘academia’ or ‘theory’ I can assure you these are all proven real-world strategies, having been applied by myself and many others for years and years.

At the most basic, one could say everything eventually comes down these four critical dimensions…

It is CRITICAL you never let a client box you in on all of the three of these items if it can be avoided or you may have to ‘walk away’ from a project (many in internal IT do not have that luxury but at least this article will show you how to push back in a way that is hard to be disputed by the forces trying to box you in to possible assured failure).

Your client gets to drive only two of the three items at most (such as Time and Cost), while you driven the third (Scope in this example) or the remaining items you control (you must always have at least one that the client explicitly gives you control over).

This is critical to profitable software sales both for commercial and custom one-off development but many fail in this area in their eagerness to close deals (this is especially a problem with salespeople who are not put in check on what they can promise the client, and will promise you right into a massive loss – a lesson I learned firsthand early in my career).

For example, if a client says:

· We are allowing vendors to work until October 1st to achieve these 120 individual scope items in the attached 600 page scope document we have assembled (the first major sign of trouble).

· Vendors have $1,900,000 to build this system. This is non-negotiable and the software must be extreme production quality, with severe contractual penalties for down-time, with scaling up to 10000 concurrent sessions per machine with an average response time of one second or less “

Do we walk away? My initial reaction is absolutely..

This violates the principle described above as you are not in control of any of the four critical elements. The answer is sometime you must walk away!

I will describe here a way to help determine if you should and how you can effectively push back on this, as we know there will be significant deltas on that scope document (both academically from studies and practically from our experience).

We really have no idea if we should accept these terms. There are ways however where we can at least assess the risk and possible accept the terms when we learn these tools.

We all know it is an agile imperative deliver a working build to your stakeholders for each iteration that is ‘real production’ although a subset most of the time

The client drives at most two dimensions, and you must drive the third (again ignoring the Quality variable) or you risk a disaster for everyone.

And after all, THEY are deviating from ‘the plan’ they committed to with confident assurances that there would be little to no need for ‘change orders’ (this is a common occurrence in my experience with a correlation to the larger the company the most convinced they are the scope will not change.

Establish Risk Tolerance Before Defining the Time, Scope and Cost Constraints

Based on the extensive research and project database built by the industry luminaries and incredibly esteemed experts Tom DeMarco and Tim Lister, we now know what the probability distribution curve is for new custom software projects. It is lognormal with a high peak and a long curve to the right. This is absolutely critical for everyone to understand and I highly recommend you read the book “Waltzing with Bears” for a detailed discussion (see the end of this chapter for more information).

This is the probability distribution curve we must embrace:

You establish the client’s willingness to accept the unavoidable possibility of failure across any of the four dimensions (we cannot predict the future) and then find that point on the curve moving up from the X axis point you have for the client (the X axis is probability of success) and take the area to the left of that point.

The total area under the curve is 100% so the farthest right point would indicate 100% confidence (again basically impossible to achieve where most organizations assume 100% by default, something that must change if our industry will ever ‘grow up’. As we cannot control the future, we can only manage it and the risks, we must know how ‘risky’ the client wants to be (again by asking them or inferring it ourselves – often manifested in a ‘public’ date and an ‘internal’ date which is past the public date if we know the client will not cancel the project or penalize us tangibly for missing the public date).

It is a typical ‘risk/reward’ situation. If the customer takes on more risk we might save them money, or deliver early. If they want less risk, we must significantly increase our cumulative resources attached to a project with the knowledge that ‘adding people to a late project makes it later’. This we know as fact so adding people is really only an option in the early phases. This has a large impact on early project planning.

· We need to understand if a customer is OK assuming a 15% risk of failure for example.

· After all, don’t all future events have unknown outcomes?

· Is the client willing to as much as double their budget for a say 10% increase to 95% probability of future success across all dimensions?

A 95% success promise is not only near reckless to offer, it is an incredible shifting of risk anyone should demand a rich reward for taking on.

Studies are behind me on this as well with the well established fact that the best developers are as much as 28 x more productive then the worst). It quite literally is often a 100% increase in total resources allocated for a project to move from 85% to 95% even though it is a 10% gain in probability, hence the very long tail. The highest I have ever had a client go is 90% and we actually had two teams in two locations for redundancy (they didn’t know about each other). One team almost failed but delivered a solution, however the other team’s solution was superior so that is what we went with. This gave us our high probability due to the redundancy and the client paid dearly for this safety.

For example, the development team may say:

“We had a terrible two weeks. Our lead Cryptography expert was sick so we moved those features into the next iteration and we severely underestimated the complexity of the mainframe integration and User Profile Customization.

Therefore we could only achieve 50% of what we had planned for this iteration. I would say from our agreed upon 85% confidence we are now closer to 75%. We can see if we make it up in the next iteration or we can take measures A, B and C to get back to 85%. What do you want to do?”

A better question I have for you is, would you rather not know this? Almost all organizations are nowhere near this level of integrated risk assessment, quantitative measurement and adjusting action execution.

This is typically a decision for a high level individual (typically the project manager with the optional input of the customer) and hopefully with input from as many people as possible covering all dimensions.

Adding people will typically hurt you, not help you. You should already have done the obvious things like have moved the team into a ‘war room’ setting (almost always a sure way to improve productivity) or many other solutions, so if you missed any do it now as these techniques are proven and it is much more painful to fail.

As for the client, they can also be blissfully unaware of how we manage the process of our internal development, but this well established process makes it incredibly hard to fail.

Here is an example with risk tolerance. Based on negotiations with the client they have agreed to a risk tolerance of 85% (a 15% risk of failure). Based on this, you can now estimate knowing your margin for error. The customer has scope requirements, and cost requirements but is fairly open to time.

You come back to the client and say:

“Based on an 85% confidence we feel we can deliver your scope at the cost you describe at some point between April 1 2006 and July 1 2006’”. The client may protest, saying (for the first time) they were hoping for a March 1 delivery. You confer with your colleagues and respond that this would be possible at a 70% Confidence (30% chance of failure). And so the negotiations follow…But at least now you have very concrete ‘dials to turn’ and it is hard for the customer to argue with the fact base supporting you.

I assert that custom software is a ‘wicked problem’ (to see a great definition of ‘wicked problem’ see http://www.cognexus.org/id42.htm or the text at the end of this article.

Conclusion

To help ensure a positive outcome for your client and for your development effort it is critical to consider first the Risk Tolerance of your client, and then negotiate the one dimension you typically have control over after the client informs you of the two (two from Time, Scope and Cost). In some cases you must walk away and this article should help you determine when that is the case.

For a much more detailed discussion of these topics and what this author considers critical:

“Waltzing with Bears”, Dorset House Publishing Company, Incorporated (March, 2003), ISBN: 0932633609

Supplemental Material: Wicked Problems

A wicked problem is one for which each attempt to create a solution changes the understanding of the problem. Wicked problems cannot be solved in a traditional linear fashion, because the problem definition evolves as new possible solutions are considered and/or implemented. The term was originally coined by Horst Rittel.

Wicked problems always occur in a social context — the wickedness of the problem reflects the diversity among the stakeholders in the problem.

Most projects in organizations — and virtually all technology-related projects these days — are about wicked problems. Indeed, it is the social complexity of these problems, not their technical complexity, that overwhelms most current problem solving and project management approaches. (See graphic of wicked problem solving process below.)

Some specific aspects of problem wickedness include:

1. You don’t understand the problem until you have developed a solution. Indeed, there is no definitive statement of “The Problem.” The problem is ill-structured, an evolving set of interlocking issues and constraints.

2. Wicked problems have no stopping rule. Since there is no definitive “The Problem”, there is also no definitive “The Solution.” The problem solving process ends when you run out of resources.

3. Solutions to wicked problems are not right or wrong, simply “better,” “worse,” “good enough,” or “not good enough.”

4. Every wicked problem is essentially unique and novel. There are so many factors and conditions, all embedded in a dynamic social context, that no two wicked problems are alike, and the solutions to them will always be custom designed and fitted.

5. Every solution to a wicked problem is a “one-shot operation,” every attempt has consequences. As Rittel says, “One cannot build a freeway to see how it works.” This is the “Catch 22″ about wicked problems: you can’t learn about the problem without trying solutions, but every solution you try is expensive and has lasting unintended consequences which are likely to spawn new wicked problems.

6. Wicked problems have no given alternative solutions. There may be no solutions, or there may be a host of potential solutions that are devised, and another host that are never even thought of.

(from Rittel and Webber, 1973)

From ReSharper’s EAP Site

I’ve been using the 4.0 EAP (pre-beta) since the first preview and it’s awesome… Rocky at times, but I’ve never lost any code (however you should use at your own risk!).

There is something very comforting in auto-creating an anonymous delegate and having it convert automagically to lambata syntax….

For example, here is a step by step from a real code sample:

C# 3.0 support

Implicitly typed locals and arrays

Fully supported, including suggestions to omit explicit type specification, Introduce Variable refactoring and context actions to convert to implicit or explicit form.

Extension Methods support

Fully supported, with Import Symbol completion (previously known as Type Name completion) after dot which can import suitable extension method and insert appropriate using directive. Analysis will suggest converting invocations from static-like to instance-like form. Context action can convert it back, and there are refactorings to convert static method of static class to Extension Method and update all call sites. There is also reverse refactoring, of course.

Object and collection initializers

Fully supported, with suggestions and context actions to fold series of statements to collection or object to initializer, if possible.

ReSharper also provides smart intellisense features in such places, like completing settable properies or displaying correct parameter information for Add method used in collection initializer.

Automatic properties

Fully supported, with context actions to convert to property with backing field and back. Analysis can show properties which are candidates for conversion. Code generation features may suggest creating automatic property in addition to property with backing field, if appropriate.

Anonymous types

Fully supported. ReSharper can search for similar anonymous types throughout the project or solution, give a name to anonymous type and replace usages, rename properties, suggest reordering properties if two anonymous types look similar and more.

Lambdas

Partially supported. By partially, it means that not all features we want there are ready. The code shouldn’t be red and intellisense should be working, but some context actions, quickfixes, analysis and such may be missing. We are actively working on those features, so as time passes ReSharper will be more and more smart about lambdas. We have conversion actions like delegate to lambda and back and some suggestions. Note, that not all features of ReSharper are lambda-aware yet, so they may fail when they happen to operate on lambdas.

LINQ

Almost supported. We import appropriate extension methods, provide intellisense, a number quickfixes, our refactorings are aware of queries. We also provide special live templates.

Partial methods

Not supported.

New and updated features

Go to Type, File, Symbol and Find Results

You can now put results of “Go to” features to find results for browsing

External Annotations

Ability to annotate external (non-source) symbols with ReSharper-specific attributes, like CanBeNull and NotNull. Note, that we standardized attribute names for better interoperability and less configuration hassle, so you may need to refactor you code a bit if you use these attributes.

Code Cleanup

Successor of Reformat Code, Optimize Usings and other code cleaning features – all in one interface with many more modules. Includes things like processing readonly fields, removing redundancies, updating file header, converting to automatic properties, replacing explicit types with vars and more. All in batch mode, so that you can instantly clean the whole project or even solution.

Plenty of new analyses

We added many more inspections in ReSharper 4. Some of them are related to C# 3.0 and deal with new language constructs. Also, there are new structure-related inspections, like “if” statement analysis, anonymous method closure analysis, and more. We also added new severity level for analysis results – Hint – which is a lot less intrusive. It does not participate in next/previous highlight navigation and is not shown on error stripe. It simply tells you: “Pssst! Take a look here, it can make your code look better.”

Complete Statement

Also known as Smart Enter, it inserts required syntax elements to complete the code you are writing. It can close parentheses as needed, add semicolon, complete constructs such as if, while, for and so on.

Completion with CamelHumps

All kinds of code completion (Symbol completion, Import Symbol Completion and Smart Completion) now supports filtering by CamelHumps, which tremendously speeds things up. E.g. if you know you have DefaultCodeCompletionManager type somewhere you just type DCCM and invoke Import symbol completion. Full type name will be inserted and using directive will be added as needed.

Refactorings

There are new refactorings related to C# 3.0 features, like “Convert Property to Automatic Property” and back, “Convert Static Method to Extension Method” and back and “Name Anonymous Type”. “Introduce Variable” is now dialogless and this improves coding flow a lot! Another great new refactoring is “Inline Method”, which can replace method call with method body at specific point or all over your code. “Method to Indexer” is a nice addition to “Method to Property” refactoring. There are also improvements in almost all refactorings, both in usability and smartness.

Recent Edits

In addition to Recent Files we created Recent Edits feature, which shows what you’ve been changing recently. If appropriate, it displays type and member the change occured in.

To-do items on identifiers and string literals

You can now configure ReSharper to search for specific patterns not only in comments, but also in string literals and identifiers. It is quite useful to set NotImplementedException pattern to have a quick access to code you have to write.

Support for solutions using different targets

ReSharper now fully supports solutions where different projects use different versions of CLR like .NET Compact Framework or Silverlight. You can now have e.g. Smart Device projects and normal projects in the same solution and all ReSharper features will work perfectly fine in this scenario.

Project References

This is more like preview of the feature which may or may not come into final bits of ReSharper 4. It can show dependencies between projects and libraries in terms of assembly references.

Live Templates Editor

We are improving usability of Live Templates editor and currently it is large work in progress. Be careful with it if you use custom templates.

Easier creation of new folders through generate (Alt+Insert shortcut)

Dozens of other features

We also have dozens of other minor features, keep track of

this tracker query for the current list.

ReSharper 4.0 EAP Notes – JetBrains.net

Add-Ins and Extensibility

The System.AddIn.dll assembly in the .NET Framework 3.5 provides powerful and flexible support to developers of extensible applications. It introduces a new architecture and model that helps developers with the initial work to add extensibility to an application and by ensuring that their extensions continue working as the host application changes. The model provides the following features:

• DiscoveryYou can easily find and manage sets of add-ins in multiple locations on a computer with the AddInStore class. You can use this class to search for and obtain information about add-ins by their base types without having to load them.
• ActivationAfter an application chooses an add-in, the AddInToken class makes it easy to activate. Simply choose the isolation and sandboxing level and the system takes care of the rest.
• IsolationThere is built-in support for application domains and process isolation of add-ins. The isolation level for each add-in is in the control of the host. The system handles loading application domains and processes and shutting them down after their add-ins have stopped running.
• SandboxingYou can easily configure add-ins with either a default or customized trust level. Support includes Internet, Intranet, Full Trust, and “same-as-host” permission sets, as well as overloads that let the host specify a custom permission set.
• UI CompositionThe add-in model supports direct composition of Windows Presentation Foundation (WPF) controls that span application domain boundaries. You can easily allow add-ins to contribute directly to the UI of the host while still retaining the benefits of isolation, ability to unload, sandboxing, and versioning.
• VersioningThe add-in architecture makes it possible for hosts to introduce new versions of their object model without breaking existing add-ins or impacting the developer experience for n

This is known by many who have been doing VSX for a while, but I ran into it again recently and thought since many are no getting into this fresh, more sources are good.

“Unhandled Exception: System.IO.FileNotFoundException: Error while loading file ‘EnvDTE, Version=7.0.3300.0″

<configuration>

<runtime>

<assemblyBinding xmlns="urn:schemas-microsoft- com:asm.v1"

appliesTo="v2.0.50318">

<dependentAssembly>

<assemblyIdentity name="EnvDTE" publicKeyToken= "b03f5f7f11d50a3a"/>

<bindingRedirect oldVersion="7.0.3300.0" newVersion="8.0.0.0"/>

</dependentAssembly>

</assemblyBinding>

</runtime>

</configuration>

We wanted to share some of the features in the new version with you below as well as some surprises! We are also working on a Mac version and a Linux version which might take longer.

Thank you for your continued interest and we look forward to seeing you in 3D! I would also appreciate any Feedback you could share with us. If you have any installation issues, please feel free to email me and I will work with you to make sure SpaceTime works for you. I know you are going to enjoy this version.

Thank you! Eddie Bakhash CEO

SpaceTime Features:

SpaceTime Zoom – Type in Google or Yahoo! search 3D Interactivity – Interact with web pages in 3D! Ctrl-Link – Press control link on a hyperlink to create that link in a new 3D space. Resize Images/Videos – Click any video or image in the lower right hand corner to scale it.

FASTER – Your initial search in SpaceTime will be much faster!

Favorites – Bookmark your favorite web pages. SpaceTime automatically imports your IE7 bookmarks.

Save Space!!!! – Yes. Load up your space. Save it. Open it up again. It is truly spectacular.

New Navigator – Click the navigator in the upper right hand corner to experience a new way to move around your 3D space.

Screenshot – Wherever you are, click the Screenshot icon in the upper right hand corner to capture the viewpoint you are at permanently by placing an icon on the timeline.

Clicking the icon takes you back to that viewpoint.

I will soon be posting a new article which (in my opinion) could be far more useful to everyone then this article ever was as it:

• Has far greater scope and use as Is a ‘domain collection’ engine and I believe the first solution to something I have been struggling with for years: The pain of building clean, quick web views in the world of Ajax, controls that expect datasets, and programmers not understanding ORM. It so far works with NHIbernate (and ActiveRecord) and I am finalizing Linq to Entity support
• Leverages advanced .NET intrinsic’s (CustomTypeDescriptors, etc…) that are leveraged by the third-part component community

• Support any ‘domain projection/entity set’ operation – the same engine backs both bindable sets and non-bindable sets.. You just pass the HQL into the user control in VS 2005/2008

Also stop by the new global repository I am bringing up with some others around ‘best practices’ for domain driven (obsessed) work. This has a .NET 3.5 focus (as we will deeply discuss linq I am planning) however it is an architects site, so we will cover mono, java, and likely 50% of the content will be platform agnostic.More to come!

Not to be a terrible bore, but brush up on your Wittgenstein lately?! Ok don’t go that far just yet…(grin).

 First, a Pattern Language (P.L.) is not some academic concept, although many would like you to believe that.

	‘Software as a Service – The Pattern Language Approach’
	‘Software as a Service – The Pattern Language Approach’
	‘Software as a Service – The Pattern Language Approach’

NOTE: I take issue with the word design below… It should be far more broad in most cases, but it often gets boxed into the design aspect of a problem. I would say ‘best practices’ which brings up its own semantic mess…

A pattern language is a structured method of describing [best] good design practices within a field of expertise. It is characterized by

1. Noticing and naming the common problems [and positively executed solutions proven over time] in a field of interest [domain in my words]
2. Describing the key characteristics of effective solutions for meeting [one or more] some stated goal[s], [Often patterns are combined and are multi-faceted]
3. Helping the designer [domain stakeholder] move from problem to problem [and challenge to challenge] in a logical way, [in an attempt to reduce and even eliminate ambiguity] and allowing for many different paths through the design process.

- Wikipedia 

1. This ties in perfectly with my claim that complex software engineering is a ‘wicked problem’. If you disagree then you can stop reading, as none of my assumptions will work. However, I would love to hear your arguments since only around 20-30% of all software projects ’succeed’…. There is no doubt there is dreadful crisis which I know you know about so enough said.

If the fundamental issue here is NOT that people cannot/will not see software engineering for what it is, then what?!

Wicked Problem

FYI: This is also why your pretty much nuts to not be Agile at this point, with some critical exceptions.

OK just to get you started chew on these 10 basic characteristics and tell me how any of them and the failure of senior stakeholders to understand that indeed software fits these characteristics is likely a key systemic disaster which we see and live every day in this industry. Click here for more.

 Before I was able to ‘take this deck on the road’ which I have done now with success (and why I am revisiting this post to offer insights), I had to get the audience (I hate to call them that… The collaborators is better) knowing (for example) that SOA was not a damn bunch of web services! I had to get people understanding exactly how distributed objects and components ARE NOT THE SAME but are similar. etc. etc.

That ASMX pages in .NET are not even close to what you want to be doing, even with WSE 3.0 and ‘Contract First’ techniques (most notably the WSCF add-in from the always amazing thinktecture).

There is nothing more necessary than truth, and in comparison with it everything else has only secondary value.
This absolute will to truth: what is it? Is it the will to not allow ourselves to be deceived? Is it the will not to deceive?
One does not want to be deceived, under the supposition that it is injurious, dangerous, or fatal to be deceived.

Friedrich Nietzsche, 1890

Thanks Herr Nietzsche… None of us want that. So “Listen for the speakers intended meaning, not your perceived definition”.

In this rather philosophical vein, I offer you here an attempt at the beginnings of a unified P.L. covering many best practices we have evolved in the SOA/SaaS space.

As stated, this presentation is born from necessity as it has become almost impossible to have a meaningful conversation on many topics in this domain due to ‘definition overloading’.

This presentation not only attacks that issue, it also brings together into a cohesive pattern language Object Orientation, Distributed Objects, Components and Services while being careful to not make overly broad generalizations that would harm any SaaS initiative.

For example, it is a best practice to evolve a Domain Driven API which is (at a minimum) the core APU which your services will use to fulfil their contracts.

The presentation is here and feedback is encouraged. This also assumes you have embraced either the SCA environment (for Java development) or WCF for .NET. These are (in our guidance to clients) the only relevant implementation frameworks for strategic large scale organizational transformations to SaaS.

Otherwise in real-world terms there are not resources (developers, or the dramatically increased effort with very little benefit) available to support other approaches. Many ‘purists to the extreme’ might attempt a hand-crafted ‘build it all over again’ approach with hand-crafted contracts (typically XSDs).

As these environments support full extensibility, indeed it is incredibly rare that one of these environments will not completely address your needs. Of course there are always exceptions, but this is addresses to 95% of the market.

Due to the immaturity of this space, it is alarming how many companies believe they are not part of that 95%!! Typically they are being driven by parties (internal or external) that have motivations not in line with the business drivers.