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:

http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx

 

About Rx

Rx is a library for composing asynchronous and event-based programs using observable collections.

The “A” in “AJAX” stand for asynchronous, and indeed modern Web-based and Cloud-based applications are fundamentally asynchronous. In fact, Silverlight bans all blocking networking and threading operations. Asynchronous programming in by no means restricted to Web and Cloud scenarios, however. Traditional desktop applications also have to maintain responsiveness in the face of long latency IO operations and other expensive background tasks.

Another common attribute of interactive applications, whether Web/Cloud or client-based, is that they are event-driven. The user interacts with the application via a GUI that receives event streams asynchronously from the mouse, keyboard, and other inputs.

Rx is a superset of the standard LINQ sequence operators that exposes asynchronous and event-based computations as push-based, observable  collections via the new .NET 4.0 interfaces IObservable<T> and IObserver<T>.  These are the mathematical dual of the familiar IEnumerable<T> and IEnumerator<T> interfaces for pull-based, enumerable collections in the .NET framework.

The IEnumerable<T> and IEnumerator<T> interfaces allow developers to create reusable abstractions to consume and transform values from a wide range of concrete enumerable collections such as arrays, lists, database tables, and XML documents. Similarly, Rx allows programmers to glue together complex event processing and asynchronous computations using LINQ queries over observable collections such as .NET events and APM-based computations, PFx concurrent Task<T>,  the Windows 7 Sensor and Location APIs, SQL StreamInsight temporal event streams , F# first-class events, and async workflows.

Play with Rx, stress it, evaluate it, and tell us what you think.

new deep zoom related enhancements - click below

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.

This is now a complete media platform for synchronized content from Internet (MRSS, iTunes) as well as private sources with our integration Cloud support out of the box for Amazon S3.

Here is one of the framework generated experiences (you can do your own but not in this demo) which transforms the Apple Movie Trailers content:

Or click here to go direct:

http://media.tangentux.com/index.htm

Adobe has no reason to ignore Silverlight now…They do that at their own peril and eventual harm.

We will have a free version of this media center environment (yes indeed it is a lot like Windows Media Center, only completely built for Internet content). The demo above shows off some Deep Zoom integration, as well as some intelligent playback optimized for quality over M4v, MP4, and associated file types.

There is also a large demo with tons of smooth streaming content. Let me know if your interested.

del.icio.us Tags: adobe,f4v,flash video,Flex,flv,RIA,SilverLight,silverlight 3,silverlight 3 beta,silverlight adobe,Video

Technorati Tags: adobe,f4v,flash video,Flex,flv,RIA,SilverLight,silverlight 3,silverlight 3 beta,silverlight adobe,Video

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

As long time advocates of domain-driven practice it should be no surprise that we prefer ‘Domain Specific Language’ approaches.

Of course now it seems obvious to everyone that these are the future. Sure there were many bumps in the road, but it is not even an interesting debate about ‘if’.

This article is so good from Martin Fowler we had to repost:

TIP: .NET Developer? Start learning the Oslo set of technologies, especially’ all things ‘M’. We pay tribute to ‘M’ in our demo Silverlight cube on Silverlight.net showcase.

DslMigration
dsl
4 February 2009
Reactions

One danger that DSL advocates need to guard against is the notion that first you design a DSL, then people use it. Like any other deice of software, a successful DSL will evolve. This means that scripts written in an earlier version of a DSL may fail when run with a later version.

Like many properties of DSL, good and bad, this is really very much the same as happens with a library. If you take a library from a someone and they upgrade the library, you may end up stuck. In essence DSLs don’t really do anything to change that. Your DSL definition is essentially a PublishedInterface and you have to deal with the consequences just the same.

This problem can be more prominent with external DSLs. Many changes to an internal DSL can be handled through refactoring tools (for those languages that have them). But refactoring tools won’t help with an external DSL. In practice this problem is less of an issue than it might be. An internal DSL with scripts that are outside the control of the DSL implementers won’t be picked up with refactoring. So the only difference between internal and external lies with DSL scripts within the same code base.

One technique for handling evolution of DSLs is to provide tools that automatically migrate a DSL from one version to another. These can be run either during an upgrade, or automatically should you try to run an old version script against a new version.

There are two broad ways to handle migration. The first is an incremental migration strategy. This is essentially the same notion that’s used by people doing evolutionary database design. For every change you do to your DSL definition, create a migration program that automatically migrates DSL scripts from the old version to the new version.

An important part of incremental migration is that you keep the changes as small as you can. Imagine you are upgrading from version 1 to 2, and have ten changes you want to make to your DSL definition. In this case, don’t create just one migration script to migrate from version 1 to 2, instead create at least 10 scripts. Change the DSL definition one feature at a time, and write a migration script for each change. You may find it useful to break it down even more and add a feature with more than one step (and thus more than one migration). They way I’ve described it may sound like more work than a single script, but the point is that migrations are much easier to write if they are small, and it’s easy to chain multiple migrations together. As a result you’ll be much faster writing ten scripts than one.

