Code Pyre

Chewie 2.0 Beta

2012-12-01T22:42:00-08:00

NuGet isn’t going away, so the best we can do is try to reduce the friction imposed upon us. Chewie was a project created by Eric Ridgeway in June 2011 with the goal of bringing Bundler like functionality to NuGet. While this solution has a number of shortcommings listed in my last NuGet post, I believe it is a much better solution that the vanilla NuGet experience. I rewrote Chewie based on many of Bundler’s features, and have come to a point where I believe it is ready for a public preview.

Sample .NugetFile

install_to 'lib'
chew Ninject [3.0.1.10]
chew Giles [0.1.4) dev -source "http://somethingrandom.feed.org"
chew NUnit

New-Group "Dev" {
  chew "Glimpse" "0.87"
}

Sample Commands

chewie init -path packages
chewie install Ninject
chewie install # installs all dependencies in the .NugetFile
chewie outdated # determines if any packages are outdated based on their version requirements
chewie update
chewie uninstall
chewie convert

Modules and Mixins for .NET: Taking Delegation to a New Level

2012-10-31T20:58:00-07:00

In the last article on prototypal inheritance using Archetype, I showed how to construct a delegation chain and simulate JavaScript’s prototypal inheritance for .NET languages. If you haven’t looked at that post, I highly recommend reading it through as I am going to skip over a lot of the theory I covered previously. Today I am taking delegation in .NET a step further. If you aren’t familiar with mixins and ruby modules, I would also recommend looking into them as what I am showing here is directly inspired by them.

When looking at prototypal inheritance for .NET, we had a very simple delegation chain. With module support we need to ammend how we evaluate and interpret expressions being called on our objects. Does the current object support the operation? Can it respond? If not, we need to loop through the prototypes (modules/mixins) that have been attached to this instance; however, as with most things in life, there is a catch. We need to process them last to first and at each level we need to start the evaluation all over again. Why last first?

When we declare a module/mixin for our class, it is taking precededence over the modules that have already been imported. This mimics the way that Ruby works. Defining a property or method that already exists redefines that member.

Revisiting the DelegatingObject (formerly PrototypalObject), I have added a new backing list to replace the single prototype from the earlier version. All existing tests and code continue to work just fine with these minimal changes. The big change is the call to creating the DynamicMetaObject with the ModuleMetaObject ctor. We are passing a collection of prototypes/modules which will be evaluated by the ModuleMetaObject which may contain many more sets of modules and delegation chains.

public class DelegatingObject : DynamicObject {
    public DelegatingObject( params object[] modules ) {
        Modules = new List<object>( modules ?? new object[]{} );
    }

    public IList<object> Modules { get; protected set; }

    public override DynamicMetaObject GetMetaObject( Expression parameter ) {
        DynamicMetaObject baseMetaObject = base.GetMetaObject( parameter );

        if ( Modules == null || Modules.Count == 0 ) {
            return baseMetaObject;
        }

        return new ModuleMetaObject( parameter, this, baseMetaObject, Modules );
    }
}

Instead of executing a preorder traversal of the module chains, we are routing all binding calls to a new method ApplyBinding which isolates all of the resolution logic to a single method. We have an additional constraint this time in that we are binding the expression to delegation chains that may fail (whereas before we had only a single chain that could fail). When this binding failure occurs, an expression with a NodeType of ExpressionType.Throw is returned and we need to ignore these failed chains. I am also able to leverage Func<,>, Func<,,>, and closures to capture the binding calls and context arguments which makes every override an easy call to ApplyBinding.

There is one operation that has a custom implementation. The BindConvert call passes a lamdba expression which calls the Convert utility method. Casting is .NET has some interesting nuances that have to be taken into account that would break when doing the module resolution if it were done just like everything else.

public class ModuleMetaObject : DynamicMetaObject
{
    private readonly DynamicMetaObject _BaseMetaObject;
    private readonly IList<object> _Modules;

    public ModuleMetaObject( Expression expression,
                             object value,
                             DynamicMetaObject baseMetaObject,
                             IList<object> modules )
            : base( expression, BindingRestrictions.Empty, value ) {
        _Modules = modules;
        _BaseMetaObject = baseMetaObject;
    }

    protected DynamicMetaObject BaseMetaObject { get { return _BaseMetaObject; } }

    protected IList<object> Modules { get { return _Modules; } }

    protected virtual DynamicMetaObject AddTypeRestrictions( DynamicMetaObject result, object value ) {
        BindingRestrictions typeRestrictions =
                GetTypeRestriction().Merge( result.Restrictions );
        var metaObject = new DynamicMetaObject( result.Expression, typeRestrictions, value );
        return metaObject;
    }

    protected virtual DynamicMetaObject CreateModuleMetaObject( object module ) {
        DynamicMetaObject moduleMetaObject = Create( module, Expression.Constant( module ) );
        return moduleMetaObject;
    }

    protected virtual BindingRestrictions GetTypeRestriction() {
        if ( Value == null && HasValue ) {
            return BindingRestrictions.GetInstanceRestriction( Expression, null );
        }
        return BindingRestrictions.GetTypeRestriction( Expression, LimitType );
    }

    protected Expression GetLimitedSelf() {
        return AreEquivalent( Expression.Type, LimitType )
                       ? Expression
                       : Expression.Convert( Expression, LimitType );
    }

    protected bool AreEquivalent( Type lhs, Type rhs ) {
        return lhs == rhs || lhs.IsEquivalentTo( rhs );
    }

    public override DynamicMetaObject BindBinaryOperation( BinaryOperationBinder binder, DynamicMetaObject arg ) {
        return ApplyBinding( meta => meta.BindBinaryOperation( binder, arg ),
                             ( target, errorSuggestion ) =>
                             binder.FallbackBinaryOperation( target, arg, errorSuggestion ) );
    }

    public override DynamicMetaObject BindConvert( ConvertBinder binder ) {
        return ApplyBinding( meta => Convert( binder, meta ), binder.FallbackConvert );
    }

    public override DynamicMetaObject BindCreateInstance( CreateInstanceBinder binder, DynamicMetaObject[] args ) {
        return ApplyBinding( meta => meta.BindCreateInstance( binder, args ),
                             ( target, errorSuggestion ) =>
                             binder.FallbackCreateInstance( target, args, errorSuggestion ) );
    }

    public override DynamicMetaObject BindDeleteIndex( DeleteIndexBinder binder, DynamicMetaObject[] indexes ) {
        return ApplyBinding( meta => meta.BindDeleteIndex( binder, indexes ),
                             ( target, errorSuggestion ) =>
                             binder.FallbackDeleteIndex( target, indexes, errorSuggestion ) );
    }

    public override DynamicMetaObject BindDeleteMember( DeleteMemberBinder binder ) {
        return ApplyBinding( meta => meta.BindDeleteMember( binder ), binder.FallbackDeleteMember );
    }

    public override DynamicMetaObject BindGetMember( GetMemberBinder binder ) {
        return ApplyBinding( meta => meta.BindGetMember( binder ), binder.FallbackGetMember );
    }

    public override DynamicMetaObject BindGetIndex( GetIndexBinder binder, DynamicMetaObject[] indexes ) {
        return ApplyBinding( meta => meta.BindGetIndex( binder, indexes ),
                             ( target, errorSuggestion ) =>
                             binder.FallbackGetIndex( target, indexes, errorSuggestion ) );
    }

    public override DynamicMetaObject BindInvokeMember( InvokeMemberBinder binder, DynamicMetaObject[] args ) {
        return ApplyBinding( meta => meta.BindInvokeMember( binder, args ),
                             ( target, errorSuggestion ) =>
                             binder.FallbackInvokeMember( target, args, errorSuggestion ) );
    }

    public override DynamicMetaObject BindInvoke( InvokeBinder binder, DynamicMetaObject[] args ) {
        return ApplyBinding( meta => meta.BindInvoke( binder, args ),
                             ( target, errorSuggestion ) => binder.FallbackInvoke( target, args, errorSuggestion ) );
    }

    public override DynamicMetaObject BindSetIndex( SetIndexBinder binder,
                                                    DynamicMetaObject[] indexes,
                                                    DynamicMetaObject value ) {
        return ApplyBinding( meta => meta.BindSetIndex( binder, indexes, value ),
                             ( target, errorSuggestion ) =>
                             binder.FallbackSetIndex( target, indexes, value, errorSuggestion ) );
    }

    public override DynamicMetaObject BindSetMember( SetMemberBinder binder, DynamicMetaObject value ) {
        return ApplyBinding( meta => meta.BindSetMember( binder, value ),
                             ( target, errorSuggestion ) =>
                             binder.FallbackSetMember( target, value, errorSuggestion ) );
    }

    public override DynamicMetaObject BindUnaryOperation( UnaryOperationBinder binder ) {
        return ApplyBinding( meta => meta.BindUnaryOperation( binder ), binder.FallbackUnaryOperation );
    }

    protected virtual DynamicMetaObject ApplyBinding( Func<DynamicMetaObject, DynamicMetaObject> bindTarget,
                                                      Func<DynamicMetaObject, DynamicMetaObject, DynamicMetaObject>
                                                              bindFallback ) {
        DynamicMetaObject errorSuggestion = ResolveModuleChain( bindTarget );
        return ( errorSuggestion == null )
            ? bindTarget( BaseMetaObject )
            : bindFallback( BaseMetaObject, errorSuggestion );
    }

    private DynamicMetaObject ResolveModuleChain( Func<DynamicMetaObject, DynamicMetaObject> bindTarget ) {
        for ( int index = Modules.Count - 1; index >= 0; index-- ) {
            object module = Modules[index];
            DynamicMetaObject metaObject = GetDynamicMetaObjectFromModule( bindTarget, module );

            if ( metaObject == null ||
                 metaObject.Expression.NodeType == ExpressionType.Throw ) {
                continue;
            }

            return metaObject;
        }
        return null;
    }

    private DynamicMetaObject GetDynamicMetaObjectFromModule( Func<DynamicMetaObject, DynamicMetaObject> bindTarget,
                                                              object module ) {
        DynamicMetaObject moduleMetaObject = CreateModuleMetaObject( module );
        DynamicMetaObject boundMetaObject = bindTarget( moduleMetaObject );
        DynamicMetaObject result = AddTypeRestrictions( boundMetaObject, boundMetaObject.Value );
        return result;
    }

