One of Neal Ford’s slides captures the idea.

The Strategy Pattern

Formally speaking, the strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

function ql {$args}            
            
function CalcByMult {            
    param($n,$m)             
            
    $n*$m            
}            
            
function CalcByManyAdds {            
    param($n,$m)            
                
    1..$n | % {$result = 0} { $result += $m } {$result}            
}            
            
            
$sampleData = @(            
    ,(3,4,12)            
    ,(5,-5,-25)            
)            
             
$strategies = ql CalcByMult CalcByManyAdds            
             
foreach($Dataset in $sampleData) {            
    foreach($strategy in $strategies) {            
        $Dataset[2] -eq (& $strategy $Dataset[0] $Dataset[1])            
    }            
}

Why Bother with Extra Structure?

Here I am creating an array of PowerShell script blocks for the strategies, eliminating the ceremony of naming them.

$sampleData = @(            
    ,(3,4,12)            
    ,(5,-5,-25)            
)            
             
$strategies =             
{param($n,$m) $n*$m},            
{            
    param($n,$m)            
    1..$n | % {$result = 0} { $result += $m } {$result}            
}            
             
foreach($Dataset in $sampleData) {            
    foreach($strategy in $strategies) {            
        $Dataset[2] -eq (& $strategy $Dataset[0] $Dataset[1])            
    }            
}

This post Fluent Interface for System.Identity – Kind’s Expression Builder got me thinking about the GoF Builder Pattern and how to turn a legacy C# class with a constructor into a Fluent Interface with a Builder and Implicit Operator.

Notice how DwellingBuilder returns a Dwelling. This is easily implemented through C#’s implicit operator. This is the Product defined by the builder pattern.

Using the Fluent Interface

Dwelling Builder

public class DwellingBuilder            
{            
    int Bedrooms { get; set; }            
    int Closets { get; set; }            
    int Floor { get; set; }            
            
    public static implicit operator Dwelling(DwellingBuilder builder)            
    {            
        return new Dwelling(            
          builder.Bedrooms,             
          builder.Closets,             
          builder.Floor            
       );            
    }            
            
    public DwellingBuilder NumberOfBedrooms(int p)            
    {            
        Bedrooms = p;            
        return this;            
    }            
            
    public DwellingBuilder NumberOfClosets(int p)            
    {            
        Closets = p;            
        return this;            
    }            
            
    public DwellingBuilder OnFloor(int p)            
    {            
        Floor = p;            
        return this;            
    }            
}

Legacy Dwelling Class

public class Dwelling            
{            
    public int Bedrooms { get; set; }            
    public int Closets { get; set; }            
    public int Floor { get; set; }            
            
    public Dwelling(int bedrooms, int closets, int floor)            
    {            
        Bedrooms = bedrooms;            
        Closets = closets;            
        Floor = Floor;            
    }            
}

Erich Gamma  is a co-author of  Design Patterns: Elements of Reusable Object-Oriented Software