The other approach is model-based migration. This is a tactic you can use if you are using a Semantic Model (which is something I almost always recommend). With this approach you support multiple parsers for your language, one for each released version. (So you only do this for version 1 and 2, not for the intermediate steps.) Each parser populates the semantic model. When you use a semantic model, the parser’s behavior is pretty simple, so it’s not too much trouble to have several of them around. You then run the appropriate parser for the version of script you are working with. This handles multiple versions, but doesn’t migrate the scripts. To do the migration you write a generator from the semantic model that generates a DSL script representation. This way you can run the parser for a version 1 script, populate the semantic model, and then emit a version 2 script from the generator.

One problem with the model-based approach is that it’s easy to lose stuff that doesn’t matter to the semantics, but is something that the script writers want to keep. Comments are the obvious example. This is exacerbated if there’s too much smarts in the parser, but then the need to migrate this way may help encourage the parsers to stay dumb – which is Good Thing.

If the change to the DSL is big enough, you may not be able to transform a version 1 script into a version 2 semantic model. In which case you may need to keep a version 1 model (or intermediate model) around and give it the ability to emit a version 2 script.

I don’t have a strong preference between these two alternatives.

Migration scripts can be run by script programmers themselves when needed, or automatically by the DSL system. In order to run automatically it’s very useful to have the script record which version of the DSL it is so the parser can detect it easily and trigger the resulting migrations.

Microsoft “Oslo” Frequently Asked Questions

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..)

Writing.

Data

Access

Code

That MS SQL Certification is hard to let go I realize but is it worth acting like Sisyphus for? I have more interesting things to do and I KNOW your stakeholders are not cool with you wasting their money.

I simply mean you can think, talk, brainstorm etc. with your ‘domain experts’ without the silly attempt to handle two different systems (Relational and OO) of thought. You all share one. And you should know it. It’s called object oriented.

Anyway… Enough pithiness (is that a word?)…

The always astoundingly good Ayende (Oren) is getting ready to release one of the most compelling software tools for people wasting far less and ‘for free’ gaining far higher quality by using NHibernate.

I expect it will be a fantastic tool to use in trying to work with teams desperately clutching their ADO.NET books….

This is all his content from here out:

NH Prof has reached the level in which I can actually talk about the features that it has in more than abstract terms. There is still a big feature area that I want to cover (which should be a nice surprise), but the basics are there, and today I had ample proof that it is maturing just nicely. I was able to deal with quite a few of the remaining tasks by applying check listing. Basically, to do X, I had to do A,B & C. Trivially simple, and quite satisfying.

Test coverage went back up to over 90% on the backend again, which is also nice.

Anyway, let us start with the tour, shall we?

The left upper pane shows the captured sessions. You can see the number of statements per each session, as well as the length time it was open.  Let us move down a bit, and explore statistics.

The session factory statistics pane include a lot of information about NHibernate, which can give you a good indication about what is going on in the application in a global fashion. In 2.0 we have quite a few data points, but the statistics feature was significantly expanded in 2.1, and contains a lot more data and more finely grained statistics.

But that is probably not what gets you excited. What is likely to thrill you are the statement view.

I put a lot of though into designing those (well, into thinking about them, the actual design was handled by people who actually know what they are doing, design wise). The upper section of the screen is optimized to allow the human eye to quickly scan it in order to find all sorts of interesting patterns. Compare this to SQL Profiler UI, and you can see why I think that this is a much better version, just from that stand point.

The bottom half, however, is what I really like. This is the part I use the most often, in order to really see what is going on. I did an ad-hoc demo of the profiler in Dallas, and one of the things that cam out of this was the format that you see on the lower pane. This UI is set to allow you to just copy the query from the profiler and immediately execute a readable, easy to understand query on Management Studio or Toad. Again, another piece where I think that I providing a lot more value than SQL Profiler does.

For quick reference, we put the parameter values on the left of the query, so you can inspect them without having to go into a potentially complex queries to try to figure out what is what.

But this isn’t where it ends, let us take a look at the stack trace tab:

The stack trace will let you correlate a query and the code that generated it, and not only that, it will take you directly from the query to the code (opening visual studio, loading the file and landing you directly in the place in the code that caused this query to be executed.

Oh, and one more thing…

I have over four years of experience working with NHibernate, a time during which I learned quite a bit about what work, what doesn’t and what kind of things we should be aware off. The profiler has given me the chance to codify a lot of these patterns, and put them in a way that allow you to have apply early detection and prevention mechanisms.

And one last thing, this time it will really be the last. Session / Entity inspection:

You can see exactly what are the entities that were loaded by this session, including counts per entity and all the ids that were loaded.

I hope to be able to open it for beta testing in two to three weeks, and a 1.0 release about a month after that. Pricing is tentatively set at 200$ per user, but this is subject to change.

http://ayende.com/Blog/archive/2008/11/04/nh-prof-a-guided-tour.aspx

Amazing stuff……Buy this from Oren!

• Click the right mouse button to freeze the cube
• Move the mouse to zoom in and out while the cube is frozen
• See if you can get the Easter egg to display

NOTE: If this did not work for you before, please try it using the new launch page below. This will indicate if any .NET bits are missing on your PC. This will all go away when we finish moving this work to Silverlight in total.

Click here to see it live

This proof of concept gets us around a few hurdles we were struggling with to deliver a ‘Google Earth’ style view but into a ‘company as the earth’. In our opinion, you can navigate to almost any spot on the planet so why is it so hard to find documents?

For those invested in document management, categorization and meta information addition (part of building the taxonomies) the piece we found missing was a ‘modern’ way to navigate, discover, filter, pattern match, etc. all that semi-structured data.

The new Architecture Explorer enables individuals to create a visual representation of existing code assets.

From MSDN (with added commentary….)

Modeling that Works with Code

For most businesses only about 20% of the code being written today is for new applications;

(DDN: Not true 100% however that is about right for budgets which is likely what they meant anyway).

the majority of work is being done on existing code bases. A typical issue encountered when working on existing code is not having good tools to help the architect or developer understand the system.

(DDN: Uh.. How about no regression tests? How about no mandate for reuse, framework API quality, etc. etc.? Sure lets not talk about the why, just the ways we can profit from it)

This can make it challenging to not only understand what needs to be done to make the required changes, but it makes it equally challenging to understand the broader impact of the changes. Often it isn’t until much later that an unexpected bug is discovered as a result of a change.

Our modeling tools have tight integration into the actual code of the application. This means that a developer or architect can use models to explore existing code assets.

Ugh.. Rational Round Trip UML nightmare but this should be part of your world at a minimum from code to view.

The new Architecture Explorer in Visual Studio Team System gives developers and architects the capability of creating a full architectural picture of existing code; understanding how they fit together; understanding how they “work.” This leads to better information about how to use, re-use, or even whether or not to discard existing code. The Architecture Explorer provides architects and developers a mechanism for visualizing code assets in a number of ways including graphs, stacked diagrams and dependency matrices.

DDN: OK now I am officially getting scared… I can see all the developers saying ‘look ma! I’m an architect!’

The introduction of the Architecture Layer Diagram means that a developer or architect can use models to enforce constraints on code as well. The Architecture Layer Diagram can be coupled to code making it an active diagram that can be used for validation.

For example, when an architect designs a system where the presentation layer should not talk to the data layer, you want to be able to enforce that model at check-in.

DDN: Oh my god was that last sentence serious? As if that would be a real interesting case?

VSTS 2010 can do that. These capabilities delivered in VSTS 2010 are part of the Microsoft’s overall modeling story.

Learn more about modeling by watching the Trends in Software Modeling webcast featuring Jeffrey Hammond (Forrester Research), Cameron Skinner (Microsoft, Visual Studio Team System), and Clemens Reijnen (Sogeti).

Related Posts

BDC Web Man

We really like this time saver in the ‘often cause of pain’ BDC. (note: the comments below are marketingspeak but as most (some) of it, it’s technically literally correct). But we like where this is going!

By dragging and dropping your database tables onto a design surface you can easily generate WCF BasicHttp web service methods that easily integrate with the Business Data Catalog. This product is currently in beta and you can download and give it a go from here:

http://www.lightningtools.com/bdc-web-man/default.aspx

We dig into this product and our own attempts which it’s nice to know will be offered in a more predictable and market oriented way then ‘when we get to it for open source’. I live open source but sometimes you need a market for the last mile (grin).

Related Posts

• How to Create a Minimal Master Page

from tag C#

• Master Generic Type Constrains : A critical success factor in Linq Development
• Technorati: Discussion about “JetBrains Releases ReSharper 4.01 Beta 1 as EAP Build 917 – Download Here”
• Engadget
• MSDN Code Gallery
• domain driven .net 3.5+ software development
• Linq C# 3.0 Enumerable Extension Method Reference « don’t give up on software just yet
• Google Desktop’s Latest Gadgets
• Advanced C# 3.0: Part 3 – New Language Features as ‘Domain Specific’ as well as General Purpose Extensions « damon wilder carr
• Design Guidelines for Developing Class Libraries
• Undocumented Linq! .NET 3.5 SP1 Gold Forgot to Mention these Critical Changes that might Break your Code « ubiquitous fluency
• E – TextEditor | New Release Feed

(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

Linq on Wikipedia

An easier way to consume, visualize, understand and quantify just about any information you can imagine from the world of global financial services.

• Delayed Quotes to Real-Time Portfolio Analytics
• Simulation Engine with Strategy Add-Ins (Monte-Carlo, etc)
• Efficient Frontier Optimization : N-Dimension Constraint Option
• User defined heuristics from strategic rebalancing to day-trading

Thanks to Microsoft’s Linq technology (introduced in the .NET 3.5 platform), the code in the image is real. It’s well established that by making things easier and more ‘declarative’ overall productivity goes up.

Quality improves and most importantly bandwidth increases significantly in focusing on ‘what is important’ not ‘what is tedious’.

In the case above we get the items in our portfolio now priced (using a real-time feed) below their 90 day moving average. You can ‘inject’ added information as we do above for history. Another option would be to inject some ‘predictive’ numbers using a simulation technique.

There are many Linq providers, however most are ‘technology focused’ such as dealing with protocols or platform APIs. We have always been the most interested in solving the harder problems driven from the business perspective. Although there are many technologies involved here, the larger difficulty is making it available in whatever way you would like to see it, across a broad set of dimensions well beyond any technology constraint.

We support more then just ‘detail’ information, You can use aggregate style commands (say you want to to get you assets for a pie chart that displays asset class holdings in percent).

If you then wanted to drill-down, you could use the same asset class information in a ‘where’ clause to limit the detail to just what you own in that class. But moving well beyond ‘SQL’ type logic, you can set up monitoring alerts that take action if/when a trigger is met.

The key is the same simple syntax is used for all data providers across all levels of information, including full-text scans and a new feature we’re working on now for a future release incorporating an even easier natural language syntax.

This platform is not a fundamentally new way to calculate or retrieve this information. We’ve had access to many frameworks, API’s, data providers, etc. for a long time now.

What this Linq provider does however, it change the dynamics of complexity, time to market, assumed costs in maintenance and testing, and much more. This offering’s goal is to make problems in this domain become utterly trivial. Our goal is to empower your team to make trivial what was previously arduous.

You’re about to ‘declare’ what you want, rather then describe each step in the process. If your thinking it looks a lot like ‘SQL’ you’re 100% correct. However SQL could never achieve what Linq provides.

Due to the nature of the access to this information, we are still working out the details for the open-source version we plan to offer soon. The world of the owners of this data has not caught up to the philosophy we have for transparency and shared value. Send us an email for updates or simply register with us. Also if your in the industry and have an interest we are looking for innovative early adopters. Also, we’ll be posting on many of the challenges we faced and a few innovative solutions we applied to the emerging and highly strategic domain of intelligent Linq Parser development.

Links

• Official Microsoft LINQ Project
• 101 C# LINQ Samples
• 101 Visual Basic LINQ Samples
• LINQ to XML Documentation
• Microsoft LINQ forum
• LINQ page on NetFXGuide.com
• LINQ wiki
• LINQ books
• Continuous LINQ
• LINQ To Sharepoint
• LINQ To Active Directory
• Linq Tutorials and Active Articles
• Looking to LINQ – Will Microsoft’s Language Integrated Query transform programmatic data access?
• Obtics (Observable Object LINQ)
• LINQ to SNMP
• Different Ways Of Retrieving Data From Collections
• LINQ Exchange – Learn LINQ and Lambda Expressions

Linq is not just about databases. It’s about reading the registry, your hard-disk, or even a list of function pointers to be invoked. Linq is about more even then sets (collections). It’s about making tasks easier in many cases and vastly more powerful (and most importantly your code more readable and maintainable at the same time).

It’s astounding just how fast the HashSet<T> collection is.

This post will show how to gain additional power that is fully supported from Microsoft which is often overlooked, yet it can solve some of the hardest problems (especially around performance however don’t prematurely optimize!).

 
There are tons of cases where we need a real powerhouse to manage super-large sets (in this example we will use the registry). An entire part of the registry actually.

Here is the API we want to use to query the HKLM part of our registry:

            var FindFontsColors = from rk in RegistryServer.Hklm
                                  where
                                          rk.Name.Contains("VisualStudio") &&
                                          rk.Name.EndsWith("FontsAndColors") &&
                                          rk.ValueCount > 0

                                  select rk.Name;

• The core win here is ‘ease of development and maintenance’ without the typical trade-off
  
  in performance. The entire equation is shifted actually so the tradeoff becomes irrelevant.
• Sure you could do this with a lot more code perhaps even a few ms faster. But at what real cost over the life of your code?
• The entire point of this post is the far greater win in maintenance and ease of understanding, without the assumed loss of things like performance.

When there is no intelligence available on a ‘back-end’ to parse your requests, yet you need the power of finding complex conditional results and much more, there is one recently introduced superstar that is often not described in terms of Linq:

HashSet<T>

Let’s start with some code. You know you can call ToList, ToArray, ToDictionary & ToLookup on your collections (we’ll call them Sequences to stay in line with Linq terms).

• You will see ‘sets’, ‘collections’ & sequences used together in documentation today. The differences are mostly academic, however the HashSet does illustrate some of those semantic differences which we point out.

We are going to add an extension method to provide us a ToHashSet capability off any IEnumerable<T> (in exactly the same implementation style Microsoft used internally).

Here is how we gain access to this type in the easiest way:

    using System;
    using System.Collections.Generic;

    /// <summary>
    /// This extension method class will add a ToHashSet<typeparamref name=">"/>
    /// in exactly the same way it is provided by the others:
    ///
    /// ToList(), ToArray(), ToDictionary().. Now ToHashSet() is available
    /// </summary>
    public static class HashSetLinqAccess
    {
        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> fromEnumerable,
            IEqualityComparer<T> comparer)
        {
            if (fromEnumerable == null)
                throw new ArgumentNullException("fromEnumerable");

            if (comparer == null)
                comparer = EqualityComparer<T>.Default;

            return !typeof(HashSet<T>).IsAssignableFrom(fromEnumerable.GetType())
                           ? new HashSet<T>(fromEnumerable, comparer)
                           : (HashSet<T>)fromEnumerable;
        }

        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> fromEnumerable) {

            return ToHashSet(fromEnumerable, EqualityComparer<T>.Default);
        }
    }