    private static bool TryConvert( ConvertBinder binder, DynamicMetaObject instance, out DynamicMetaObject result ) {
        if ( instance.HasValue && instance.RuntimeType.IsValueType ) {
            result = instance.BindConvert( binder );
            return true;
        }

        if ( binder.Type.IsInterface ) {
            result = new DynamicMetaObject( Convert( instance.Expression, binder.Type ),
                                            BindingRestrictions.Empty,
                                            instance.Value );
            result = result.BindConvert( binder );
            return true;
        }

        if ( typeof (IDynamicMetaObjectProvider).IsAssignableFrom( instance.RuntimeType ) ) {
            result = instance.BindConvert( binder );
            return true;
        }

        result = null;
        return false;
    }

    private static DynamicMetaObject Convert( ConvertBinder binder, DynamicMetaObject instance ) {
        DynamicMetaObject result;
        return TryConvert( binder, instance, out result ) ? result : instance;
    }

    private static Expression Convert( Expression expression, Type type ) {
        return expression.Type == type ? expression : Expression.Convert( expression, type );
    }
}

One great thing about this implementation is that we can replicate prototypal inheritance completely. We just need to make sure that each module we create only has a single base module all the way through the chain.

With these two classes now in place, it is time to start having some fun. While there are many fun ways we can leverage the DelegatingObject to mix in behavior, today I am going to focus on one very specific usage.

Invariably, when talking about module support in .NET, one of the most common requests you will here people talk about is to have a INotifyPropertyChanged module. While this can now be easily done, we have an added benefit from the way that ModuleMetaObject handles casting. We can pass around our model object and it can be cast as INotifyPropertyChanged without the need to generate a runtime proxy. The cast will actually dig through the module hierarchy, find that we have a module which provides the interface, and return that object.

First, let’s create a utility interface and module that will help us out and abstract some boilerplate code.

public interface INotifyPropertyChanges : INotifyPropertyChanged, INotifyPropertyChanging {
    void OnPropertyChanged( string propertyName = "" );
    void OnPropertyChanging( string propertyName = "" );
}

public class NotifyPropertyChangesModule : INotifyPropertyChanges {
    public event PropertyChangedEventHandler PropertyChanged;
    public event PropertyChangingEventHandler PropertyChanging;

    public virtual void OnPropertyChanged( string propertyName = "" ) {
        PropertyChangedEventHandler handler = PropertyChanged;
        if ( handler != null ) {
            handler( this, new PropertyChangedEventArgs( propertyName ) );
        }
    }

    public virtual void OnPropertyChanging( string propertyName = "" ) {
        PropertyChangingEventHandler handler = PropertyChanging;
        if ( handler != null ) {
            handler( this, new PropertyChangingEventArgs( propertyName ) );
        }
    }
}

One thing you may notice is that I did not use the CallerMemberName attribute available in .NET 4.5. When using modules, the caller name will not be the originating caller you expect. Since we are building expression trees to call the members at runtime, you cannot rely on this new feature.

With a module in place, we can now create a model which can have the functionality weaved in:

public class Person : DelegatingObject {
    private string _Name;

    public Person()
            : this( new NotifyPropertyChangesModule() ) { }

    public Person( params object[] modules )
            : base( modules ) { }

    public string Name {
        get { return _Name; }
        set {
            This.OnPropertyChanging( "Name" );
            if ( _Name != value ) {
                _Name = value;
                This.OnPropertyChanged( "Name" );
            }
        }
    }

    private dynamic This { get { return this; } }
}

The implementation is pretty simple. The thing to remember is that in order for the module chain to trigger, whether you are in the object or acting on the model object, the invocation must take place on a dynamic object. I have provided a simple property This which casts the model object to dynamic allowing us to access the latebound method calls.

There are a few different ways we can work with this object now:

public void UsingModelObjectAsDynamic() {
    dynamic person = new Person();
    // The cast to the interface will work returning the inner module
    INotifyPropertyChanges inpc = person;
    inpc.PropertyChanged +=
            ( sender, args ) => Console.WriteLine( "The field {0} has changed.", args.PropertyName );
    inpc.PropertyChanging +=
            ( sender, args ) => Console.WriteLine( "The field {0} is changing.", args.PropertyName );
    // We have full IntelliSense when working with inpc,
    // but now accessing person.Name looses IntelliSense
    person.Name = "Inigo Montoya"; // trigger the events
}

public void UsingModelObjectAsStronglyTyped() {
    Person person = new Person();
    // Casting first to dynamic triggers the DelegatingObject's casting system
    INotifyPropertyChanges inpc = (dynamic) person;
    inpc.PropertyChanged +=
            ( sender, args ) => Console.WriteLine( "The field {0} has changed.", args.PropertyName );
    inpc.PropertyChanging +=
            ( sender, args ) => Console.WriteLine( "The field {0} is changing.", args.PropertyName );
    // We have full IntelliSense when working with person.
    person.Name = "Inigo Montoya"; // trigger the events
}

Sometimes, we may want to handle accessing the interface provided by a module. Again leveraging the dynamic casting, we can create a new property which will provide us access to the interface. I have also created a new Age property which takes advantage of this feature and now gives us IntelliSense when acting on the INotifyPropertyChanges feature.

private int _Age;

public int Age {
    get { return _Age; }
    set {
        Inpc.OnPropertyChanging( "Age" );
        if ( _Age != value ) {
            _Age = value;
            Inpc.OnPropertyChanged( "Age" );
        }
    }
}

internal INotifyPropertyChanges Inpc { get { return This; } }

We can also leverage this property to provide external access to our mixed in behavior:

public void UsingModelWithProxyCastingProperty() {
    Person person = new Person();
    // The cast property to give us IntelliSense
    person.Inpc.PropertyChanged +=
            ( sender, args ) => Console.WriteLine( "The field {0} has changed.", args.PropertyName );
    person.Inpc.PropertyChanging +=
            ( sender, args ) => Console.WriteLine( "The field {0} is changing.", args.PropertyName );
    // We also still have IntelliSense on Name
    person.Name = "Inigo Montoya"; // trigger the events
}

So far, each model has received its own instance of a module, but that is by no means the only usage pattern. Object’s can share modules and behavior:

public void ShareModulesToShareBehavior() {
    var module = new NotifyPropertyChangesModule();
    module.PropertyChanged +=
            ( sender, args ) => Console.WriteLine( "The field {0} has changed.", args.PropertyName );
    module.PropertyChanging +=
            ( sender, args ) => Console.WriteLine( "The field {0} is changing.", args.PropertyName );
    Person inigo = new Person( module ) { Name = "Inigo" };
    Person ian = new Person( module ) { Name = "Ian" };
    // Four events triggered by setting the names, 2x Changed, 2x Changing
    inigo.Age = 35;
    ian.Age = 30;
    // The module is now acting somewhat like a message channel in a message broker
}

This barely scratches the surface of what is possible, but hopefully it gives you a taste.

Another simple pattern you can apply is adding an ExpandoObject to the beginning of your module chain (thus it is the last resolved). This will give you a fallback behavior of the Expando should all else fail. You can also create a system to handle an analog to method_missing by overriding the TryXyz members you get when deriving from DelegatingObject (via DynamicObject). I playing around with a sample implementation right now which will also delegate to static members.

If you find this interesting or have ideas for other modules, I’d love to hear about them.

NuGet: You're Doing it Wrong

2012-10-29T19:23:00-07:00

NuGet is the new (well, relatively new) hotness. Everyone loves NuGet. I am even guilty of extolling some of its virtues. I am not going to talk about the things which NuGet does well as they have been documented over and over again, and I don’t really have anything to add to those lists of awesome features. I can’t, however, advocate the way the owners of NuGet have taken the product.

Microsoft, along with most of the industry, went from using build domain specific languages (DSL) to drowning in XML. MSBuild, Ant, NAnt, XBuild, etc are all anathemas to our profession. Don’t get me wrong, they served their purpose, but we have to learn from those mistakes and move toward build systems based on coded build scripts using tools like Rake and Albacore, jake, and psake.

Leveraging existing programming languages, we can utilize their capabilities in creating DSLs to run our builds. Funny as this is, we have now come full circle, but with a better understanding of what a build should be.

Why bring this up? This applies directly to NuGet’s exhaustive use of XML. In addition, we have NuGet’s incredibly limited command-line outside of Visual Studio, and the choices to disempower users with unneeded hand holding. There is an incredible focus to force users to manage their dependencies inside of Visual Studio with a number of features, such as the PowerShell tool scripts, only working when you have the solution loaded.

Ruby

Ruby has had a package management system, gems, and a dependency bundling tool, bundler, for years. Gem specs are ruby code veiled in a thin DSL. You can see examples in the rspec gemspec and Albacore gemspec . They were made simple, leveraging the language and incredibly powerful.

Bundler scripts are ruby code veiled in a thin DSL which defines the external dependencies in one place (in addition it has a GemFile.lock which ensures other developers will use the same packages that you are based on all of your packages’ dependency versioning requirements). Again, we can look to the elegant simplicity of the Albacore Gemfile for an example.

The ruby community has fully embraced their language, package management system, and made them first class citizens. When you clone a repo, you execute ‘bundle install’ and all of your dependencies are pulled down. You do this once. From then on you can check for updates, verify that packages are up-to-date, and all other dependency lifecycle tasks. You can also manage your gem projects with the Jewler gem; it has some very enticing features (if you looked at the Albacore gemspec, you likely saw that it is generated by Jewler).

What about NuGet?

NuGet defines its specs with XML. And to be all great and powerful XML, it is schema validated. Ninety-three percent of the first three lines of a package are copy & paste noise. This is a waste of time and hides the intent of the spec.

<?xml version="1.0"?>
<package xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <metadata xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">

NuGet defines its dependencies with XML and manages its local package configurations with a repositories.config file and many, many packages.config files. Each of these packages.config files are stored in each project folder. If you use NuGet, the way it is designed to work, you have no way of seeing what dependencies your application actually has without loading your solution into VS and making sure that all of these config files are checked in across your codebase.

Examples

Let’s start by taking a look at a simple spec definition.