Ok so what are we going to do with the HashSet<T> and why?

The benefit comes when we have in-memory large sequences to deal with. I will be using the following code as the ‘server’ here. This is code that provides a ‘Registry Server’ to our application. We will populate up a HashSet<T> with RegistryKey instances and then see just how fast it is.

In the next post we will cover all of the additional methods the HashSet<T> exposes.

Here is the code for our Registry Server. NOTE: Please do not try to modify this to change your registry unless you know what you are doing. This is an immutable (read-only) projection from the registry for a very good reason: You can thrash your machine otherwise.

————————————————————

namespace domaindotnet.LinqToRegistry {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.CompilerServices;
    using System.Threading;
    using Castle.Core;
    using LinqToCore;
    using Microsoft.Win32;

    /// <summary>
    /// Provider immutable projections from the registry
    /// of the machine, as well as events for status and errors
    /// via a singeton wrapper on the .NET Registry
    /// singleton.
    /// Here we are only exposing the HKLM area
    /// subkey but you can see it is easily extensible
    /// </summary>
    public class RegistryServer : IEqualityComparer<RegistryKey>, IInitializable,
                                  IEnumerable<RegistryKey> {
        // IInitializable is from Castle.Core Contractually
        // saying we need a call on our Initialize() method
        // before we can be given out as a service to
        // others

        private static readonly RegistryServer _instance;
        private static int iCounter;
        private HashSet<RegistryKey> allKeys;
        private PopulateProgressEventArgs eventArgStatus;
        private bool isInitialized;

        private PopulateProgressDelegateError populateError = delegate { };
        private PopulateProgressDelegate populateEventOk = delegate { };

        static RegistryServer() {
          

            _instance = new RegistryServer
            {eventArgStatus = new PopulateProgressEventArgs()};

        }

        private RegistryServer() {}

        public static long Count {
            get {
                if (!_instance.isInitialized)
                    throw new InvalidOperationException(
                            "Please initialize the backing store first");

                return _instance.allKeys.Count;
            }
        }

        public static RegistryServer Hklm {
            get {
                if (!_instance.isInitialized)
                    throw new InvalidOperationException(
                            "Please initialize the backing store first");

                return _instance;
            }
        }

        #region IEnumerable<RegistryKey> Members

        public IEnumerator<RegistryKey> GetEnumerator() {
            if (!isInitialized)
                throw new InvalidOperationException(
                        "Please initialize the backing store first");

            return allKeys.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() {
            return GetEnumerator();
        }

        #endregion

        #region IEqualityComparer<RegistryKey> Members

        /// <summary>
        /// If either contains a null, the result is false (actually it is
        /// null be we do not have that option. It is 'unknown and indeterminant'.
        /// An emptry string however is treated as 'known to be empty'
        /// where null is 'could be anything we have no idea'.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public bool Equals(RegistryKey x, RegistryKey y) {
            return x.Name != null && y.Name != null && x.Name == y.Name;
        }

        /// <summary>
        /// For null names here we will calculate a funky random number
        /// as null != null
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int GetHashCode(RegistryKey obj) {
            return obj.Name != null
                           ? obj.Name.GetHashCode()
                           : RuntimeHelpers.GetHashCode(new object());
        }

        #endregion

        #region IInitializable Members

        void IInitializable.Initialize() {
            Initialize();
        }

        #endregion

        public static event PopulateProgressDelegate PopulateProgress {
            add { _instance.populateEventOk += value; }
            remove { _instance.populateEventOk -= value; }
        }

        private void InvokePopulateProgress() {
            var PopulateProgressDelegate = _instance.populateEventOk;
                eventArgStatus.ItemCount = Interlocked.Increment(ref iCounter);
                PopulateProgressDelegate(this, eventArgStatus);

        }

        public static event PopulateProgressDelegateError PopulateProgressItemError {
            add { _instance.populateError += value; }
            remove { _instance.populateError -= value; }
        }

        private static void InvokePopulateProgressItemError(PopulateProgressEventArgs args) {
           _instance.populateError(_instance, args);
        }

        public static void Initialize() {
            Initialize(Registry.LocalMachine);
        }

        private static void Initialize(RegistryKey RegistryStartKey) {
            if (_instance.isInitialized)
                throw new InvalidOperationException(
                        "Already Initialized. Cannot perform twice");

          
            _instance.allKeys = GetAllSubkeys(RegistryStartKey, "").ToHashSet(_instance);

            _instance.isInitialized = true;
        }

        private static IEnumerable<RegistryKey> GetAllSubkeys(RegistryKey StartkeyIn,
                                                              String NodeKey) {
            _instance.InvokePopulateProgress();

            if (StartkeyIn != null) {
                RegistryKey SubItemRoot;

                if (TryOpenSubKey(StartkeyIn, NodeKey, out SubItemRoot)) {
                    yield return SubItemRoot;

                    foreach (var sub in

                            SubItemRoot.GetSubKeyNames().SelectMany( // Recursion back into this method
                                    s => GetAllSubkeys(SubItemRoot, s)))

                        yield return sub;
                }
            }
        }

        private static bool TryOpenSubKey(RegistryKey StartFrom, String Name,
                                          out RegistryKey itemOut) {
            var bIsOK = false;
            itemOut = null;

            try {
                itemOut = StartFrom.OpenSubKey(Name,
                        RegistryKeyPermissionCheck.ReadSubTree);
                if (itemOut != null)
                    bIsOK = true;
            }
            catch (Exception ex) {
                InvokePopulateProgressItemError(new PopulateProgressEventArgs(-1,
                        ex.Message + Environment.NewLine + "Key=" + StartFrom.Name + " failed trying " + Name));
            }

            return bIsOK;
        }
                                  }