<?xml version="1.0"?>
<package xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <metadata xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
    <id>Ninject</id>
    <version></version>
    <authors>Ninject Project Contributors</authors>
    <requireLicenseAcceptance>true</requireLicenseAcceptance>
  <licenseUrl>https://github.com/ninject/ninject/raw/master/LICENSE.txt</licenseUrl>
  <summary>IoC container for .NET</summary>
    <language>en-US</language>
  <tags>Ninject ioc di</tags>
  <iconUrl>https://github.com/ninject/ninject/raw/master/logos/Ninject-Logo32.png</iconUrl>
  <projectUrl>http://www.ninject.org</projectUrl>
  </metadata>
</package>

Pulling directly from Giles rakefile which uses Albacore to generate the XML spec:

desc "Create the nuspec"
nuspec :createSpec => :prepPackage do |nuspec|
    nuspec.id = "Giles"
    nuspec.version = @GilesVersion
    nuspec.authors = "Jeff Schumacher (@codereflection)"
    nuspec.owners = "Jeff Schumacher (@codereflection)"
    nuspec.description = "Giles - continuous test runner for .NET applications."
    nuspec.summary = "Currently supports Machine.Specifications (mspec), NUnit, xUnit.net, and NSpec"
    nuspec.language = "en-US"
    nuspec.projectUrl = "http://testergiles.herokuapp.com/"
    nuspec.title = "Giles, Rupert Giles, at your service!"
    nuspec.tags = "testrunner test unittest giles"
    nuspec.output_file = "Giles.nuspec"
    nuspec.working_directory = "deploy/package"
    nuspec.licenseUrl = "https://github.com/codereflection/Giles/blob/master/License.txt"
end

desc "Create the nuspec package"
nugetpack :createPackage do |nugetpack|
    nugetpack.nuspec = "deploy/package/Giles.nuspec"
    nugetpack.base_folder = "deploy/package"
    nugetpack.output = "deploy"
end

We can replicate this with a simple PowerShell script where we give the user a simple object which properties are attached.

param($spec)
$spec.id = Ninject
$spec.version = 3.1.0.8
$spec.authors = @(‘Ninject Project Contributors’)
$spec.requireLicenseAcceptance = $true
$spec.licenseUrl = https://github.com/ninject/ninject/raw/master/LICENSE.txt
$spec.summary = “IoC container for .NET”
$spec.language = en-US
$spec.tags = @(‘Ninject’, ‘ioc’, ‘di’)
$spec.iconUrl = https://github.com/ninject/ninject/raw/master/logos/Ninject-Logo32.png
$spec.projectUrl = http://www.ninject.org

There are additional properties such as dependencies, frameworkAssemblies, and files. With a scripted definition, these nodes are very simple, and we can actually use file sets and collections to specify values instead of wildcards and long lists.

In the Beginning

Perhaps the craziest part is that NuGet started with Nubular (Nu), which was implemented via ruby gems. Let that sink in for a moment. The package management system for .NET was once ruby based. Here is an original package definition for AutoFac

version = File.read(File.expand_path("../VERSION", __FILE__)).strip
Gem::Specification.new do |spec|
  spec.platform  = Gem::Platform::RUBY
  spec.name      = 'autofac'
  spec.version   = version
  spec.files = Dir['lib/**/*'] + Dir['docs/**/*']
  spec.summary   = 'Autofac - An addictive .NET IoC container'
  spec.description = 'Autofac is an IoC container for Microsoft .NET. It manages the dependencies between classes so that applications stay easy to change as they grow in size and complexity. This is achieved by treating regular .NET classes as components.'
  spec.authors           = ['Nicholas Blumhardt','Rinat Abdulin']
  spec.email             = 'emailme@bilsimser.com'
  spec.homepage          = 'http://code.google.com/p/autofac/'
  spec.rubyforge_project = 'autofac'
end

If you go to the Nu website, you’ll see this at the top:

February 2011 - The collaborative effort of the Nubular team and Microsoft has produced NuGet.

I wasn’t involved, but it seems to me that collaborative is a synonym for neutering. They took a thriving ecosystem with working solution and then stepped back years technologically. Microsoft couldn’t embrace Ruby; especially with the way it abandoned IronRuby. NuGet became the TFS of package management: highly integrated and doing nothing well.

Package Restore

I traveled to Portland and paired up with another developer to try to cut some code. We pulled down a repo, and then proceeded to trip all over ourselves…err, NuGet…for quite a while. The project we were dealing with, unsurprisingly, relied on NuGet package restore.

We were surprised at every step dealing with packages hooking into the csproj targets, build steps, and tooling incompatibilities. In the end, we changed frameworks and were finally able to rip out NuGet’s parasitic attachment to our project.

NuGet package restore is a feature in which NuGet embeds itself into your project files

<project>
  <propertyGroup>
    <RestorePackages>true</RestorePackages>
  </propertyGroup>
  <!-- your project contents-->
  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
</project>

It also creates a .nuget folder at your solution root which contains NuGet.config, NuGet.exe, and NuGet.targets.

When you pull down a project/solution that uses package restore, and then try to build it, you get an error (well, many errors most likely, but they are the same). NuGet, through its targets hook, will call:

"$(SolutionDir).nuget\nuget.exe" install "C:\<PathTo>\packages.config" -source ""
      -RequireConsent -o "$(SolutionDir)\packages"

Where <PathTo> is changed for every packages.config littered in your codebase.

C:\Dev\SomeProject\.nuget\NuGet.targets(80,9): error : Package restore is disabled by default.
To give consent, open the Visual Studio Options dialog, click on Package Manager node and
check 'Allow NuGet to download missing packages during build.' You can also give consent by
setting the environment variable 'EnableNuGetPackageRestore' to 'true'. [C:\Dev\SomeProject\src\SomeProject\SomeProject.csproj]
C:\Dev\SomeProject\.nuget\NuGet.targets(80,9): error : One or more errors occurred. [C:\Dev\SomeProject\src\SomeProject\SomeProject.csproj]

So, now I need to either open Visual Studio and find the setting they list, or I need to create an environment variable and set the value to true. Now, we have to configure package restore on each developer’s machine, plus the build server to deal with this requirement.

There is something more insidious hiding inside your build due to package restore. When you run your build, it is not a one-time install of your application’s dependencies. NuGet will run a package install for every single package in every project that has a packages.config file. Let’s look at the log output from building a solution with package restore:

> msbuild SomeProject.sln
...
RestorePackages:
  "C:\dev\SomeProject\.nuget\nuget.exe" install "C:\dev\SomeProject\src\SomeProject\packages.config
  " -source ""  -RequireConsent -solutionDir "C:\dev\SomeProject\ "
  All packages listed in packages.config are already installed.

The build will always run the nuget.exe install call for every build. Every build you have is now slower, and will be slower still for each project you add that makes this redundant call (nuget will detect that the packge is already installed, but it is still slowing your build and filling your logs with garbage).

NuGet is also dealing with privacy issues related to package restore. Had the NuGet team stuck with Nu’s original implementation, there would have never been a need for package restore with everything handled with Bundler. Ruby’s gem system isn’t the greatest in the world, and there are growing numbers of people that are talking about trying something else, but they are still years ahead of the NuGet.

NuGet.exe

NuGet on the command line is a shadow of its Package Manager Console self. NuGet.exe:

Can’t update a package, let alone all, without being given a packages.config file. (I hear this is being fixed)
Can’t remove a package, at all.
Does not run init.ps1, install.ps1, or uninstall.ps1 leaving your packages broken when used outside of Visual Studio. You don’t have a DTE instance, so even if the scripts were executed, they wouldn’t work. Package installation has been designed to force a user into Visual Studio to install a dependency.
With the config parameter: gets or sets NuGet config values - except that you don’t know what keys exist so you can’t see the config values.
When using packages.config will get the exact version in the file no matter what.
Doesn’t get dependencies at all when using packages.config; they are expected to be in the file already.

You can’t specify a compatible set of versions in your packages.config files should one or more of your dependencies require a different, but still compatible version of a shared dependency. I can hear you objecting with “you can use allowedVersions”:

<package id="log4net" version="1.2.10" allowedVersions="[1.2.10]" />

This however, doesn’t work; it is broken by design. Using allowedVersions means you’d have to track down every packages.config file and manually edit it to add this attribute. Even worse, NuGet looks at each packages.config individually so it can’t see version compatibility issues with allowedVersions.

NuGet appends the version of the library to the name when creating a folder in the Packages folder. This means that any updates require you to update every one of your project files with a new file path. This is a weak argument, but we should be given an easy way to override this without manually creating the calls to nuget.exe or install-package.

One item, that may be the coup de grâce of NuGet’s feature failings relates to how package sources are specified. How do you know where a particular dependency is sourced? We can see an example with xUnit. If we open the xunit NuGet.targets file:

<ItemGroup Condition=" '$(PackageSources)' == '' ">
  <PackageSource Include="https://nuget.org/api/v2/" />
  <PackageSource Include="http://www.myget.org/F/b4ff5f68eccf4f6bbfed74f055f88d8f/" />
</ItemGroup>

When you look at a dependency, you have no idea where that dependency is coming from. NuGet will have to check each feed to find where a particular package resides. What happens if the package is in both feeds? What if you want the version from your own feed to be used? This is just another example of making the tool work like magic and finding yet another place to configure NuGet.

Now, to figure out what dependencies I have, and where they come from, I have to look through three different types of XML files. Even though once I have done that, I may not know where those dependencies even come from.

The End?

Will I stop using NuGet? No. Will I be happy using it? No. Will I stop complaining? Hell no. Pretending that everything is great will never push us to do better. I’ll do everything I can to remove NuGet’s way of doing things and put in my own.

Finishing Questions

Do we host a new gems website and write some importer form nuget to convert packages to gems?
Will we write something gemlike?
Can we analyze gems’ and NuGet’s failings to design a better system?
Can we create tooling around a cross platform DSL other than XML?
The use of PowerShell and reliance on Visual Studio really hurts mono development on Linux using nuget. What could we use instead? Can we push Microsoft to make PowerShell OSS?
Can Nemerle be leveraged to create a DSL that will work for mono as well?
Do we rewrite nuget the correct way? Correct being first class, OS independent CLI and no XML. The CLI is the most important thing in most camps. It should be the case, but it obviously isn’t since MS took over NuGet. There is a whole camp that thinks the GUI is the most important thing; then there is MS that tries to make all free things tie into paid products somehow. They would be wrong. I understand their perspective, but it is the wrong choice. When developing free software, choose to do it right. By creating the deep integration into Visual Studio and abandoning the command line, we are forced to use Visual Studio in order to leverage NuGet, thus destroying any competition.

Prototypal Inheritance in .NET: Delegation at Last

2012-10-08T17:19:00-07:00

In .NET 4.0, we have access to the Dynamic Language Runtime (DLR) giving us dynamic dispatch via the IDynamicMetaObjectProvider interface coupled with the dynamic keyword. When a variable is declared as dynamic and it implements the IDynamicMetaObjectProvider interface, we are given the opportunity to control the delegation of calls on that object by returning a DynamicMetaObject containing an expression which will be evaluated by the runtime. We only get this opportunity if the direct target was unable to directly handle the expression.

The DynamicObject and ExpandoObject classes both implement IDynamicMetaObjectProvider, but their implementations are explicitly implemented and the nested classes used to return the DynamicMetaObject are private and sealed. I understand that the classes may not have been tested enough to make them inheritable, but not having access to these classes really hurts our ability to easily modify the behavior of the underlying DynamicMetaObject. The key word here is easily; implementing the needed expression building is a great deal of work and the internal workings of the Microsoft implementations leverage many internal framework calls.

A key thing to consider is that we don’t want to replicate classical inheritance; instead, we are going to focus on prototypal inheritance that mostly replicates JavaScript’s prototypal inheritance. Rather than trying to replicate all of the hard work that the DRL team put into writing their implementation, we can add our own implementation on top of theirs. It is simple to hook in, but we need to save off a method to access the base DynamicMetaObject implementation. This will allow us to attempt to interpret the expression on the object itself or pass it along.

public class DelegatingPrototype : DynamicObject {
    public DelegatingPrototype( object prototype = null ) {
        Prototype = prototype;
    }

    public virtual object Prototype { get; set; }

    public override DynamicMetaObject GetMetaObject( Expression parameter ) {
        if ( Prototype == null ) {
            return GetBaseMetaObject( parameter );
        }
        return new PrototypalMetaObject( parameter, this, Prototype );
    }

    public virtual DynamicMetaObject GetBaseMetaObject( Expression parameter ) {
        return base.GetMetaObject( parameter );
    }
}

This small amount of code just sets the hook. Now we need set up the delegation expression.

To set up the prototypal hierarchy, we are going to need to do a lot of recursion. Unfortunately, it is well hidden (I’ll explain shortly). When a call is made on the root object, we are given the expression being interpreted. Using the IDynamicMetaObjectProvider overload, we will hand off the expression to the PrototypalMetaObject to construct delegation expression (or the DynamicObject implementation if our prototype is null thus trying to interpret the expression on the current object). We want to make a preorder traversal of the prototype hierarchy; at each step, the current object’s evaluation will take precedence over its prototype tree. Consider the following prototypal class hierarchy:

Since we never know which level of the hierarchy will be handling the expression, we need to build an expression for the entire tree every time. We want to get the DynamicMetaObject representing the current object’s tree first. Once done, we get the DynamicMetaObject for evaluating the expression on the current instance. With these two, we can create a new DynamicMetaObject which try to bind the expression to the current instance first, and then fallback to the prototype. At the root level, the prototype DynamicMetaObject contains the same fallback for the next two layers.

There is another caveat that we need to address. When we try to invoke and expression on an object, the expression is bound to that type. When accessing the prototype, if we don’t do anything, the system will throw a binding exception because the matching object won’t match the DynamicMetaObject’s type restrictions. To fix this, we need to relax the type restrictions for each prototype.

To iterate is human, to recurse is divine, to inception recurse is demented
L. Peter Deutsch Paraphrased

Remember the recursion I mentions earlier? In the code sample below, I have pulled out all binding code except for the BindInvokeMember method. The _metaObject.Bind[...] will actually call into DelegatingPrototype::GetMetaObject which will try to call back into _metaObject.Bind[...], which will…well you get the idea. At each call, the prototype becomes the target and we get a new prototype.

public class PrototypalMetaObject : DynamicMetaObject {
    private readonly DynamicMetaObject _baseMetaObject;
    private readonly DynamicMetaObject _metaObject;
    private readonly DelegatingPrototype _prototypalObject;
    private readonly object _prototype;

    public PrototypalMetaObject( Expression expression, DelegatingPrototype value, object prototype )
            : base( expression, BindingRestrictions.Empty, value ) {
        _prototypalObject = value;
        _prototype = prototype;
        _metaObject = CreatePrototypeMetaObject();
        _baseMetaObject = CreateBaseMetaObject();
    }

    protected virtual DynamicMetaObject CreateBaseMetaObject() {
        return _prototypalObject.GetBaseMetaObject( Expression );
    }
  
    protected virtual DynamicMetaObject CreatePrototypeMetaObject() {
        Expression castExpression = GetLimitedSelf();
        MemberExpression memberExpression = Expression.Property( castExpression, "Prototype" );
        return Create( _prototype, memberExpression );
    }

    protected Expression GetLimitedSelf() {
        return AreEquivalent( Expression.Type, LimitType ) ? Expression : Expression.Convert( Expression, LimitType );
    }

    protected bool AreEquivalent( Type lhs, Type rhs ) {
        return lhs == rhs || lhs.IsEquivalentTo( rhs );
    }
      
    protected virtual BindingRestrictions GetTypeRestriction() {
        if ( Value == null && HasValue ) {
            return BindingRestrictions.GetInstanceRestriction( Expression, null );
        }
        return BindingRestrictions.GetTypeRestriction( Expression, LimitType );
    }

    protected virtual DynamicMetaObject AddTypeRestrictions( DynamicMetaObject result ) {
        BindingRestrictions typeRestrictions = GetTypeRestriction().Merge( result.Restrictions );
        return new DynamicMetaObject( result.Expression, typeRestrictions, _metaObject.Value );
    }
  
    public override DynamicMetaObject BindInvokeMember( InvokeMemberBinder binder, DynamicMetaObject[] args ) {
        DynamicMetaObject errorSuggestion = AddTypeRestrictions( _metaObject.BindInvokeMember( binder, args ) );
        return binder.FallbackInvokeMember( _baseMetaObject, args, errorSuggestion );
    }
}

You may be thinking, ok, this is cool, but what use it is it? What is the use case? First, it’s cool. Second, it sets the foundation for .NET mixins. Third, it gives us a second form of inheritance (after parasitic) for PowerShell.

What if we take the prototype and make it a collection of prototypes? What if instead of inheriting from DelegatingPrototype we reuse the internal prototypal skeleton? If this sounds familiar, it should. I am describing ruby classes with modules and a base class, but with C#…

If you want to see more or play around with the code, you can find full implementations in the Archetype project.

Project Euler: Problem 10 in PowerShell

2012-10-02T13:20:00-07:00

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
Find the sum of all the primes below two million.
Project Euler Problem 10

This problem is very simple as I can reuse the parasitic prime generation from my solution to Problem 7 which also requires Prototype.ps.

function New-PrimeFinder {
  $prototype = New-PrimeGenerator
  $prototype | Add-Function FindPrimesLessThan {
    param($value)
    if($this.Bound -lt $value) {
      $finder.BoundIncrement = $value - $this.Bound
      $this.Expand()
    }
    return $this.Primes | ? { $_ -lt $value }
  }
  $prototype
}

function Solve-Problem10 {
  param($value = 2000000)
  $finder = New-PrimeFinder
  $finder.FindPrimesLessThan($value) | % {[long]$sum = 0} {$sum+=$_} {$sum}
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem10}).TotalSeconds
Write-Host "Solution: " (Solve-Problem10)

Elapsed Time (s):  1999.6739304
Solution:  142913828922

Project Euler: Problem 9 in PowerShell

2012-10-01T20:15:00-07:00

A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
a^2 + b^2 = c^2
For example, 32 + 42 = 9 + 16 = 25 = 52.
There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.
Project Euler Problem 9

function Solve-Problem9 {
  $sum = 1000
  $found = $false
  for ($a = 1; $a -lt $sum / 3; $a++) {
    for ($b = $a; $b -lt $sum / 2; $b++) {
      $c = $sum - $a - $b

      if ($a * $a + $b * $b -eq $c * $c) {
        $found = $true
        break
      }
    }

    if ($found) { break }
  }

  Write-Host "The Pythagorean triplet is a = $a, b = $b, c = $c"
  Write-Host "The product is $($a*$b*$c)"
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem9}).TotalSeconds
The Pythagorean triplet is a = 200, b = 375, c = 425
The product is 31875000
Elapsed Time (s):  0.2247551

Project Euler: Problem 8 in PowerShell

2012-09-30T18:51:00-07:00

Find the greatest product of five consecutive digits in the 1000-digit number.
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
Project Euler Problem 8

function Split-Number {
  param([string]$value)
  $index = 0
  while($index -lt $value.Length - 4) {
    $value.Substring($index++, 5)
  }
}

filter Evaluate-String {
  $_.ToCharArray() | % { [int]::Parse($_) } | % {$total = 1} {$total *= $_} {$total}
}

function Solve-Problem8 {
  $text = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"

  (Split-Number $text | Evaluate-String | Measure-Object -Maximum).Maximum
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem8}).TotalSeconds
Write-Host "Solution: " (Solve-Problem8)

Elapsed Time (s):  0.5708985
Solution:  40824

Project Euler: Problem 7 in Parasitic PowerShell

2012-09-28T17:45:00-07:00

This post leverages my OSS project Prototype.ps to support parasitic object creation. If you haven’t read the introduction posts Part 1 and Part 2, I would recommend reading them as I build off of their functionality and theory. If you don’t care how it works, read on my friend.

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
What is the 10,001st prime number?
Project Euler Problem 7

Solving Using a Prototypal Object