    public delegate void PopulateProgressDelegateError(
            object sender, PopulateProgressEventArgs args);

    public delegate void PopulateProgressDelegate(
            object sender, PopulateProgressEventArgs args);
}

namespace domaindotnet.LinqToRegistry {
    using System;

    /// <summary>
    /// Simple EventArg for the two progress events
    ///
    /// NOTE: There will typically be some errors
    /// which is fine as some parts of the Registry are
    /// not accessible with standard security
    /// </summary>
    public class PopulateProgressEventArgs : EventArgs {

        private readonly string _keyName;

        public PopulateProgressEventArgs(int itemCount) : this(itemCount, null) {}

        public PopulateProgressEventArgs(int itemCount, String KeyName) {

            ItemCount = itemCount;
            _keyName = KeyName;

        }

        public PopulateProgressEventArgs() : this(-1, null) {}

        public string KeyName {
            get { return _keyName; }
        }

        public int ItemCount { get; internal set; }
    }
}

Although not required, if you want to use this Registry Server (it makes a fantastic ‘mock’ server – although not really a Mock at all) put all the code above in a separate assembly for ease of use.

It’s great for trying our many variants of Linq queries over objects (as we do here) as the Registry – although a bit dangerous to muck about with – is a nice hierarchical source with enough interesting turns to make it fun.