function New-PrimeGenerator {
  $prototype = New-Prototype
  $prototype | Update-TypeName
  $prototype | Add-Property Primes @(2,3,5)
  $prototype | Add-Property Cache @{2=$true; 3=$true; 4=$false; 5=$true}
  $prototype | Add-Property Bound 5
  $prototype | Add-Property BoundIncrement 1000
  $prototype | Add-Property LastExpansionPrimeCount 3
  $prototype | Add-ScriptProperty MaxPrime {$this.Primes | select -last 1}
  $prototype | Add-Function IsPrime {
    param($value)
    while ($this.MaxPrime -lt $value) { $this.Expand() }
    return $this.Cache[$value] -ne $null
  }
  $prototype | Add-Function FindNthPrime {
    param($value)
    while ($this.Primes.Length -lt $value) { $this.Expand() }
    return $this.Primes[$value-1]
  }
  $prototype | Add-Function RoundToNextMultiple {
    param($base, $multiple)
    $remainder = $base % $multiple;
    if($remainder -eq 0) { $base }
    else { $base + $multiple - $remainder }
  }
  $prototype | Add-Function Expand {
    $oldBound = $this.Bound
    if($this.LastExpansionPrimeCount -le $this.Primes.Length) {
      $this.Bound += $this.BoundIncrement
    }
    $limit = $this.Bound
    $cache = $this.Cache
    $this.Primes | % {
      for ($i=$this.RoundToNextMultiple($oldBound,$_); $i -le $limit; $i += $_ ) {
        if(!$cache.ContainsKey($i)) { $cache[$i] = $false }
      }
    }
    ($oldBound+1)..$limit | ? { $cache[$_] -eq $null } | % {
      $cache[$_] = $true
      $this.Primes += @($_)
      for ($i=$this.RoundToNextMultiple($oldBound,$_); $i -le $limit; $i += $_ ) {
        if(!$cache.ContainsKey($i)) { $cache[$i] = $false }
      }
    }
    $this.LastExpansionPrimeCount = $this.Primes.Length
  }
  $prototype
}

function Solve-Problem7 {
  $generator = New-PrimeGenerator
  Write-Host "Elapsed Time (s): " (Measure-Command {$generator.FindNthPrime(10001)}).TotalSeconds
  Write-Host "Elapsed Time (s): " (Measure-Command {$generator.FindNthPrime(10001)}).TotalSeconds
  Write-Host "Solution: " ($generator.FindNthPrime(10001))
}

Solve-Problem7

Elapsed Time (s):  33.1381042
Elapsed Time (s):   0.0003987
Solution:  104743

Project Euler: Problem 6 in PowerShell

2012-09-27T13:00:58-07:00

The sum of the squares of the first ten natural numbers is,
1^2 + 2^2 + … + 10^2 = 385
The square of the sum of the first ten natural numbers is,
(1 + 2 + … + 10)^2 = 55^2 = 3025
Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025-385 = 2640.
Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.
Project Euler Problem 6

function Solve-Problem6 {
  $sum = (1..100 | Measure-Object -Sum).Sum
  $sumOfSquares = (1..100 | % {$_*$_} | Measure-Object -Sum).Sum
  $sum * $sum - $sumOfSquares
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem6}).TotalSeconds
Write-Host "Solution: " (Solve-Problem6)

Elapsed Time (s):  0.0115265
Solution:  25164150

Project Euler: Problem 5 in PowerShell

2012-09-26T13:00:58-07:00

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?
Project Euler Problem 5

The next problem is just folding two values from an array and replacing them with their LCM, then run again and again until only one item is left in the collection (and you now have the LCM of all entries).

function Get-Gcd {
  param($lhs, $rhs)
  if ($lhs -eq $rhs) { return $rhs }
  if ($lhs -gt $rhs) { $a,$b = $lhs,$rhs }
  else { $a,$b = $rhs,$lhs }
  while ($a % $b -ne 0) {
    $tmp = $a % $b
    $a,$b = $b,$tmp
  }
  return $b
}

function Get-Lcm {
  param($lhs, $rhs)
  [long][Math]::Abs($lhs * $rhs) / (Get-Gcd $lhs $rhs)
}

function Get-LcmOfGroup {
  param([int[]]$values)
  $lhs = $values[0]
  $rhs = $values[1]
  $lcm = Get-Lcm $lhs $rhs
  $values = @($lcm) + $values[2..$values.Length]
  if($values.Length -eq 1) { return $lcm }
  else { Get-LcmOfGroup $values }
}

function Solve-Problem5 {
  Get-LcmOfGroup @(1..20)
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem5}).TotalSeconds
Write-Host "Solution: " (Solve-Problem5)

Elapsed Time (s):  0.0407472
Solution:  232792560

Project Euler: Problem 4 in PowerShell

2012-09-25T13:00:58-07:00

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91*99.
Find the largest palindrome made from the product of two 3-digit numbers.
Project Euler Problem 4

function Solve-Problem4 {
  (100..999 | % {
    $lhs = $_
    100..999 | % {
      $rhs = $_
      $product = $lhs * $rhs
      $value = $product.ToString()
      if($value -eq ($value[$value.Length..0] -join "")) {$product}
    }
  } | Measure-Object -Maximum).Maximum
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem4}).TotalSeconds
Write-Host "Solution: " (Solve-Problem4)

Elapsed Time (s):  87.4686333
Solution:  906609

Project Euler: Problem 3 in PowerShell

2012-09-15T13:00:00-07:00

The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ?
Project Euler Problem 3

Generating prime factors is another simple algorithm. We divide off all of the 2’s, then we take off the 3’s, but from there we skip two instead of one as we already pulled out all of the possible even factors.

function Get-PrimeFactors {
  param([long]$number)
  while($number % 2 -eq 0) {
     2
     $number /= 2
  }
  $bound = [Math]::Sqrt($number)
  for($i = 3; $i -le $bound; $i += 2) {
     while($number % $i -eq 0) {
        $number /= $i
        $i
     }
  }
  $number
}

function Solve-Problem3 {
  Get-PrimeFactors 600851475143 | select -last 1
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem3}).TotalSeconds
Write-Host "Solution: " (Solve-Problem3)

Elapsed Time (s):  0.0477742
Solution:  6857

Project Euler: Problem 2 in PowerShell

2012-09-15T05:00:00-07:00

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …
By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.
Project Euler Problem 2

The Fibonacci sequence is much more fun. You can get close to this implementation with yield return in C#, but the multiple assignment trick has yet to come to C# :(.

function Get-FibonacciSequence {
  param([int]$max)
  0
  1
  for($i = $j = 1; $i -lt $max) {
    $i
    $i,$j = ($i + $j),$i
   }
}

filter Select-EvenValues { if($_ % 2 -eq 0) { $_ } }

function Solve-Problem2 {
  $upperBound = 4000000
  $evenValues = (Get-FibonacciSequence $upperBound) | Select-EvenValues
  ($evenValues | Measure-Object -Sum).Sum
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem2}).TotalSeconds
Write-Host "Solution: " (Solve-Problem2)

Elapsed Time (s):  0.0049869
Solution:  4613732

Project Euler: Problem 1 in PowerShell

2012-09-14T21:00:00-07:00

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.
Project Euler Problem 1

The first problem is rather easy. We just need to generate a sequence, filter it, and them sum the results. Calculating sums in PowerShell is syntactically awkward as you can see in the different examples.

One item that will probably stand out as odd is the | % -begin {} -process {} -end {} in which I am effectively creating a stateful function in the pipe.

function Solve-Problem1 {
  # using Measure-Object
  (1..999 | ? {$_ % 5 -eq 0 -or $_ % 3 -eq 0} | Measure-Object -Sum).Sum

  # using begin, process, end blocks
  1..999 | ? {$_ % 5 -eq 0 -or $_ % 3 -eq 0}| % -begin {$sum=0} -process {$sum+=$_} -end {$sum}

  # cleaning up a bit
  1..999 | ? {$_ % 5 -eq 0 -or $_ % 3 -eq 0}| % {$sum = 0} {$sum += $_} {$sum}
}

Write-Host "Elapsed Time (s): " (Measure-Command {Solve-Problem1}).TotalSeconds
Write-Host "Solution: " (Solve-Problem1)

Elapsed Time (s):  0.0606135
Solution:  233168

Prototypal Inheritance Using PowerShell (Part 4): Static Properties

2012-08-29T15:15:00-07:00

If you didn’t read Part 1 and Part 2, I would recommend reading them as I build off of their functionality and theory.

In the previous articles I built a simple platform and API to help create PowerShell objects mimicking prototypal inheritance. Each object created with the Prototype.ps API is essentially classless but instead has a loose specification and the actual ‘class’ of the object is held in its underlying PSObject.TypeNames member. We can leverage these type names while we are extending the underlying object to create proxy properties.

Why proxy properties? When adding a static property, we have a small problem. Due to the lack of control that we have for dispatching, we can’t control how missing methods are handled, and thus we must define any methods that we want to be able to call. This also means that it does not make sense to attach static properties after object creation (outside of the object definition) as we cannot delegate the calls dynamically (any existing references would be missing the proxy property).

The Common Language Infrastructure (CLI) defines the Common Type System (CTS) which lays the groundwork for how the type system in .NET works. In the CTS definition, the runtime holds a single instance of a Type (e.g., there is one instance of the Console Type which should not be confused with an instances of the Console class); by mimicking this model, we can instantiate a shared ‘type’ object on which we can attach ‘static’ behavior and properties. Then, we can attach a proxy property on the instances which will call into this single instance.

The first step is to add a line to both the New-Prototype and Update-TypeName which will create the static instance if it doesn’t exist.

function New-Prototype {
  param(
    $baseObject = (new-object object)
  )
  process {
    $prototype = [PSObject]::AsPSObject($baseObject)
    $prototype.PSObject.TypeNames.Insert(0,"Prototype")
    $prototype | Add-StaticInstance
    $prototype
  }
}

function Update-TypeName {
  process {
    $caller = (Get-PSCallStack)[1].Command
    $caller = $caller -replace "new-", [string]::Empty
    $caller = $caller -replace "mixin-", [string]::Empty
    $derivedTypeName = $_.PSObject.TypeNames[0]
    if($derivedTypeName) {
      $derivedTypeName = "$derivedTypeName#{0}" -f $caller
    }
    $_.PSObject.TypeNames.Insert(0,"$derivedTypeName")
    $_ | Add-StaticInstance
  }
}

To simplify the implementation, I create a global registry that will match the TypeName to the shared instance. If the registry does not exist, then we create it. Once we have a registry, we need to get the current TypeName of the instance passed in from the pipeline. If the current TypeName has not been added to registry, we create a new object and wrap it in a PSObject which will allow us to extend the object and assign the new object’s TypeName to that of the current pipe object. Once done, I add the new object into the global registry.

function Add-StaticInstance {
  process {
    # Create the static instance registry to mimic the CTS's single class instance per type
    if($Global:__CTS__ -eq $null) {
      $dictionary = (New-Object -TypeName 'System.Collections.Generic.Dictionary[string,object]'
                                -ArgumentList @([StringComparer]::OrdinalIgnoreCase))
      $value = [PSObject]::AsPSObject($dictionary)
      $Global:__CTS__ = $value
    }
    $registry = $Global:__CTS__
    $key = $_.PSObject.TypeNames[0]

    # If this 'type' has not been added, create a new psobject and add it
    if(!$registry.ContainsKey($key)) {
      $instance = [PSObject]::AsPSObject((New-Object object))
      $instance.PSObject.TypeNames.Insert(0,$key)
      $registry[$key] = $instance
    }
  }
}

We now have an instance which is shared across our PowerShell session thiat is created the first time we instantiate our objects.

To implement Add-StaticProperty, I attach the desired property to the shared instance, and add a proxy ScriptProperty which calls into the registry, finds the instance that maps to our ‘type’ and accesses the property needed. As always, there is a small catch.

The TypeName is only known during the call to Add-StaticProperty and PowerShell doesn’t support closures, so we can’t capture the TypeName at this moment in a ScriptBlock. Instead, the ScriptBlock must be created from a string and the TypeName is captured via string interpolation. At the same time, we cannot let the rest of the proxy ScriptBlocks’ values be interpolated (this leads to some syntactic messiness).

function Add-StaticProperty {
  param(
    [string]$name,
    [object]$value = $null,
    [System.Management.Automation.ScopedItemOptions]$options = [System.Management.Automation.ScopedItemOptions]::None,
    [Attribute[]]$attributes = $null
  )
  process {
    $key = $_.PSObject.TypeNames[0]

    $instance = $Global:__CTS__[$key]
    $instance | Add-Property $name $value $options $attributes

    $getterBlock = [ScriptBlock]::Create('$Global:__CTS__["' + "$key" + '"].' + "$name")
    $setterBlock = [ScriptBlock]::Create('param($value) $Global:__CTS__["' + "$key" + '"].' + "$name" + ' = $value')
    $_ | Add-ScriptProperty $name $getterBlock $setterBlock
  }
}

Enough background, let’s look at an example. Borrowing the example from Part 1, I am making the Message static so that it can be modified and used by separate instances.

function New-SapiVoice {
  $prototype = New-Prototype
  $prototype | Update-TypeName
  $prototype | Add-Function Say {
    param([string]$message)
    $speaker = new-object -com SAPI.SpVoice
    ($speaker.Speak($message, 1)) | out-null
  }
  $prototype | Add-StaticProperty Message "Hello, World!"
  $prototype
}

$voice = New-SapiVoice
$voice.Say($voice.Message) # says: Hello, World!

# Changing the message on $voice changes it on $voice2 as well
$voice.Message = "The dude abides"

$voice2 = New-SapiVoice
$voice2.Say($voice2.Message) # says: The dude abides

Because of the way the shared instances are mapped with the proxy properties, derived objects are able to call static methods on their base implementations.

function New-Foo {
  $prototype = New-Prototype
  $prototype | Update-TypeName
  $prototype | Add-StaticProperty Name "Baz"
  $prototype
}

function New-Bar {
  $prototype = New-Foo
  $prototype | Update-TypeName
  $prototype
}

$foo = New-Foo
$bar = New-Bar

$foo.Name # outputs Baz
$bar.Name # outputs Baz

$foo.Name = "The Dude"

$foo.Name # outputs The Dude
$bar.Name # outputs The Dude

If you want to view the ‘inheritance hierarchy’ of your prototypal object, you can call $value.PSObject.TypeNames and it will give you an ordered collection of types being implemented. You can also do this on any .NET object that you wrap in a PSObject instance.

I hope you enjoyed this trip down the rabbit hole.

Prototypal Inheritance Using PowerShell (Part 3): Mixins

2012-08-26T09:10:00-07:00

If you didn’t read Part 1 and Part 2, I would recommend reading them as I build off of their functionality and theory.

With mixins, each derivation/extension has the chance to replace override previously declared functionality. Since we aren’t dealing with classical inheritance, we can have multiple mixins applied to a single prototypal object.

I have designed the mixins to operate as filters that return nothing; this choice is simply for syntax reasons.

filter Mixin-Math {
  $_ | Add-Property PI ([Math]::PI) Constant
  $_ | Add-Property E ([Math]::E) Constant
  $_ | Add-Function Get-Sqrt {param($value)[Math]::Sqrt($value)}
  $_ | Add-Function Get-Hypotenuse {param($a,$b) $this.Get-Sqrt($a*$a+$b*$b)}
}

filter Mixin-Circular {
  param($radius = 3.0)
  $_ | Mixin-Math
  $_ | Add-Property Radius $radius
  $_ | Add-ScriptProperty Diameter {$this.Radius * 2.0}
  $_ | Add-ScriptProperty Circumference {$this.Diameter * $this.PI}
  $_ | Add-ScriptProperty BaseArea {$this.Radius * $this.Radius * $this.PI}
}

filter Mixin-Cylindrical {
  param($radius = 3.0, $height = 4.0)
  $_ | Mixin-Circular $radius
  $_ | Add-Property Height $height
  $_ | Add-ScriptProperty LateralHeight {$this.Height}
  $_ | Add-ScriptProperty LateralArea {$this.Circumference * $this.LateralHeight}
  $_ | Add-ScriptProperty SurfaceArea {$this.BaseArea + $this.LateralArea}
  # override/replace
  $_ | Add-ScriptProperty BaseArea {2 * $this.Radius * $this.Radius * $this.PI}
}

The mixins describe groups of functionality that we wish to bestow upon other objects effectively apply a bulk monkey patch. Since we only have the single level of delegation, we replace any functions/properties instead of overriding.

To create a new cylinder, we just need to create the prototype and mix in the cylindrical behavior.

function New-Cylinder {
  param($radius = 3.0, $height = 4.0)
  $prototype = new-prototype
  $prototype | Update-TypeName
  $prototype | Mixin-Cylindrical $radius $height
  $prototype
}

$cylinder = New-Cylinder -radius 1 -height 1

# Let's have a look at our new cylinder object:
$cylinder | Get-Member -View Extended

   TypeName: Prototype#Cylinder

Name          MemberType     Definition
----          ----------     ----------
E             NoteProperty   System.Double E=2.71828182845905
Height        NoteProperty   System.Int32 Height=1
PI            NoteProperty   System.Double PI=3.14159265358979
Radius        NoteProperty   System.Int32 Radius=1
Hypotenuse    ScriptMethod   System.Object Hypotenuse();
Sqrt          ScriptMethod   System.Object Sqrt();
BaseArea      ScriptProperty System.Object BaseArea {get=2 * $this.Radius * $this.Radius * $this.PI;}
Circumference ScriptProperty System.Object Circumference {get=$this.Diameter * $this.PI;}
Diameter      ScriptProperty System.Object Diameter {get=$this.Radius * 2.0;}
LateralArea   ScriptProperty System.Object LateralArea {get=$this.Circumference * $this.LateralHeight;}
LateralHeight ScriptProperty System.Object LateralHeight {get=$this.Height;}
SurfaceArea   ScriptProperty System.Object SurfaceArea {get=$this.BaseArea + $this.LateralArea;}

# And its values
$cylinder | fl

PI            : 3.14159265358979
E             : 2.71828182845905
Radius        : 1
Diameter      : 2
Circumference : 6.28318530717959
Height        : 1
LateralHeight : 1
LateralArea   : 6.28318530717959
SurfaceArea   : 12.5663706143592
BaseArea      : 6.28318530717959

We can take an object that has cylindrical properties, but has differently definitions for those properties, and reconstruct them after applying the mixin. In our case, we are going to define a cone.

function New-Cone {
  param($radius = 3.0, $height = 4.0)
  $prototype = new-prototype
  $prototype | Update-TypeName
  $prototype | Mixin-Cylindrical $radius $height
  # override/replace Calculations
  $prototype | Add-ScriptProperty BaseArea {$this.Radius * $this.Radius * $this.PI}
  $prototype | Add-ScriptProperty LateralHeight {$this.Get-Hypotenuse($this.Radius, $this.Height)}
  $prototype | Add-ScriptProperty LateralArea {$this.PI * $this.Radius * $this.LateralHeight}
  $prototype
}


$cone = New-Cone -radius 1 -height 1

# Let's have a look at our new cone object:
$cone | Get-Member -View Extended

   TypeName: Prototype#Cone

Name          MemberType     Definition
----          ----------     ----------
E             NoteProperty   System.Double E=2.71828182845905
Height        NoteProperty   System.Int32 Height=1
PI            NoteProperty   System.Double PI=3.14159265358979
Radius        NoteProperty   System.Int32 Radius=1
Hypotenuse    ScriptMethod   System.Object Hypotenuse();
Sqrt          ScriptMethod   System.Object Sqrt();
Area          ScriptProperty System.Object Area {get=$this.LateralArea + 2.0 * $this.Pi * $this.Radius * $this.Height;}
BaseArea      ScriptProperty System.Object BaseArea {get=$this.Radius * $this.Radius * $this.PI;}
Circumference ScriptProperty System.Object Circumference {get=$this.Diameter * $this.PI;}
Diameter      ScriptProperty System.Object Diameter {get=$this.Radius * 2.0;}
LateralArea   ScriptProperty System.Object LateralArea {get=$this.Circumference * $this.LateralHeight;}
LateralHeight ScriptProperty System.Object LateralHeight {get=$this.Hypotenuse($this.Radius, $this.Height);}
SurfaceArea   ScriptProperty System.Object SurfaceArea {get=$this.BaseArea + $this.LateralArea;}

# And its values
$cone | fl