In practice we rarely need to change the registry but if we did, it would be though this (we would carefully evolve it so it could perform controlled updates).

The Regression Tests

So we are using xUnit because we like it. Use whatever you want. The code shown next is the abstract base class our real test cases will use:

namespace LinqToORMValidation {
    using System;
    using domaindotnet.LinqToRegistry;

    public abstract class BaseTestContext {

        private static void RegistryServer_OnPopulateProgress(object sender, PopulateProgressEventArgs args)
        {
            //Console.WriteLine("Processed " + args.ItemCount + " items");

        }

        private static void RegistryServer_OnPopulateProgressError(object sender, PopulateProgressEventArgs args)
        {
            Console.WriteLine("Error : " + args.KeyName);
        }
        protected BaseTestContext() {

            RegistryServer.PopulateProgress += RegistryServer_OnPopulateProgress;
            RegistryServer.PopulateProgressItemError += RegistryServer_OnPopulateProgressError;
            RegistryServer.Initialize();

            Console.WriteLine("Initialization Complete. Total Records = " + RegistryServer.Count);
        }

    }
}

NOTE: Un-Comment the Console.WriteLine in the OnPopulateProgress to view the status as it runs.

The main area to see is the protected constructor. It’s clear that the Singleton is exposing a separate Initialize() method (we did this on purpose as it can take a little while for all those keys to get inside the HashSet<T> and debugging things if they go wrong in say a static constructor is harder then making a long-running initialization explicit. In general a good design decision we believe.

So the final part of code for this post at least is the first test which indeed shows the exact query from the beginning working:"

namespace LinqToORMValidation {
    using System;
    using System.Diagnostics;
    using System.Linq;
    using domaindotnet.LinqToRegistry;
    using Xunit;

    public class RegistryServerValidation : BaseTestContext {

        /// <summary>
        /// As a Linq IEnumerable<T> result
        /// if anything changed, the
        /// underlying HashSet<T> would not change. However if this
        /// were a direct reference to the HashSet the values ARE
        /// changeable. The idea is to project out immutable results
        /// from the Registry server and indeed treat all the data
        /// as read only
        /// </summary>
        [Fact]
        public void should_prove_basic() {

            // Find the registry key(s) that have
            // VisualStudo in the name and end in
            // 'FontsAndColors' that also have at least
            // one value defined inside they key

            var sw =Stopwatch.StartNew();

            var FindFontsColors = from rk in RegistryServer.Hklm
                                  where
                                          rk.Name.Contains("VisualStudio") &&
                                          rk.Name.EndsWith("FontsAndColors") &&
                                          rk.ValueCount > 0

                                  select rk.Name;

            var countMatched = FindFontsColors.Count();

            sw.Stop();

            Console.WriteLine("Total Records Matched = " + countMatched);
            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");

            // Assert it took less then one second
            Assert.True(sw.ElapsedMilliseconds < 1000);
            ObjectDumper.Write(FindFontsColors);
        }

    }
}

For this test cases we are very specifically finding any keys across any in HKLM matching the conditions:

• The key name ‘VisualStudio’ somewhere.
• The key ends with ‘FontsAndColors’
• The key has at least one value inside (you’ll see why in the next post when things get harder)

We also introduce a time to show off the speed of the HashSet<T>.

Here I am making the assumption that the name of the key holds identity, and if null, we use standard null semantics (as defined in relational algebra).

The only few interesting points are the use of the static RuntimeHelpers class from .NET as the fact we are using the singleton static instance as the Equality instance.

Running the Code

As expected we received a few errors, but they make sense as they are protected areas of the registry.

So we matched across 233142 instances of RegistryKey with three conditions in 746ms. Try that in RegEdt32!!

So far this has only set a baseline for the next exploration into these new methods provided in the HashSet<T> you might not have been aware of which we can now easily use:

NHibernate 2.0 went gold yesterday and is available for download from here.

This is official release 2.0.0 GA. Please ensure you review this list of breaking changes from the release notes (also main items briefly listed below).

NOTE: Correction/clarification made 8/26 on Linq to NHibernate location.

The much anticipated Linq to NHibernate is available for now only via the NHibernate Contrib project and is not included in this NHibernate release.

Although likely to change, there does not appear to be an installer for Linq to NHibernate so it must be accessed from the source code. To gain access to this, you will need a subversion client such as Tortoise, and then download the code.

To download ‘Linq to NHibernate’ from the Trunk go here

The location of the bits can be found under the repository at this location:

http://nhcontrib.svn.sourceforge.net/viewvc/nhcontrib/trunk/src/NHibernate.Linq/
NOTE: Pictures Below Generated from NDepend, a must-have tool for .NET Development

gold release 2.0.0.GA

BREAKING CHANGES from NH1.2.1GA to NH2.0.0

• Infrastructure

  • .NET 1.1 is no longer supported
  • Nullables.NHibernate is no longer supported (use nullable types of .NET 2.0)
  • Contrib moved. New Location

NDepend Analysis

• • • http://sourceforge.net/projects/nhcontrib

• Compile time

  • NHibernate.Expression namespace was renamed to NHibernate.Criterion
  • IInterceptor have additional methods. (IsUnsaved was renamed IsTransient)
  • INamingStrategy
  • IType
  • IEntityPersister
  • IVersionType
  • IBatcher
  • IUserCollectionType
  • IEnhancedUserType
  • IPropertyAccessor
  • ValueTypeType renamed to PrimitiveType

• Possible Breaking Changes for external frameworks

• Various classes were moved between namespaces
• Various classes have been renamed (to match Hibernate 3.2 names)
• ISession interface have additional methods
• ICacheProvider
• ICriterion
• CriteriaQueryTranslator

• <nhibernate> section, in App.config, is no longer supported and will be ignored. Configuration schema for configuration file and App.config is now identical, and the App.config section name is: <hibernate-configuration>
• <hibernate-configuration> have a different schema and all properties names are cheked
• configuration properties are no longer prefixed by “hibernate.”, if before you would specify “hibernate.dialect”, now you specify just “dialect”
• All named queries will be validated at initialization time, an exception will be thrown if any is not valid (can be disabled if needed)
• Stricter checks for proxying classes (all public methods must be virtual)

• <any> : default meta-type is “string” (was “class”)

Stumble It!

What’s your opinion on the genesis for a new software process/method entering the mainstream?

They don’t emerge as collective practice from air.

What made waterfall become a shared mental belief system in millions of minds yet fail so consistently, and indeed provide the only level of ‘predictability’ in software at that time (an expectation of predictable disaster).

I could continue on the facts above for a few pages but it merely is an example of our need to carefully choose a belief system that actually has the added value of being correct.

in terms likely unseen (and unknown by most)    What do you believe the memes for successful adoption are? Why did waterfall dominate for so long and at such pain?

For this discussion, your opinion of why Agile succeeded yet while it also brings impassioned opposition from others is a focus of thought.

Yet indeed while software is filled with so many amazing minds why do we fail on the most basic and fundamental topics more as a rule then exception (code reuse for example is still an utter failure for no reason other than human constraints. The technology has existed for well over a decade if not more).

Mental models/belief systems around software development drive ‘methods/methodologies’ for implementation. Unfortunately, many fallacies define the standard for how others perceive ‘how the work should be performed’.

This has been the shame of software for decades, as we seem to have a terrible time growing into a mature field of science. There is far too much failure, lack of predictability, and utter frustration at the highest levels of corporations globally. What happened and why is Agile / Wicked Problem thinking so helpful?

What are some of the reasons this disconnect exists?

Enter Agile

Agile was and mostly is the best approach to resolve the most painful aspects of fitting an artisan’s model into an assembly line mentality. Agile reconciles organizational needs in software around previously unrealistic demands around predictability, verifiable estimations, and planning.

Buzzwords and industry hyperbole aside, Agile has moved our industry forward in fundamental ways. We believe this is mostly around its focus on team-centric behaviors and simply not watering down the statement of facts around software most in the ‘methods’ world could never do as it would sever their ability to be embraced! Agile simply told the truth and said ‘enough is enough’ let us do this using some common sense.

‘Wicked Problems’

Now consider a model already used in many domains that goes back to 1973. This model has already defined the very drivers of ‘what is software development’ we assert. Consider the following:

NOTE: For a more complete listing and discussion please see [3]

If you cannot admit 90% of these statements below about software, why would you believe Agile would work for you?

Every solution to a wicked problem is a “one-shot operation,” every attempt has consequences.

This is not around all code being written from scratch in the least. This means that the delivered software for a wicked problem is unique but almost always composed of other ‘non-wicked’ solutions..

Who would even consider delivering a strategic application where nothing is leveraged from others?

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 considered. This is the nature of solving complex and ‘moving target’ type concerns

Mock Frameworks are a Mandate

Although a side discussion, we believe it merits your attention as we simply have no idea how anyone can succeed at Agile without a Mock-Centric world.

Consider an ‘API’ you require but is now ill defined and not even built. Do succeed this API must ‘appear to exist and indeed appear to be working’ to our system as we evolve items around it. For example, a complex API for financial calculations is assumed, but at iteration three we only required a few aspects of that API.

For more discussion on this critical yet later stage topic go here for our deeper discussion

Facts will not Save Us

1) It is irrelevant how correct the above is until external, internal or a combination of forces move the collective thought.

Typically, the competitive market and legislation protecting shareholders should resolve the glaring nature of this issue. However, it is ignorant for we technologists to believe the ‘objective truth’ of our knowledge will directly drive cultural shifts. It does not happen that way in most cases. If it did we would all have OS/2 running on our machines and beta-max machines.

2) Most cannot actually act on these facts or even acknowledge their reality.

This is of course due to their having to ‘change everything’ in how their fiefdoms execute, not to mention trying to explain this to the other stakeholders of IT. I see disastrous practices perpetuated rather than trying to actually be viewed strategically in the value they could offer their organization.

Conclusion for Now

Ask yourself these questions at the most fundamental:

• Does your culture understand and nurture ‘software as iterative learning and Wicked Problem’.
• If so can you only acknowledge this fact with your team (that’s fine, as good luck explaining this to most C-Level execs. In fact we recommend not mentioning Agile unless they mention it to you first.
• How do you treat short-term failures from iterative development (assuming a strong set of feedback loops allowing constant course correction and validation)?

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.