PI            : 3.14159265358979
E             : 2.71828182845905
Radius        : 1
Diameter      : 2
Circumference : 6.28318530717959
Height        : 1
LateralArea   : 8.88576587631673
SurfaceArea   : 12.0273585299065
Area          : 15.1689511834963
BaseArea      : 3.14159265358979
LateralHeight : 1.4142135623731

Prototypal Inheritance Using PowerShell (Part 2): ScriptProperties

2012-08-25T06:39:00-07:00

If you didn’t read Part 1, I would recommend reading it as I build off of its functionality and theory.

Adding functions and variables to a PowerShell object is very useful, but ScriptProperty objects give us some unique features (and gotchas) as well. We can attach them just as we did with other prototype helpers:

function Add-ScriptProperty {
  param(
    [string]$name,
    [scriptblock]$getter,
    [scriptblock]$setter = $null
  )
  process {
    $property = new-object System.Management.Automation.PSScriptProperty "$name", $getter, $setter
    $_.psobject.properties.remove($name)
    $_.psobject.properties.add($property)
  }
}

This kind of property comes in very handy for creating proxy properties, composite properties, and syntax helpers:

function New-EnvironmentModifier {
  $prototype = New-Prototype
  $prototype | Add-Function SetUserVariable {
                 param([string]$name, [string]$value)
                 [Environment]::SetEnvironmentVariable($name, $value, "User")
               }
  $prototype | Add-Function GetUserVariable {
                 param([string]$name)
                 [Environment]::GetEnvironmentVariable($name,"User")
               }
  $prototype | Add-ScriptProperty BuildNumber {
                                      $this.GetUserVariable("BuildNumber")
                                    } {
                                      param([String]$value)
                                      $this.SetUserVariable("BuildNumber", $value)
                                    }
  $prototype
}

$modifier = New-EnvironmentModifier
$modifier.BuildNumber = 42
$modifier.BuildNumber
42

You MUST remember that ScriptBlocks are not closures and you cannot capture variables with them! You can get into situations in which it appears that your code is working, but it is in fact accessing a variable from your current scope. The easiest mistake to make is using your $prototype variable in a new function or ScriptProperty.

function New-ClosureSample {
  param($target)
  $prototype = New-Object psobject
  $prototype | Add-ScriptProperty Value { $target }
  $prototype
}

$sample = New-ClosureSample 37
# If the variable was captured, we should see 37, but instead we get $null
$sample.Value -eq $null
True
$target = 42
$sample.Value
42

Once $target is defined, the Value block has data to work with. Remember to always use $this to access members of your object within a ScriptProperty. If you need to capture an argument, use a regular property (then optionally refer to it from the ScriptProperty)

function New-ClosureSample {
  param($target)
  $prototype = New-Object psobject
  $prototype | Add-Property Captured $target
  $prototype | Add-ScriptProperty Value { $this.Captured }
  $prototype
}

$sample = New-ClosureSample 37
$sample.Value
37

In a ScriptProperty block you have to use the $this automatic variable. From the about_Automatic_Variables help topic:

In a script block that defines a script property or script method, the $This variable refers to the object that is being extended.

In the case of our prototype, $this refers to the underlying PSObject allowing use to use functions, properties, and variables that we have attached and any others that the object provides.

If you want to read more, Part 3 is now available.

Prototypal Inheritance Using PowerShell

2012-08-24T10:15:00-07:00

PowerShell has no concept of a class, so classical inheritance is not an option; however, PowerShell’s Adaptive Type System (ATS) gives us great power in implementing prototypal objects. Prototype-based programming relies on delegation to execute late bound features of an object. Ruby is famous for its message delegation capabilities. PowerShell, on the other hand, has some shortcomings.

PowerShell, even the new Dynamic Language Runtime (DRL) based v3, does not support true dynamic dispatch and we cannot get into the internals of PSObject’s IDynamicMetaObjectProvider implementation. If we could have true dynamic dispatch and take over delegation, we could mimic JavaScript’s prototypal inheritance with each object having an actual prototype to which we could delegate messages and support overriding (prototypes with prototypes with prototypes with …).

PowerShell, through PSObject, does support a single level of prototypal inheritance. I created an OSS project called Prototye.ps in order to create a domain specific language for creating PowerShell objects using prototypal inheritance. There are a few simple operations we need in order to build a prototypal object factory:

Wrap the prototype and add type metadata
Update type metadata
Add variables to the prototype
Add functions to the prototype
Attach a ScriptProperty to the prototype (In a later post)
Apply Mixins (In a later post)

To create a new prototype object, we want to wrap an existing object in a PSObject so that we can add late bound functionality leveraging ATS. We also want to set up the infrastructure needed to support formatting ps1xml files via the TypeNames property.

function New-Prototype {
  param($baseObject = (new-object object))
  process {
    $prototype = [PSObject]::AsPSObject($baseObject)
    $prototype.PSObject.TypeNames.Insert(0,"Prototype")
    $prototype
  }
}

If a PSObject is passed into New-Prototype, the call to [PSObject]::AsPSObject will return that object rather than rewrap it. This allows use to extend prototypes using the various behaviors and mix them together without unneeded indirection.

Now that we have a handy function to create custom objects, we need the ability to append more type metadata easily when creating custom objects. Once we have these two tasks done, we can start to create our object factories.

function Update-TypeName {
  process {
    $caller = (Get-PSCallStack)[1].Command
    $caller = $caller -replace "new-", [string]::Empty
    $caller = $caller -replace "mixin-", [string]::Empty
    $derivedTypeName = $_.PSObject.TypeNames[0]
    if($derivedTypeName) {
      $derivedTypeName = "$derivedTypeName#{0}" -f $caller
    }
    $_.PSObject.TypeNames.Insert(0,"$derivedTypeName")
  }
}

You will notice that the code is actually in a process {} block. This is so that Update-TypeName will work in the pipeline. Update-TypeName assumes that the functions calling it follow the pattern new-noun or mixin-noun and then appends the calling members ‘type’ to the underlying TypenName. Now that we can create ‘typed’ prototypal object, let’s take a look at a sample.

function New-Sample {
  $prototype = New-Prototype
  $prototype | Update-TypeName
  $prototype # always return the prototype
}

$sample = New-Sample
$sample | get-member

   TypeName: Prototype#Sample
[...]

That’s a start, and we have something extendable, but not that useful yet. Next we need the ability to attach functions and properties/variables to our prototype.

function Add-Property {
  param(
    [string]$name,
    [object]$value = $null,
    [System.Management.Automation.ScopedItemOptions]$options = [System.Management.Automation.ScopedItemOptions]::None,
    [Attribute[]]$attributes = $null
  )
  process {
    $variable = new-object System.Management.Automation.PSVariable $name, $value, $options, $attributes
    $property = new-object System.Management.Automation.PSVariableProperty $variable
    $_.psobject.properties.remove($name)
    $_.psobject.properties.add($property)
  }
}

function Add-Function {
  param(
    [string]$name,
    [scriptblock]$value
  )
  process {
    $method = new-object System.Management.Automation.PSScriptMethod "$name", $value
    $_.psobject.methods.remove($name)
    $_.psobject.methods.add($method)
  }
}

The implementations will detach any existing property/function/variable and attach the new implementation. You can attach private, readonly, and const variables/properties.

A more complex example might be a wrapper around the Microsoft Speech API (SAPI). I am going to define a message, a function to say messages, and update the type metadata so that I have a Prototype#SapiVoice object.

function New-SapiVoice {
  $prototype = New-Prototype
  $prototype | Update-TypeName
  $prototype | Add-Function Say {
    param([string]$message)
    $speaker = new-object -com SAPI.SpVoice
    ($speaker.Speak($message, 1)) | out-null
  }
  $prototype | Add-Property Message "Hello, World!"
  $prototype
}

$voice = New-SapiVoice
$voice.Say($voice.Message) # Says "Hello, World1"
$voice | Get-Member -View Extended # Show what we have added to the base object

   TypeName: Prototype#SapiVoice

Name    MemberType   Definition
----    ----------   ----------
Message NoteProperty System.String Message=Hello, World!
Say     ScriptMethod System.Object Say();

Following this pattern we can mix in modules, support multiple inheritance, and create reusable objects without having to pull in inline C# via Add-Type. This should look a bit like JavaScript ;)

If you want to read more, Part 2 and Part 3 are now available.

Ad-hoc Polymorphism (Function Overloading) in PowerShell

2012-08-23T20:19:00-07:00

Languages like ruby and PowerShell don’t actually support ad-hoc polymorphism.

[…] ad-hoc polymorphism is a kind of polymorphism in which polymorphic functions can be applied to arguments of different types, because a polymorphic function can denote a number of distinct and potentially heterogeneous implementations depending on the type of argument(s) to which it is applied.
Wikipedia Ad-hoc Polymorphism

Ruby relies on message passing instead of method invocation; a message is sent with a set of arguments and the receiver decides how to respond. PowerShell uses functions in a Session keyed on name so that you can only ever have a single function declared in your Runspace with a given name. PowerShell does not have support for creating types directly, but instead favors monkey patching using PowerShell’s Adaptive Type System (ATS) to add variables, properties, methods, and ScriptBlocks to a PSObject instance. The same single name rules apply for these instances (You can add additional behavior to other objects, but internally they are wrapped by a PSObject instance). In both languages, whenever you define a function/message with a name that is already in use, you are replacing that earlier implementation.

It would be nice PowerShell supported ad-hoc polymorphism as we could do this:

function Get-Distance {
  param(
    [Parameter(Position=0,Mandatory=$true)]
    [psobject]$origin,
    [Parameter(Position=1,Mandatory=$true)]
    [psobject]$target,
  )
  return [Math]::Sqrt( [Math]::Pow(($origin.x - $target.x),2) + [Math]::Pow(($origin.y - $target.y),2))
}

function Get-Distance {
  param(
    [Parameter(Position=0,Mandatory=$true)]
    [psobject]$origin,
    [Parameter(Position=1,Mandatory=$true)]
    [int]$x,
    [Parameter(Position=2,Mandatory=$true)]
    [int]$y
  )
  return [Math]::Sqrt( [Math]::Pow(($origin.x - $x),2) + [Math]::Pow(($origin.y - $y),2))
}

To handle this limitation in PowerShell, we can leverage parameter sets to simulate method overloading. Each parameter set can be thought of as an overload (parameters can also be shared across all sets as shown below). There are a number of rules and features to parameter sets which can be found in §17.3.7 of the PowerShell v2 specification that I won’t bore you with today.

Let’s create a function that computes the distance between two points. It takes a source point ($origin) shared between all parameter sets; it also has two sets of mandatory parameters that contains either a second point ($target) or two coordinates ($x,$y values). When the function is called, PowerShell has a built-in object and variable ($PsCmdlet.ParameterSetName) that we can query to figure out which set of parameters were used. Using a switch block on that variable will determine which code needs to be executed.

$point = new-object psobject
$point | Add-Member NoteProperty -Name X -Value 4
$point | Add-Member NoteProperty -Name Y -Value 0

$point2 = new-object psobject
$point2 | Add-Member NoteProperty -Name X -Value 0
$point2 | Add-Member NoteProperty -Name Y -Value 0


function Get-Distance {
  param(
    [Parameter(Position=0,Mandatory=$true)]
    [psobject]$origin,
    [Parameter(Position=1,Mandatory=$true,ParameterSetName="point")]
    [psobject]$target,
    [Parameter(Position=1,Mandatory=$true,ParameterSetName="xy")]
    [int]$x,
    [Parameter(Position=2,Mandatory=$true,ParameterSetName="xy")]
    [int]$y
  )
  switch ($PsCmdlet.ParameterSetName)
  {
    "point" {
      return [Math]::Sqrt( [Math]::Pow(($origin.x - $target.x),2) + [Math]::Pow(($origin.y - $target.y),2))
    }
    "xy" {
      return [Math]::Sqrt( [Math]::Pow(($origin.x - $x),2) + [Math]::Pow(($origin.y - $y),2))
    }
  }
}

Get-Distance $point $point2
Get-Distance $point 0 0

This effectively acts like the two methods in the first example. Though we cannot have ad-hoc polymorphism in PowerShell, parameter sets let us simulate the same functionality and flexibility.

Safe-Dereference / Inverse Null Coalescing Support for C#

2012-08-23T16:59:00-07:00

Groovy has a very handy safe-dereference operator ?. which allows for nested dereferencing without having to worry about a null reference exception.

people << new Person(name:'Ian')
highestZipCode = people.collect{ p -> p.Address?.ZipCode }.max()
println highestZipCode

While we cannot add custom operators to C#, we can use extension methods and expressions to simulate p -> p.Address?.ZipCode. To follow the naming convention in LINQ, I am going to create an extension method on object called ValueOrDefault. Since operators are not an option, expression trees are the primary option. Assuming we have a an object, our goal is to support target.ValueOrDefault( item => item.Foo.Bar().Baz ) evaluating the expression layer by layer until we finish or encounter a default(T) value. To evaluate the expression, we have to parse from the outside in, but evaluate from the inside out, and wrap every subexpression evaluation in the same safe call to ValueOrDefault. The recursion is rather fun:

Start              => ValueOrDefault

ValueOrDefault     => TerminalValue
ValueOrDefault     => EvaluateExpression

EvaluateExpression => ValueOrDefault
EvaluateExpression => EvaluateMember
EvaluateExpression => TerminalValue

EvaluateMember     => EvaluateMember
EvaluateMember     => ValueOrDefault

In order to evaluate target.ValueOrDefault( item => item.Foo.Bar().Baz ) we need to

Determine if target is null, if so, return null
Pass target as the instance and item => item.Foo.Bar().Baz
Pull off the .Baz expression and evaluate item.Foo.Bar() with target as the instance
Pull off the .Bar() and evaluate item.Foo with target as the instance
Pull off the .Foo and evaluate item with target as the instance
There are no more member or method expressions, so target is passed back up the stack
.Foo is evaluated on the target instance. If Foo evaluates to default(T) we cascade back up the recursion tree and stop evaluating. If not, we proceed to #8 passing the value returned by .Foo as the target instance.
.Bar() is executed on the target instance. Same behavior as #7, pass the return value back up the stack
.Baz is evaluated on the target instance returned from .Bar()

Well, that’s enough theory, let’s look at the implementation.

using System;
using System.Linq.Expressions;
using System.Reflection;

public static class ObjectExtensions
{
  public static TValue ValueOrDefault<TSource, TValue>
                         ( this TSource instance,
                           Expression<Func<TSource, TValue>> expression )
  {
    return ValueOrDefault( instance, expression, true );
  }

  private static TValue ValueOrDefault<TSource, TValue>
                          ( this TSource instance,
                            Expression<Func<TSource, TValue>> expression,
                            bool nested )
  {
      return ReferenceEquals( instance, default( TSource ) )
                 ? default( TValue )
                 : nested ? EvaluateExpression( instance, expression )
                          : expression.Compile()( instance );
  }

  internal static TProperty EvaluateExpression<TSource, TProperty>
                              ( TSource source,
                                Expression<Func<TSource, TProperty>> expression )
  {
    var method = expression.Body as MethodCallExpression;
    if ( method != null ) {
      return ValueOrDefault( source, expression, false );
    }

    var body = expression.Body as MemberExpression;
    if ( body == null ) {
      const string format = "Expression '{0}' must refer to a property.";
      string message = string.Format( format, expression );
      throw new ArgumentException( message );
    }

    object value = EvaluateMemberExpression( source, body );
    if ( ReferenceEquals( value, null ) ) {
      return default( TProperty );
    }
    return (TProperty) value;
  }

  private static object EvaluateMemberExpression
                          ( object instance,
                            MemberExpression memberExpression )
  {
    if ( memberExpression == null ) {
      return instance;
    }
    instance = EvaluateMemberExpression( instance, memberExpression.Expression as MemberExpression );
    var propertyInfo = memberExpression.Member as PropertyInfo;
    instance = ValueOrDefault( instance, item => propertyInfo.GetValue( item, null ), false );
    return instance;
  }
}

The key thing to grok is the inside out evaluation. If you want to play around with this code, I have included a number of tests below to make sure that everything is in working order. Having ?. added to the C# language is high on my list of desired vNext features. Hopefully the C# team agrees.

Tests and Example Usage

using Xunit;

public class Person
{
  public string Name { get; set; }
  public Address Address { get; set; }
}

public class Address
{
  public string StreetName { get; set; }
  public ZipCode ZipCode { get; set; }
}

public class ZipCode
{
  public int Body { get; set; }
  public int? Suffix { get; set; }
  public Zone Zone { get; set; }
  public Zone GetZone() { return Zone; }
}

public class Zone
{
  public string Name { get; set; }
}

public class ObjectExtensionTests
{
  [Fact]
  public void when_the_accessed_object_is_null_then_null_is_returned()
  {
    Person person = null;
    string result = person.ValueOrDefault( p => p.Name );
    Assert.Equal( null, result );
  }

  [Fact]
  public void when_the_accessed_property_is_null_then_null_is_returned()
  {
    var person = new Person { Name = null };
    string value = person.ValueOrDefault( p => p.Name );
    Assert.Equal( null, value );
  }

  [Fact]
  public void when_the_accessed_property_is_not_null_then_its_value_is_returned()
  {
    const string name = "Ian";
    var person = new Person { Name = name };
    string value = person.ValueOrDefault( p => p.Name );
    Assert.Equal( name, value );
  }

  [Fact]
  public void when_a_complex_property_is_null_then_null_is_returned()
  {
    var person = new Person { Address = null };
    Address value = person.ValueOrDefault( p => p.Address );
    Assert.Equal( null, value );
  }

  [Fact]
  public void EvaluateExpression_non_nested_properties_are_evaluated()
  {
     const string name = "Ian";
     var person = new Person { Name = name };
     string value = ObjectExtensions.EvaluateExpression( person, p => p.Name );
     Assert.Equal( name, value );
  }

  [Fact]
  public void EvaluateExpression_nested_properties_are_evaluated()
  {
    const string name = "Ian";
    var person = new Person { Address = new Address { StreetName = name } };
    string value = ObjectExtensions.EvaluateExpression( person, p => p.Address.StreetName );
    Assert.Equal( name, value );
  }

  [Fact]
  public void when_a_nested_accessed_property_is_null_then_null_is_returned()
  {
    var person = new Person { Address = null };
    string value = person.ValueOrDefault( p => p.Address.StreetName );
    Assert.Equal( null, value );
  }

  [Fact]
  public void when_a_nested_accessed_property_is_not_null_then_its_value_is_returned()
  {
    const string name = "Ian";
    var person = new Person { Address = new Address { StreetName = name } };
    string value = person.ValueOrDefault( p => p.Address.StreetName );
    Assert.Equal( name, value );
  }

  [Fact]
  public void when_a_double_nested_accessed_propertys_parent_is_null_then_defaultT_is_returned()
  {
    var person = new Person { Address = null };
    int value = person.ValueOrDefault( p => p.Address.ZipCode.Body );
    Assert.Equal( 0, value );
  }

  [Fact]
  public void when_a_double_nested_accessed_propertys_parent_is_null_then_defaultT_is_returned_for_nullable_types()
  {
    var person = new Person { Address = null };
    int? value = person.ValueOrDefault( p => p.Address.ZipCode.Suffix );
    Assert.Equal( null, value );
  }

  [Fact]
  public void when_a_double_nested_accessed_property_is_not_null_then_its_value_is_returned()
  {
    const int body = 99016;
    var person = new Person { Address = new Address { ZipCode = new ZipCode { Body = body } } };
    int value = person.ValueOrDefault( p => p.Address.ZipCode.Body );
    Assert.Equal( body, value );
  }

  [Fact]
  public void when_a_triple_nested_accessed_propertys_parent_is_null_then_null_is_returned()
  {
    var person = new Person { Address = null };
    string value = person.ValueOrDefault( p => p.Address.ZipCode.Zone.Name );
    Assert.Equal( (object) null, value );
  }

  [Fact]
  public void when_a_triple_nested_accessed_property_is_not_null_then_its_value_is_returned()
  {
    const string name = "Yay";
    var person = new Person
                   { Address = new Address { ZipCode = new ZipCode { Zone = new Zone { Name = name } } } };
    string value = person.ValueOrDefault( p => p.Address.ZipCode.Zone.Name );
    Assert.Equal( name, value );
  }
}