DEV Community: Gary Woodfine

How to use the Strategy Pattern in C#

Gary Woodfine — Sun, 24 Apr 2022 16:05:05 +0000

The Strategy Pattern is a Behavioral Pattern , software Design Patterns defined by the Gang of Four in Design Patterns: Elements of Reusable Object-Oriented Software , it is also discussed in Head First Design Patterns.

The Strategy pattern enables the definition and encapsulation of a number of algorithms and make them interchangeable. The algorithms may vary independently and may deliver different outcomes and enable different behaviour, however they can all be called using the same method signature.

A typical example of how the Strategy pattern is implemented is illustrated in the diagram below.

In Strategy pattern, a class behaviour or its algorithm can be changed at run time. Enabling the creation of objects which represent various strategies and a context object whose behaviour varies as per its strategy object. The strategy object changes the executing algorithm of the context object.

Another name for the Strategy pattern is *Policy*, which in my opinion provides a better clue on how this pattern can be utilised in software applications. The most common scenario in enterprise software development where the Strategy pattern can be implemented in a Business Rules Engine.

Define a family of algorithms, encapsulate each one and make them interchangeable. Strategy lets the algorithm vary independently from the clients that use it

Design Patterns

A business rules engine (BRE) is an application that manages decision processes using pre-defined logic to determine outcomes. BREs enable precise decision making, and are especially useful for complex dependencies, as well as in instances where regulatory or organisational rule changes frequently require logic changes.

An example of this may be in a Bank loan software application, there are various rules that can be triggered based on responses to questions. If the answer is yes to one question or no to another question, the chances of approval for a loan could be impacted or further subsequent questions may be required to further clarify financial information. These rules help guide users through the application process and help the financial institution determine the eligibility and structure their business.

I recently came across Basic Rules Engine Design Pattern, where in the author just actually describes the typical implementation of the Strategy pattern, as you’ll be able to tell from the class diagram he supplied, the implementation resembles the simplified Strategy Pattern above.

Simplified Implementation

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

In software development a Software Design Pattern is a reusable solution to commonly recurring problems. A software design pattern is a description or template used to solve a problem that can be used in many different situations.

In 1994, the so called Gang Of Four (GOF) published their book Design Patterns: Elements of Reusable Object-Oriented Software in which they presented a catalog of simple and succinct solutions to commonly occurring design problems.

The book captured 23 Patterns that enabled software architects to create flexible, elegant and ultimately reusable design patterns without having to rediscover or reinvent the design solutions for themselves.

Through a series of blog posts on garywoodfine.com I will discuss these patterns and more on how C# .net core developers can implement these patterns in cross platform .net core software solutions.

Software Design Patterns

Software Design patterns are typically…

View on GitHub

In our very simple implementation of the strategy pattern we’ll build a simple console game, in which we’ll invite the user to enter a number in the terminal and based on the value we’ll return different values. Each of the return values will be returned by different strategies.

let’s start by declaring an interface for our strategies, which we’ll define as Rule which will have two methods a Verify and an Execute.

public interface IRule
 {
    bool Verify(string choice);
    void Execute();
 }

Essentially the Verfify method will taken in the input and determine if the strategy can be executed based on the input and provide a response back to calling application to signify whether it is appropriate to execute the strategy.

The Execute will enable the calling application to execute the strategy.

Lets implement a first simple strategy class implementing the interface. We’ll implementing a strategy to ensure the user has provided a valid number as input, We’ll name our class NotANumberRule.cs the code for the class will be as follows.

public class NotANumberRule : IRule
 {
    public bool Verify(string choice)
    {
      return !choice.All(char.IsDigit);
    }
    public void Execute()
    {
      Console.WriteLine("We said enter a number ");
    }
 }

I’ve kept the implementation of our class as simple as possible as not to distract from the detail of the strategy pattern. In the Verify method we iterate through each char in the supplied string to ensure that it is a Numeric digit, if we find any alpha characters then we want t signify that our strategy should be executed because we want to notify the user that they should only enter a number.

We can create any number of Rules classes providing the all implement the Rule interface. In the code sample I have implemented several rules each will trigger on various conditions.

We can now implement our simple Console application, in which we’ll prompt the user to enter to choose a number between 1 and 10.

class Program
 {
    static void Main(string[] args)
    {
      string val;
      Console.Write("Enter a number between 1 & 10 : ");
      val = Console.ReadLine();         
 }

We now need to implement one more bit of code, which will basically retrieve all our Rules that we have defined in our application and determine which rule to execute based on the conditions.

We use a some Reflection to retrieve all types in our application and check to see if they implement the IRule interface, if they do we will instantiate the class and call the Verify method to determine if we should call the Execute method.

I have previously discussed using reflection in C# ,Get All C# Classes Implementing an Interface , the code below is slightly more lightweight implementation.

private static void ProcessInput(string input)
 {
    foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
    {
      if (!typeof(IRule).IsAssignableFrom(type) || !type.IsPublic || type.IsInterface) continue;

      var rule = (IRule)Assembly.GetExecutingAssembly().CreateInstance(type.FullName, false);
      if (rule.Verify(input)) rule.Execute();
    }
 }

With this method now in place we can add it to our Console application.

static void Main(string[] args)
{
   string val;
   Console.Write("Enter a number between 1 & 10 : ");
   val = Console.ReadLine();
   ProcessInput(val);
}

If we attempt to run the application and attempt to enter any string that is not a number then we’ll activate our NotANumber rule.

Let’s extend our application and implement another rule, which specifies if the user enters a number 2, that a random snarky comment is generated.

 public class SnarkyCommentRule : IRule
 {
    public bool Verify(string choice)
    {
      if (!choice.All(char.IsDigit)) return false;
      var answer = Convert.ToInt32(choice);
      return answer == 2;
    }

   public void Execute()
   {
     var index = new Random().Next(responses.Count);
     Console.WriteLine(responses[index]);
   }

   private List<string> responses => new List<string>()
   {
     "To err is human to choose number 2 is plain stupid",
     "Of all the numbers to choose you picked 2. Why?",
     "A bird in the hand is worth 2 in the bush",
     "You picked a couple of ones",
     "Once bitten twice shy",
     "An arch bishop Desmond",
     "A vicar in a two two",
   };
}

if we run our application and enter a two in the terminal we should now see one of our randomly selected responses displayed.

Conclusion

Using the Strategy pattern, a class behaviour or algorithm can be changed at run time. To implement the Strategy pattern, we create objects which represent various strategies and a context object whose behaviour varies as per its strategy object.

The strategy design pattern is not limited to a certain area of application. Instead, Any software that needs to solve pending tasks and problems with variability, behaviour options, and changes is a prime candidate for the design pattern.

The Mediator Pattern

Gary Woodfine — Tue, 18 May 2021 18:32:08 +0000

The Mediator Pattern

The Mediator Pattern one of the Behavioral Patterns defined by the Gang of Four in Design Patterns: Elements of Reusable Object-Oriented Software

Mediator pattern is used to reduce communication complexity between multiple objects or classes. The pattern provides a mediator class which handles all the communications between different classes and supports easy maintenance of the code by loose coupling.

A mediator sits between method callers and receivers creating a configurable layer of abstraction that determines how callers and receivers get wired up.

Benefits of the Mediator Pattern

Increases the reusability of the objects supported by the Mediator by decoupling them from the system.
Simplifies maintenance of the system by centralizing control logic
Simplifies and reduces the variety of messages sent between objects in the system.

The Mediator is most commonly used to co-ordinate related GUI components. However, it is also gaining popularity amongst C# developers when developing web API's and Microservices to enable typical Request & Response messaging.

A drawback of the Mediator pattern is that without a proper design the Mediator object itself can become overly complex.

Fortunately, in C# Jimmy Bogard, of Automapper fame has also developed MediatR - Simple mediator implementation in .NET. MediatR supports request/response, commands, queries, notifications and events, synchronous and async with intelligent dispatching via C# generic variance.

I prefer to use MediatR as my implementation of choice of the Mediator Pattern, because of its ease of use and versatility. I also learned a lot about code by reading the MediatR source code. It is well worth cloning the repository and spending sometime just going through the implementation, it will provide one with a good sense of how to implement the pattern and also an appreciation of some of the finer points of the C# language.

Why use the Mediator pattern

When working with Domain Classes where multiple functions are used to modify state and implement domain rules it usually becomes difficult to debug, extend and review the implementation. Often business rule functions implement multiple sub-rules that are repeatedly required elsewhere in the domain. This may lead to Multiple layers of complex abstraction required to share functionality or multiple strategies from several developers advocating different patterns and practices.

A common challenge in a codebase, is dealing with the constant flux of ever changing domain requirements and business rules.

Typically software services start out as simple CRUD applications, but gradually evolve to become complex as more rules and changes are introduced.

Developers may initially try to solve this problem, by implementing a Manager class to centralise the logic to contain every action possible to modify the state of an entity or to modify the state of another manager class.

Testing often becomes convoluted, messy, complex and usually incomplete. Typically the problems occur when in order to test the class there are a number of dependencies to mock and configure. Just to test a new function.

Typically no validation of the inbound request is implemented, and the request is allowed to pass through the middle layer, API layer and only validated within the Manager class functions. This often causes bloated action functions with complicated validation rules before the implementation logic!

How does the Mediator pattern solve issues

The mediator pattern promotes loose coupling, by implementing a mediator object to enable objects to communicate with it rather than each other.

Example of the mediator pattern using MediatR

In Developing Api’s using Http Endpoints I discussed some of the problems relating to using MVC pattern to developing Web API projects and how to overcome by making use of the Adralis API Endpoints and I even created a API Template project to help you get started.

In this very simplified example we are going to make use of the template to create a basic project structure to illustrate how to use the Mediator Pattern, and we will also be making use of MediatR, primarily because the template project comes pre-configured to use it.

Once you have installed the template we can create a new project using

dotnet new apiproject -n mediator

Once the project has been generated, we will have have all that is required done for us to provide the most simplistic example of the Mediator pattern.

The Sample project is also generated using what is known as Vertical Slice Architecture or Feature Slices which are Structural Pattern and methodology that aims for logic separation for components and library code

It is important that the basis of the Mediator pattern, is Request & Response mediation or what is more commonly known as the CQRS (Command Query Responsibility Segregation) .

Mediator promotes loose coupling by keeping objects from referring to each other explicitly and it lets you vary their interaction independently

Design Patterns: Elements of Reusable Object-Oriented Software

In order to speed things up even more, I am also going to use a few other products I have developed to quickly build out the other infrastructure details. Hence, I will be making use of the ThreeNine.Data - Generic Repository which I discussed in more detail in Using the Repository and Unit Of Work Pattern in .net core and also the Code First Database library Nuget package from our Headless CMS we are currently in the process of developing.

I will not discuss the whole process of setting up the project to use these libraries because the source code is for this example is available. For the purpose of this article we will only discuss the Mediator pattern implementation.

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Through a series of blog posts on garywoodfine.com I will discuss these patterns and more on how C# .net core developers can implement these patterns in cross platform .net core software solutions.

Software Design Patterns

Software Design patterns are typically…

View on GitHub

We will implement functionality to Create a new Salutation, which is essentially a polite expression of greeting, which covers things like Mr., Mrs. , Prof. etc. Our simplistic API endpoint is simply going to enable adding new items to the list.

In our application configuration in the Startup.cs we will first enable MediatR to essentially scan our assembly and automatically wire up all Mediator Handlers it finds ready to be used. We'll do this by simply adding the services.AddMediatR(typeof(Startup)); in our ConfigureServices method.

 public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo {Title = "mediator", Version = "v1"});
                c.EnableAnnotations();
            });
            services.AddAutoMapper(typeof(Startup));
            services.AddMediatR(typeof(Startup));
            services.AddDbContext<BoleynContext>(options =>
                options.UseNpgsql(Configuration.GetConnectionString("mediator"))
            ).AddUnitOfWork<BoleynContext>();
        }

We'll create a new Api Endpoint as Post , the most important details are that we simply dependency inject IMediator object into our class, which has been made possible because of the step we carried out earlier of instructing MediatR to scan our assembly and wire up all the handlers.

You notice that we have configured our endpoint to Accept a request, which will contain a command, and that our endpoint will not provide a Response. Although it is still important to remember our Endpoint will still provide an ActionResult response, but in this instance it means that endpoint will not be providing an Object response.

 [Route(RouteNames.Salutations)]
    public class Post : BaseAsyncEndpoint.WithRequest<CreateSalutationCommand>.WithoutResponse
    {
        private readonly IMediator _mediator;

        public Post(IMediator mediator)
        {
            _mediator = mediator;
        }

        [HttpPost]
        [SwaggerOperation(
            Summary = "Create a new salutation",
            Description = "",
            OperationId = "AA440D51-75A5-4975-8875-C1799B58D4EB",
            Tags = new []{RouteNames.Salutations}
            )]
        [ProducesResponseType(StatusCodes.Status201Created)]
        public override async Task<ActionResult> HandleAsync([FromBody] CreateSalutationCommand request, CancellationToken cancellationToken = new())
        {
            var result = await _mediator.Send(request, cancellationToken);
            return new CreatedResult( new Uri(RouteNames.Salutations, UriKind.Relative), new { id = result });
        }
    }

Our endpoint handler accepts a CreateSalutationCommand object, which in theory is an implementation of CQRS, We need to create our CreateSalutationCommand object as follows.

    public class CreateSalutationCommand : IRequest<int>
    {
        public string Abbreviation { get; set; }
        public string FullWord  { get; set; }
    }

You will notice our Command inherits from the IRequest essentially stipulate the Type that our object will request. This type can either a Primitive or Complex type, however in this case we are simply requesting an Integer return value containing the ID of the created object.

We can now configure out Handler object, you will notice that we create a class which inherits from the IRequestHandler interface and accepts the CreateSalutationCommand and provides an int response type.

We can inject whatever dependencies we may need into this class, in our case it will be the Mapper and Unit Of Work from our generic repository.

  public class PostHandler : IRequestHandler<CreateSalutationCommand, int>
    {
        private readonly IUnitOfWork _unitOfWork;
        private readonly IMapper _mapper;

        public PostHandler(IUnitOfWork unitOfWork, IMapper mapper)
        {
            _unitOfWork = unitOfWork;
            _mapper = mapper;
        }

        public async Task<int> Handle(CreateSalutationCommand request, CancellationToken cancellationToken)
        {
            var salutation = _mapper.Map<Salutation>(request);
            var repo = _unitOfWork.GetRepositoryAsync<Salutation>();
            await repo.InsertAsync(salutation, cancellationToken);
            await _unitOfWork.CommitAsync();
            return salutation.Id;
        }
    }
}

In this very simple example, you'll notice that we have placed our business logic all with Handle method, which I would be the first to admit is not great, but it also serves to illustrate that we have separated it from our Endpoint logic.

In later, articles based on MediatR, I will provide further examples of how this can further be improved enabling you to take further advantage of MediatR, but for now I just want to illustrate the Mediator Pattern at work.

The take away from this example, is that you will notice that at no point do we explicitly define a reference to our Handler anywhere, in our Post endpoint, we simply make use of the Send function available on the IMediator to send our request to whichever object has been defined to satisfy the Request and Response pairing. The Mediator, then ensures it sends it to which ever it has been configured too.

Conclusion

The most simplest definition of the Mediator pattern is that it is an object that encapsulates how objects interact. So it can obviously handle passing Request and Response between objects.

The Mediator pattern promotes loose coupling by not having objects refer to each other, but instead refer to the mediator. So they pass the messages to the mediator, who will pass it on to the object that has been defined to handle them.

The CQRS pattern defined actually just an “implementation” of the mediator pattern. As long as we are promoting loose coupling through a “mediator” class that can pass data back and forth so that the caller doesn’t need to know how things are being handled, then we can say we are implementing the Mediator Pattern.

The Adapter Pattern

Gary Woodfine — Tue, 04 May 2021 08:00:21 +0000

The Adapter Pattern is the first software design pattern of the Structural Pattern, that the Gang of Four (GOF) Design Patterns, presented in their book , Design Patterns – Elements of Reusable Object-Oriented Software.

The Adapter pattern is a structural design pattern that enables incompatible interfaces, from disparate systems to exchange data and work together. It is extremely useful when integrating tool-kits, libraries and other utilities together.

Apple Macbook users will be very familiar adaptors, which they will frequently use to plug various devices and network connections.

USB C Hub Multiport Adapter, 13-in-1 MacBook Pro USB Type C Adapter Hub with Ethernet, VGA, 4K HDMI, 3 USB 2.0, 2 USB 3.0, 3-Slot Card Reader, 3.5mm Audio and Power Delivery

This is essentially a physical implementation of the Adapter pattern. Head First Design Patterns provides a really good succinct definition of the Adapter Pattern.

he Adapter pattern allows you to provide an object instance to a client that has a dependency on an interface that your instance does not implement. An Adapter class is created that fulfils the expected interface of the client but that implements the methods of the interface by delegating to different methods of another object.

Adaptive Code – Agile coding with design patterns and SOLID principles

Adaptive Code

Agile coding with design patterns and SOLID principles

Two types of Adapters

There are typically two kinds of adapter pattern implementations

Object Adapters
_ Class _ Adapters

Class adapters

Typically you may only really encounter this type of pattern when using C or C++ or other languages that enable multiple inheritance.

Object adapters

It basically the only adapter pattern C# developers have available and is the type that is discussed in this post.

The Adapter Pattern

Converts the interface of a class into another interface this client expects.

Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.

The object Adapter pattern uses composition to delegate from the methods of the interface to those of a contained encapsulated class. This is a more common implementation of the Adapter pattern.

The main advantage of this pattern is that it enables the use of another library in an application that has an incompatible interface by using an adapter that does the conversion.

Head First Design Patterns

Building Extensible and Maintainable Object-Oriented Software

When to use the Adapter Pattern?

There are a number of situations when making use of the Adapter pattern can be a great solution

A class needs to be reused that does not have an interface that a client requires.
Allow a system to use classes of another system that is incompatible with it.
Allow communication between a new and already existing system that is independent of each other.
Sometimes a toolkit or class library cannot be used because its interface is incompatible with the interface required by an application.

Simple Adapter pattern implementation

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Through a series of blog posts on garywoodfine.com I will discuss these patterns and more on how C# .net core developers can implement these patterns in cross platform .net core software solutions.

Software Design Patterns

Software Design patterns are typically…

View on GitHub

In its most simple form the Adapter Pattern can just be a simple _ wrapper _ class which implements an interface. However the implementation within the class my implement a different set of classes to deliver the functionality required.

You may have an interface for Transport class that defines a Commute method.

public interface ITransport
{
   void Commute();
}

csharp

However, the only class you have a available is Bicycle class that has a Pedal method which will work for what you need.

public class Bicycle
{
   public void Pedal()
   {
       Console.WriteLine("Pedaling");
   }
}

The snag is that the method or class that is going to use it, can only use classes that implement the ITransport interface.

We can use the Adapter pattern here to create a class that implements the ITransport interface, but it actually just wraps the Bicycle class.

public class Transport : ITransport
{
   private Bicycle _bike => new Bicycle();
   public void Commute()
   {
     _bike.Pedal();
   }
 }

You can now implement the Transport class in your application, because it implements the ITransport interface.

 class Program
 {
    static void Main(string[] args)
    {
       var transport = new Transport();
       transport.Commute();
    }
 }

That is all there is to the Adapter pattern. Even in this most simplistic of implementations you can see the power of enabling classes that my seem incompatible with your application , yet you can still make use of them.

The adapter pattern only needs to do as much as it needs to do in order to adapt a class to work. If the Target and Adaptee are similar then the adapter has just to delegate the requests from the Target to the Adaptee. If Target and Adaptee are not similar, then the adapter might have to convert the data structures between those and to implement the operations required by the Target but not implemented by the Adaptee.

Conclusion

The Adapter Pattern is a very simple pattern, but can be quite powerful and extremely useful, and is really a worthwhile pattern to be aware of. Many developers, will most likely have used the Adapter pattern, without actually being explicitly aware of it.

The are more advanced implementation details of the Adapter pattern, but the fundamentals of the pattern remain the same.

Singleton Design Pattern C# .net core

Gary Woodfine — Tue, 05 Nov 2019 10:49:30 +0000

The Singleton pattern is grouped by the Gang Of Four in Design Patterns: Elements of Reusable Object-Oriented Software as a Creational Pattern, although to some extent it is a pattern that limits, rather than promotes, the creation of classes.

The primary objective of the Singleton Pattern, is to ensure that there is one and only one instance of a class and provides a global access point to it.

There are a number of instances in software development where one will need to ensure that there is only one instance of a class. One such example, which may be typical for enterprise software developers is to ensure there is a single point of access to a database engine.

The Singleton Pattern creates a single class responsible to create an object ensuring that only a single object gets created. This class provides a way to access its only object which can be accessed directly without the need to instantiate the object of the class.

The singleton pattern is a design pattern that restricts the instantiation of a class to one object.

The Singleton Pattern does not allow any parameters to be specified when creating the instance - as otherwise a second request for an instance but with a different parameter could be problematic!

If the same instance should be accessed for all requests with the same parameter, the Abstract factory pattern is more appropriate.

Creational Design Patterns

Implementing the Singleton Pattern

There are a number of different ways of implementing the Singleton Pattern in C#, each suited to different situations and requirements, which include Simple, Thread Safe, Lazy Loading and High Performance.

Common Characteristics of Singleton Pattern Implementations.

Single Constructor - Private and Parameter-less.
Sealed Class i.e. Cannot be inherited
Static variable references the single created instance
Public static access to the single created instance

Singleton Pattern Implementation

In our fictional implementation of the Singleton Pattern we will be using it to create Print Spooler class.

The print spooler is a software service that manages the printing process. The spooler accepts print jobs from the computer and makes sure that printer resources are available. It also schedules the order in which jobs are sent to the print queue for printing.

In the early days of personal computers, you had to wait until a document printed before you could do anything else. Thanks to modern print spoolers, the printing process has minimal impact on user productivity.

Processes and Threads

In order to understand the singleton pattern, it is important to understand the context in which it will operate. In the .Net Framework, an application will be composed of lightweight, managed sub-processes called application domains that can comprise one or more managed threads.

For the purpose of understanding the singleton pattern, let's define this as a multi-threaded application that contains one or more threads running simultaneously.

Technically, the threads are actually not running simultaneously, but this is achieved by dividing the available processor time between the threads, so that each thread will execute for a small amount of time and then the thread will suspend activity, allowing for another thread to execute.

singleton pattern, in a multi-threaded application, special care needs to be taken to ensure that access to the singleton is limited so that only one thread enters specific areas of logic at a time. Because of this synchronization of threads, it is possible for one thread to retrieve a value and update it, and, before it can be stored, another thread also updates the value.

To avoid data being updated incorrectly, restriction is required to prevent more than one thread from executing the same block of logic at the same time. There are several mechanisms supported in the .Net Framework and, in the singleton pattern.

We'll examine several Singleton Implementation patterns

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Through a series of blog posts on garywoodfine.com I will discuss these patterns and more on how C# .net core developers can implement these patterns in cross platform .net core software solutions.

Software Design Patterns

Software Design patterns are typically…

View on GitHub

Simple Singleton Pattern

The simplest implementation of the Singleton Pattern is not thread safe, which may result in two different threads evaluate the instance value to null and actually create two instances of the object thus completely violating the core concept of the Singleton Pattern.


  // This is not recommended implementation of the Singleton Pattern
  // Just an example of the simplest implementation
  public sealed class Spooler
   {
       private static Spooler instance = null;

       private Spooler()
       {

       }

       public static Spooler Instance => instance ??= new Spooler();
   }

In the above example, it is possible for the instance to be created before the expression is evaluated, but the memory model doesn't guarantee that the new value of instance will be seen by other threads unless suitable memory barriers have been passed.

In the line public static Spooler Instance => instance ??= new Spooler(); We simply make use of the null-coalescing operator to check if our instance has been instantiated and if not create it or return the existing instantiated object.

In a simple single thread application model the example will work, but this is not an optimal implementation.

In the following, example we'll create an abstract class which our Singleton class will extend, to basically add some features we can reuse throughout our further examples.

We'll add a Spool class which just preforms a very rudimentary implementation of a print queue which will serve for a demo purposes.

  public abstract class Spool
  {
    public List<PrintQueueItem> Queue { get; } = new List<PrintQueueItem>();
  }

We will then simply inherit this class in our Singleton class

 public sealed class Spooler : Spool
   {
       private static Spooler instance = null;

       private Spooler()
       {

       }

       public static Spooler Instance => instance ??= new Spooler();

   }

We'll also create a really simple console application to illustrate how we would implement and use this Singleton Pattern Implementation.

    class Program
            {
                static void Main(string[] args)
                {
                    if (args == null) throw new ArgumentNullException(nameof(args));

                    for (int i = 0; i < 12; i++)
                    {
                        Spooler.Instance.Queue.Add(new PrintQueueItem{ DocumentName = $"test-document-{i}"});
                    }


                    foreach (var queueItem in Spooler.Instance.Queue)
                    {
                        Console.WriteLine(queueItem.DocumentName);
                    }
                }
            }

If we run a simple application we'll see that our application works as expected and there is only one instance of Spooler class and we can add values to it no problem. Interesting point to note here, is that because our Singleton class returns a reference to itself in the instance, we can then just use it in Fluent style i.e. we don't need to create a variable to reference to it.

The problem comes in when we try to use this class in a Multi-Threaded environment. Which I will try to simulate by creating a load of tasks which start a new thread and attempts to add a document to our Queue

Simple Thread Safe Singleton Implementation

We could improve the above implementation by making use of a lock on the shared object to check if the instance has been created before creating a new one.

Locking ensures that all reads occur logically after the lock is acquired while unlocking ensures all writes occur logically before the lock release. This ensures only one thread can create an instance

This pattern may address the memory barrier issues, faced with the Simple Implementation, but unfortunately has a performance impact because a lock is acquired every time the instance is requested.

     public sealed class Spooler : Spool
         {
            private static Spooler instance;
            private static readonly object threadlock = new object();


            public static Spooler Instance
            {
                get
                {
                    lock (threadlock)
                    {
                        return instance ??= new Spooler();
                    }
                }
            }
        }

Double check Lock Singleton Pattern

We could attempt the issues above by implementing a Double check Lock pattern.

This pattern is not recommended and has a number of issues.

 public sealed class Spooler : Spool
    {

            private static Spooler instance;
            private static readonly object padlock = new object();

            public static Spooler Instance
            {
                get
                {
                    if (instance == null)
                    {
                        lock (padlock)
                        {
                            if (instance == null)
                            {
                                instance = new Spooler();
                            }
                        }
                    }
                    return instance;
                }
            }
        }

This pattern with the help pf C# 6.0 + can be further updated by introducing the volatile keyword

The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. The compiler, the runtime system, and even hardware may rearrange reads and writes to memory locations for performance reasons. Fields that are declared volatile are not subject to these optimizations. Adding the volatile modifier ensures that all threads will observe volatile writes performed by any other thread in the order in which they were performed. There is no guarantee of a single total ordering of volatile writes as seen from all threads of execution.

Volatile (C# Reference )

   public sealed class Spooler : Spool
    {

        private static volatile Spooler instance;
        private static readonly object threadLock = new object();

        public static Spooler Instance
        {
            get
            {
                if (instance != null) return instance;

                lock (threadLock)
                {
                    if (instance == null)
                    {
                        instance = new Spooler();
                    }
                }

                return instance;
            }
        }
    }

Almost Lazy Singleton Pattern

static constructors in C# execute only when an instance of the class is created or a static member is referenced, and to execute only once per AppDomain. The check for the type being newly constructed needs to be executed whatever else happens, it will be faster than adding extra checking as in the previous examples.

This approach is still not ideal and actually has some issues because if you have static members other than Instance, the first reference to those members will involve creating the instance. There are also additional complications in that if one static constructor invokes another which invokes the first again. The laziness of type initializers are only guaranteed by .NET when the type isn't marked with a special flag called beforefieldinit.

This pattern also incurs a performance hit.

 public sealed class Spooler : Spool
    {
        private static readonly Spooler instance = new Spooler();

        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static Spooler()
        {
        }

        private Spooler()
        {
        }

        public static Spooler Instance => instance;
    }

Full Lazy Implementation

In this pattern instantiation is triggered by the first reference to the static member of the nested class, which only occurs in Instance.

   public sealed class Spooler : Spool
    {

        private Spooler()
        {
        }

        public static Spooler Instance { get { return Nested.instance; } }

        private class Nested
        {
            // Explicit static constructor to tell C# compiler
            // not to mark type as beforefieldinit
            static Nested()
            {
            }

            internal static readonly Spooler instance = new Spooler();
        }

    }

Generic Lazy Implementation

The .net framework has some really cool features that and System.Lazy<T> is one of those features to help provide lazy initialization with access from multiple threads.

The code below implicitly uses LazyThreadSafetyMode.ExecutionAndPublication as the thread safety mode for the Lazy<Spooler>.

simpler way to achieve laziness, using .NET 4 +, in my opinion tt also has the advantage that it's obviously lazy and it is clearly and implicitly stated in the code.

 public sealed class Spooler : Spool
 {
    private static readonly Lazy<Spooler>
            lazy =
                new Lazy<Spooler>
                    (() => new Spooler());

    public static Spooler Instance { get { return lazy.Value; } }

    private Spooler(){}

  }

Example Scenarios for Singleton Classes

Singleton classes are typically used in applications to create utility classes. A utility classes typically have the following characteristics

Have no state of its own
All the methods can be class methods (static) rather than object methods
Provide methods for multiple other classes i.e. Common or shared code

Other common usages for Singleton classes could be:

Service Proxies: invoking a service or API is an expensive operation. Creating Service proxy as a Singleton this overhead can be reduced.
Facades: Database connections are another example where Singleton can be used to improve performance and synchronisation. Logging: I/O is resource consuming operation, having a single instance of a Logger, data can be persisted to log files.
Data sharing: Configuration values and constant values can be kept in Singleton to read by other components of the application.
Caching: Data fetching is a time consuming process whereas caching required data in the application memory avoids DB calls and Singleton can be used to handle the caching with thread synchronisation.

The Singleton Pattern should only be used when necessary as it can introduce a potential bottleneck for the application. Sometimes, the pattern may be viewed as an anti-pattern because it could introduce Global State.

Global state, unknown dependencies within an application are introduced and it then becomes unclear as to how many types might depend on the information. Additionally, many frameworks and repositories already limit access when required, so introducing an additional mechanism might limit the performance unnecessarily.

The Prototype Design Pattern C# .net core

Gary Woodfine — Mon, 28 Oct 2019 15:34:57 +0000

The Prototype Design Pattern is one of the Creational Design Patterns defined by the Gang Of Four (GOF) published their book Design Patterns: Elements of Reusable Object-Oriented Software in which they presented a catalog of simple and succinct solutions to commonly occurring design problems.

The Prototype pattern is specifically used when creating a duplicate object of an existing object while attempting to conserve resources and focus on performance.

Creational Design Patterns

Real World Implementation of the Prototype Pattern

Consider a real-world example of a Software Developer. In order to create or instantiate a new instance of Software Developer, we would in the first instance create a new Human Object, Nurture and Parent the Human object while educating it. Ensuring that the Human Object gets all the right attributes and elements which eventually lead to it becoming a Software Developer.

Creating a Software Developer object, is a very resource intensive and time consuming process. What happens you need another 10 of these objects ? Wouldn't it be great if we could just clone our existing copy of the software developer, which already has all the attributes and properties we need instantly?

This is the type pf scenario that Prototype Pattern serves to address. The pattern provides a prototype interface which enables creating a clone of the current object. This pattern is used when creation of object directly is costly. For example, an object is to be created after a costly database operation. We can cache the object, returns its clone on next request and update the database as and when needed thus reducing database calls.

Prototype Pattern Implementation

A typical implementation of the Prototype pattern could modelled as follows

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Through a series of blog posts on garywoodfine.com I will discuss these patterns and more on how C# .net core developers can implement these patterns in cross platform .net core software solutions.

Software Design Patterns

Software Design patterns are typically…

View on GitHub

A class may implement an ICloneable Interface which requires the class to implement a Clone method.

The .net framework provides developers with the ICloneable Interface

The ICloneable interface enables you to provide a customized implementation that creates a copy of an existing object. The ICloneable interface contains one member, the Clone method, which is intended to provide cloning support beyond that supplied by Object.MemberwiseClone.

The ICloneable interface simply requires that your implementation of the Clone() method return a copy of the current object instance.

The developer is free to choose any implementation to perform the clone operation i.e. Deep, Shallow or Custom copy of the object.

Practical Implementation of Prototype Pattern

In the first simple implementation of the Prototype Pattern, we'll create a Developer class that implements ICloneable interface which preforms a MemberwiseClone operation.

The MemberwiseClone method creates a shallow copy by creating a new object, and then copying the nonstatic fields of the current object to the new object.


public class Developer : ICloneable
    {
        public string FirstName { get; set; }
        public string Lastname { get; set; }
         public List<string> Skills { get; set; }

        public object Clone()
        {
            return this.MemberwiseClone();
        }
    }

We can now implement our basic client App to instantiate an initial Developer object then we will create a Second version of the object making use of the Clone method that is available. We will then just inspect the cloned developer to check the FirstName it has been defined.

 class Program
    {
        static void Main(string[] args)
        {

            var dev = new Developer
            {
                FirstName = "Gary",
                Lastname = "Woodfine",
                 Skills = new List<string>{"C#", "PHP", "SQL", "JavaScript"}
            };


            var dev2 = dev.Clone() as Developer; 

            Console.WriteLine($"The Cloned  Developer name is { dev2.FirstName }  { dev2.Lastname }");

            Console.WriteLine("The second developer has the following skills: ");


            foreach (var skill in dev2.Skills)
            {
                Console.WriteLine(skill);
            }
        }
    }

If you run the application you'll notice that the Second instance of the Developer has all the same properties of the first one instantiated.

Applications for the Prototype Pattern

The Prototype Pattern is useful when you need to be able to quickly create new instances of objects based on other objects.

The following are typical application scenarios where you may want to consider using the Prototype pattern in C#

You want to instantiate classes at run time, for example, by dynamic loading.
Avoid building a class hierarchy of factories that parallels the class hierarchy of products.
When new instantiations of class can have one of only a few different combinations of state.
New object are going to be clones of existing object.
Avoid subclasses of an object creator in the client application i.e. Abstract Factory Pattern.
Avoid resource intensive object instantiation and initialisation logic.

Advantages of the Prototype Design Pattern

Reduce the time complexity to creating resource consuming objects by using the prototype pattern.
Reduces the sub-classing.
Enables adding and removing objects at run time.
Enables configuring application classes dynamically.

The Prototype Pattern is another tool you can use when you can specify the general class needed in program but need to defer the exact class until execution time. It is similar to the Builder Pattern in that some class or method decides what components or details make up the final instantiated class. However, it differs in that the target classes are constructed by cloning one or more classes and then changing or filling in the details of the cloned class to behave as desired.

Prototypes can be used whenever you need classes that differ only in the type of processing they offer.

Any change you make in one clone of the object is immediately reflected in the other because in fact there is only one object.

To see this behaviour lets add some additional logic to our code, to add an additional skill to our Second Developer instance. After that lets print out our skills of our initial instance to the console.

 class Program
    {
        static void Main(string[] args)
        {

            var dev = new Developer
            {
                FirstName = "Gary",
                Lastname = "Woodfine",
                Skills = new List<string>{"C#", "PHP", "SQL", "JavaScript"}
            };


            var dev2 = dev.Clone() as Developer; 

            Console.WriteLine($"The Cloned  Developer name is { dev2.FirstName }  { dev2.Lastname }");

            Console.WriteLine("The second developer has the following skills: ");


            foreach (var skill in dev2.Skills)
            {
                Console.WriteLine(skill);
            }

            // Add a new Skill to our Cloned Instance
            dev2.Skills.Add( "VueJs");

            Console.WriteLine(" ");


            Console.WriteLine("Our Initial Developer object now has VueJS added too");
            foreach (var skill in dev.Skills)
            {
                 Console.WriteLine(skill);
            }

        }

If we run our sample we'll see that the Vue.JS has been added to our Developer instance skill set.

The Cloned  Developer name is Gary  Woodfine
The second developer has the following skills: 
C#
PHP
SQL
JavaScript

Our Initial Developer object now has VueJS added too
C#
PHP
SQL
JavaScript
VueJs

Summary

The prototype pattern copies or clones an existing class, rather than creating a new instance, when creating new instances is more expensive.

The importance of side projects

Gary Woodfine — Fri, 18 Oct 2019 09:17:17 +0000

In my opinion every developer should have at least one side project. They are by far the most useful and constructive learning and development tool out there.

Your side project doesn’t have to be an enormous global success, but it can guarantee career success!

What is a Side Project ?

A side project is something you do aside from your main job. They are projects you create for yourself to pursuit in order to learn something new or completely outside of your day to day activities or even comfort zone.

Side projects are often regarded as a means for developers to scratch an entrepreneurial itch, or just done by people who seek to create new or alternative ways to make money or a living. Of course, that might be the target of a side project, but you don’t need to think about working on a side project only in terms of starting another company.

Having a personal side project, apart from your usual work, has many other benefits :

Fun – Side projects allow you to invest your time doing something you enjoy.
Facilitate learning and personal development. Side projects allow you to experience and learn new things. They help you learn new techniques or, through deliberate practice, build and improve your current skills.
Encourage creativity. Side projects enable you to work without constraints. There are no deadlines or specifications imposed by anyone except you. You decide your schedule, your pace of work, your priorities.
Huge source of training and self-development. You can read many books on any particular subject, but there is nothing like taking action to gain self-confidence and grow.
Benefit your career. You will have more chances of getting a job if you can show a variety personal projects that are real, interesting, and meaningful, rather than a simple CV or résume.

How I use side projects

In reflection I have used side projects for most of my working life to learn new things. Even my blog and this newsletter are side projects really! I am using them to learn more about Digital Marketing, which is a field that is only really partly connected with what I actually do for a living. It is also play a vital role in the success of any business. Yet all to often, I come across developers who know very little about it.

When I originally started my blog, it was a side project and something I was only going to use to learn about Digital marketing.

In my post Why I blog and why you should too, I discussed some of the aspects that drove me to explore blogging in general. I have learned so much and continue to learn more just from the simple act of blogging. Over the years I have gained and continue to gain a whole multitude of new skills that have come in really useful!

For instance, I am now know a whole lot more about SEO and even WordPress. Which has actually helped me in gaining new customers because people no longer see me as just a developer, they now recognise additional value I can provide to their businesses.

WordPress, is a technology I would often hear about but never get the opportunity to play with in my average software development jobs. I have always been a primarily back-end focused .net developer. So even PHP and even Linux based hosting was never something I came across much.

So when I initially had the idea, of starting my blog, naturally I thought I would use one of the many .net based solutions that were available. However, I remember thinking at the time maybe it would be fun to learn something different.

The initial challenge was enormous because I soon found out that there was so much I didn’t know. However, after a few months and continual learning I was soon able to start getting to grips with WordPress and in 2012 I wrote one of my first blog posts, Add custom fields to MVC4 simple membership , on the first incarnation of this blog.

I read that article now, and cringe with embarrassment, but I also realize how far I have come! I notice the difference in my writing style. my grammar has improved considerably.

One of the biggest benefits I have experienced in writing blogs posts about code, is that my code has significantly improved over all. It’s only when you take a step back from your code and have to take time and effort to explain the code to someone else, particularly if you are going to write a blog post about it, that you really try to ensure your code is self explanatory, to ensure anyone who reads it can understand it. Particularly if you are going to host the code on Github for everyone to see.

in order to teach you must first learn

John Sonmez – Soft Skills

The path to continual learning and improvement

When I first started on my path to blogging I really didn’t know what I was doing and I made so many mistakes, so much so that I actually had to delete my WordPress website several times and start over. However, each time I was learning something new, and more importantly I learned what not to do.

I wasn’t focused on making my blog a success,but just focused on learning what makes things a success. Each failure, was a lesson and an opportunity to explore something I had never encountered or considered before.

Over the years I have become really familiar with WordPress and now count it was one of my skills. I even developed a WordPress Plugin that helped combat Referrer spam plague in 2015. I implemented something that I had learned and it helped a lot of people at the time.

It was actually because of my plugin I was able to land a particularly lucrative contract with large company, with virtually no interview process!

Lately, my focus has been on Digital Marketing and exploring all aspects related to it. One of the primary reasons why, is that I have learned over several failed attempts at launching new Software Products, that key ingredient to their success literally has nothing to do with how well they are a coded or even if they solve a particular problem, the key to success is the marketing and making people aware of your product!

I have previously discussed, Why is it so hard to make money from software, and it is something I have increasingly grown to appreciate. The more side projects you undertake, the more you’ll realize that developing a successful software product takes more than just writing code!

So in fine tradition, I have decided to launch another side project, in the hope of learning and cracking the secrets to effective Digital Marketing well at the same time come up with a solution to help software developers and companies to better connect, in order to solve the problems software developers and companies face with recruitment.

I have long had an issue with the software developer recruitment process and I for one really hate the Technical Interviews, which I have also discussed in, How not to do technical interviews .

My latest side project

I have recently embarked on the creation of another side project, which may be a potential solution to the software developer recruitment problem, but it requires the development of a Website, Web & Mobile application and a whole raft of tools. Its a massive project, but it is fun.

The project, is what I have called Sourcelink – Software Developers Community, and its aim is to potentially revolutionise the way recruitment is currently handled in the software development sector.

Currently, I am currently the only the person on the project and doing everything and it is a huge undertaking and a lot to learn. However, it is fun and there are a lot value I personally can gain from this.

The project itself has already spawned a number of tutorial blog posts, as I am learning and exploring VueJS, Strapi, Firebase, Heroku, GCP, Tensorflow.js, and a whole host of other products and services I have previously had very little exposure too.

The source code and links to tutorials for both these projects is available at:

I will hopefully continue to develop more tutorials on these projects and will be exploring a whole raft of other interesting aspects.

It was by embarking on these projects that I realized just how important side projects have been for me not only as a developer, but as a business person as they totally help me to craft new skills and enable me to stand out from the crowd.

The development of Sourcelink is also greatly inspired from what I learned from reading Rework, – I have recently re-read in order to write the book review – which transformed my outlook on the world of work a few years ago and inspired me to focus on remote working!

I am passionate about changing the way society should view work. I many ways I think we have lost our way and we believe the path to happiness is about making obscene amounts of money. Many people believe life is about being the richest corpse in the cemetery!

The recruitment process and the way companies advertise jobs to attract candidates often manifests this delusion too. Its like Hard Work and long hours are some kind of badge of honour for life.

I have never agreed with corporate view of life and have therefore been self-employed for most of my adult life and simply just helicopter visit the corporate world. Each and every visit reaffirms my belief that no one is ever happy at work or within their company!

If you really sit down to think about it, work or employment really is the worst kind of deal in history for most people. We are all only allocated a finite period of time on this planet. On average we spend 10 – 15 years of that time educating and preparing ourselves to enter the world of work, where we will spend on average between 40-50 years trading our time for money, in the hope that we will be disease free and fit enough to possibly enjoy on average 10 to enjoy spending time on what we want to do!

In most of my discussions with people in the work place and this irrespective of companies I have worked in it seems the general consensus is that work generally pays enough money for them to live, but never enough for the life they want to live!

I am a firm believer in the concept of aUniversal Basic Income which in my opinion will drive more people to be entrepreneurial. I also firmly believe this will also be a primary driver for the advancement of humanity.

I also firmly believe that a Universal Basic Income will inspire more people to take up side projects to explore their true passions.

Summary

It is my opinion and a firm belief that side projects are an essential component of a healthy lifestyle. They are not just an excuse just to work more, but they are just an avenue for people to explore their true passions and interests.

Side projects are not just about the pursuit of creating another Billions Dollar startup, although there are many side projects that have become one. Side Projects, should rather be viewed as a mechanism for everyone to be able to contribute to advancement of humanity and the welfare of the planet!

The Builder Pattern .net core

Gary Woodfine — Wed, 01 May 2019 20:54:47 +0000

The Builder Pattern is a creational Gang of Four (GoF) design pattern, defined in their seminal book Design Patterns: Elements of Reusable Object-Oriented Software, in which they presented a catalogue of simple and succinct solutions to commonly occurring design problems.

The pattern is useful for encapsulating and abstracting the creation of objects. It is distinct from the more common Factory Pattern because the Builder Pattern contains methods of customising the creation of an object.

Whenever an object can be configured in multiple ways across multiple dimensions, the Builder Pattern can simplify the creation of objects and clarify the intent.

Let's explore the Builder Pattern and how developers can use it to construct objects from components. You may have already seen that the Factory Pattern returns one of several different subclasses, depending on the data passed in arguments to creation methods.
We'll now learn that the Builder Pattern assembles a number of objects in various ways depending on the data.

Advantages of the Builder Pattern

The builder pattern enables developers to hide details of how an object is created
The builder pattern enables developers to vary the internal representation of an object it builds.
Each specific builder is independent of others and the rest of the application, improving Modularity and simplifies and enables the addition of other Builders.
Provides greater control over the creation of objects.

The builder pattern is similar to the Abstract Factory Pattern in that both return classes made up of a number of other methods and objects.

The main difference between the Builder Pattern and the Abstract Factory Pattern, is that the Abstract Factory Pattern returns a family of related classes and the Builder Pattern constructs a complex object step by step, depending on the data presented to it.

Builder Pattern in Unit tests

The builder pattern is a popular pattern to use in Unit tests, in fact one of my favourite tools to use in Unit Tests is Nbuilder - A rapid test object generator, which if you read the source code also provides a great example of how to implement the builder pattern.

In his book Adaptive Code Gary Maclean Hall states the builder pattern is useful for encapsulating and abstracting the creation of objects, and provides an example of using the builder pattern to help clarify the intent of unit tests, by assisting to eliminate any unnecessary arrange code.

Example Builder Pattern

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Through a series of blog posts on garywoodfine.com I will discuss these patterns and more on how C# .net core developers can implement these patterns in cross platform .net core software solutions.

Software Design Patterns

Software Design patterns are typically…

View on GitHub

In this example, we are going to implement a very simple Builder Pattern and use it to create a Person class to contain some attributes to describe a person

  public class Person
    {
        public int Id { get; set; }

        public string Firstname { get; set; }

        public string Lastname { get; set; }

        public DateTime DateOfBirth { get; set; }

        public Gender Gender { get; set; }
    }

You may notice that we make use of an Enum to contain the value of the gender.

 public enum Gender
    {
        Male,
        Female
    }

There is nothing all that complicated about the class, it's a simple POCO class. We can now develop our Builder class, which again we will keep simple to help illustrate the point. The builder class will basically return the object in a string format.

 public class Person
    {
        public int Id { get; set; }

        public string Firstname { get; set; }

        public string Lastname { get; set; }

        public DateTime DateOfBirth { get; set; }

        public string Occupation { get; set; }

        public Gender Gender { get; set; }

        public override string ToString()
        {
            return  $"Person with id: {Id}  with date of birth {DateOfBirth.ToLongDateString()}   and name {string.Concat(Firstname, " ",Lastname)} is a {Occupation}";
        }
    }

The builder class in its simplest guise just a series of name constructor methods with arguments, you'll notice that they always return an instance of the class. The final method on the builder class is Build method will return the completed object. By convention this method is typically named Build or Create or something similar.

public class PersonBuilder
    {
        private readonly Person _person;

         public PersonBuilder()
        {
            _person = new Person();
        }

         public PersonBuilder Id(int id)
        {
            _person.Id = id;
            return this;
        }

         public PersonBuilder Firstname(string firstName)
        {
            _person.Firstname = firstName;
            return this;
        }

         public PersonBuilder Lastname(string lastname)
        {
            _person.Lastname = lastname;
            return this;
        }

         public PersonBuilder DateOfBirth( DateTime dob)
        {
            _person.DateOfBirth = dob;
            return this;
        }

         public PersonBuilder Gender(Gender gender)
        {
            _person.Gender = gender;
            return this;
        }

         public PersonBuilder Occupation(string occupation)
        {
            _person.Occupation = occupation;
            return this;
        }

         public Person Build()
        {
            return _person;
        }
    }

We can now make use of our Builder to create a person as follows.

   class Program
     {
         static void Main(string[] args)
         {

             var person = new PersonBuilder()
                 .Id(10)
                 .Firstname("Gary")
                 .Lastname("Woodfine")
                 .Gender(Gender.Male)
                 .DateOfBirth(DateTime.Now)
                 .Occupation("Freelance Full-Stack Developer")
                 .Build();

             Console.WriteLine(person.ToString());

             Console.ReadLine();
         }
     }

We build the object by instantiation the PersonBuilder then adding the properties, then the final method we call is the Build method. We then simply call the ToString() method to write out our values.

Using the Builder Pattern, we can avoid using large constructor methods to provide all the required parameters for constructing our object. Large constructor methods lead to unreadable and difficult to maintain code. It is possible that there may not always be the need to supply all arguments in constructor methods because in all probability they won't always be needed.

In the above code, I intentionally introduced a code smell, in the ToString(), you'll notice there is a lot of string interpolation and even additional concatenation. I primarily because I wanted to highlight how the .net core makes use of the builder pattern.

We can make use of the StringBuilder class, StringBuilder prevents having to recreate a string each time you are adding to it. Using the String class in C# means you are using an immutable object, but StringBuilder is much faster in most cases since it's not having to create a new String each time you append to it.

We can now refactor our ToString() method as follows.

public override string ToString()=>
         new StringBuilder()
            .Append("Person with id: ")
            .Append(Id.ToString())
            .Append("with date of birth ")
            .Append(DateOfBirth.ToLongDateString())
            .Append(" and name ")
            .Append(Firstname)
            .Append(" ")
            .Append(Lastname)
            .Append(" is a ")
            .Append(Occupation)
            .ToString();

We use the StringBuilder to create the string. You'll notice, that even though I said by convention you could use the Build or Create to define the method that will return your object, but you don't really need to rather you could opt for another name, in the case of StringBuilder it is ToString()

In the above example, we have implemented a simple builder pattern, however, it probably isn't easy to determine why this actually provides any benefit to developers. After all, from this simple implementation, you might be thinking but surely we could just simply use C# object initialisation and get exactly the result.

 var person2 = new Person
             {
                 Id = 10,
                 Firstname = "Gary",
                 Lastname = "Woodfine",
                 DateOfBirth = DateTime.Now,
                 Occupation = "Freelance Full Stack Developer",
                 Gender = Gender.Male
             };

The problem with this approach is that it is vry similar to passing arguments to a function, which inadvertently adds complexity to understanding the code.

The ideal number of arguments for a function is zero (niladic). Next comes one (monadic), followed closely by two (dyadic). Three arguments (triadic) should be avoided when possible. More than three (polyadic) requires very special justification – and then shouldn’t be used anyway.

Uncle Bob - Clean Code

There will invariably be situations when instantiating objects that you will need to call a function to do something to provide a value to that object. i.e. Generate a new ID which may need calling out to function to get a newly created Id value etc.

It is in situations like this that make the Builder pattern a much more viable option, and as defined in Philosophy of Software Design we are able to pull complexity downwards.

When developing a module, look for opportunities to take a little bit of extra suffering upon yourself in order to reduce the suffering of your users.
John Ousterhout - Philosophy of Software Design

Fluent Builder Pattern implementation

The standard definition the Builder pattern separates the construction of a complex object from its representation so that the same construction process can create different representations.

The Builder pattern provides step-by-step creation of a complex object so that the same construction process can create different representations is the routine in the builder pattern that also makes for finer control over the construction process. All the different builders generally inherit from an abstract builder class that declares the general functions to be used by the director to let the builder create the product in parts.

Builder has a similar motivation to the abstract factory but, whereas in that pattern, the client uses the abstract factory class methods to create its own object, in Builder the client instructs the builder class on how to create the object and then asks it for the result. How the class is put together is up to the Builder class. It's a subtle difference.

The Builder pattern is applicable when the algorithm for creating a complex object should be independent of the parts that make up the object and how they are assembled and the construction process must allow different representations for the object constructed.

If we consider a person object and think of all the different variations we could expect to create a person object. For instance, how do we deal with married woman? Considering in some cases we may need to take into consideration her maiden name.

It soon becomes clear that there are all manner of rules and variations we need to consider when building a person object. All manner of varying combinations and additional properties we will need to include.

Rules that may not be easy or convenient to incorporate in object initialization. We will also need to have the flexibility and adaptability to change or add additional methods in future developments.

In our first implementation of builder for a fluent interface of the Person class, we implemented the builder with no strings attached. We have not enforced rules for the order of assignment.

The code is simple and easy to understand but it does leave the builder class open to misuse. We can implement the basic expression builder with method chaining in C# .NET.

We're going to refactor our builder slightly to incorporate a new method Create which will accept Firstname and Lastname argument but more importantly we are going to remove the creation of the Person class from the constructor
and into Create method.

It also doesn't make much sense providing and Id to an object on creation, it is highly likely that a new Id should be created when the object is created. So we'll also remove the Id parameter from the Builder.

Implementing a fluent interface is a relatively straight-forward task that can be done through the use of method chaining. Method chaining is simply a set of assignment methods that return itself. The result from each method can then call the next assignment method, and so-on.

To guide the user and enforce rules of construction (such as, the Class can only be assigned once, followed by attributes), we utilize progressive interfaces. Where the method would return “this”, we instead return an interface for the next step in line.

   public class PersonBuilder
      {
          private Person _person;

         public PersonBuilder Create(string firstName, string lastName)
          {
              _person = new Person();
              _person.Firstname = firstName;
              _person.Lastname = lastName;
              _person.Id = Guid.NewGuid();
              return this;

          }
          public PersonBuilder DateOfBirth( DateTime dob)
          {
              _person.DateOfBirth = dob;
              return this;
          }

          public PersonBuilder Gender(Gender gender)
          {
              _person.Gender = gender;
              return this;
          }

          public PersonBuilder Occupation(string occupation)
          {
              _person.Occupation = occupation;
              return this;
          }

          public Person Build()
          {
              return _person;
          }
      }

We’ve implemented the Expression Builder pattern using method chaining. The class itself constructs a Person for us. We may then call any of the assignment methods to populate the fields and attributes of the Character class. Each method returns a copy of itself, allowing us to chain the assignment methods, one after the other, thus implementing our fluent interface in C# .NET. We can then finally call the Build() method to obtain the completed Person class.

Summary

We examined the Builder Pattern and seen how useful it is too create complex objects. We also looked at an example of how the .net core framework itself makes use of the builder pattern to provide common functionality string building functionality.

Using Serverless Framework Environment Variables .net core Lambda

Gary Woodfine — Thu, 25 Apr 2019 14:26:44 +0000

In previous posts, have explored getting started with Serverless Framework and how to implement Simple Dependency Injection and then we explored how to implement more advanced dependency injection concepts relating to AWS Lambda.

In each of these posts, we explored different levels of interactivity and how the Serverless Framework helps you develop and deploy your AWS Lambda functions and .net core and C#. In this post, we are going to delve a little deeper again into one specific area of how you can create Environment Variables with the Serverless Framework and share them with the .net core executable.

This is a useful strategy to learn as it helps you to create easily configurable and maintainable infrastructure as code and helps to element those Magic Strings from your code base.

We are going to make use of the serverless.yml to create our environment variables so if you not all that familiar with it then I recommend reading the high-level serverless.yml reference but I will explain the features we’re going to use as I go through.

Environment Variables in Serverless Framework

The Environment tag in the Serverless Framework YAML file enables you to create service-wide environment variables which you can easily make use of in other programming languages, for instance in nodejs based lambda functions you could simply create an environment variable in your serverless.yml as follows

Environment:
    Variables:
      TABLE_NAME: SomeTableName

You can then simply reference and get the value from the environment variable in your code as follows

const tableName = process.env.TABLE_NAME;

This is because of one of the many quirks of the JavaScript that make it both a pleasure and pain to work with in equal amounts and also because the process object is a global that provides information about, and control over, the current Node.js process

In .net core however there is a little bit additional work required but, in my opinion at least, is worth it when it comes to managing variables etc.

We will be building on the code base I introduced in how to implement Simple Dependency Injection the branch we’ll be using is EnvironmentVariables

garywoodfine / HelloConfiguration

AWS Lambda and .net core dependency injection

Hello Configuration

Source Code to support a series of blog posts to detailing how to use Dotnet Core Configuration and Dependency Injection in AWS Dotnet core lambdas

Donate

Hello Configuration is a FREE tutorial developed and supported by Threenine.co.uk

If you would like to make a donation to keep the developers stocked with coffee and pizza's would be greatly appreciated.

View on GitHub

How to use Environment Variables in .net core

In order to extend our AWS Lambda application to make use of Environment Variables we will need to add an additional reference to our application.

dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables –version 2.1.0

Once this is added we can now add an environment variable to our serverless.yml. We’ll create an environment variable called SaySomething and provide some arbitary statement.


service: Hello-Configuration

provider:
  name: aws
  runtime: dotnetcore2.1
  environment:
    SaySomething: "Eating coconuts is cool"

package:
  individually: true

functions:
  hello:
    handler: HelloConfiguration::Threenine.ConfigTest.Functions.Speak::Greet


    package:
      artifact: bin/release/netcoreapp2.1/hello.zip

We can then edit our LambdaConfiguration.cs to the below

using System.IO;
using Microsoft.Extensions.Configuration;

namespace Threenine.ConfigTest
{
    public class LambdaConfiguration : ILambdaConfiguration
    {
        public static IConfigurationRoot Configuration => new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddEnvironmentVariables()
            .Build();

        IConfigurationRoot ILambdaConfiguration.Configuration => Configuration;
    }
}

We can now make use of this in our code as follows, we’ll edit our SpeakService to make use of the of the environment variable.

using Microsoft.Extensions.Options;

namespace Threenine.ConfigTest.Services
{
    public class SpeakService : ISpeakService
    {
        private readonly Greeting _greeting;

        public SpeakService(IOptions<Greeting> hello)
        {
            _greeting = hello.Value;

        }

        public string Greeting => string.Concat( _greeting.Message, " ", System.Environment.GetEnvironmentVariable("SaySomething"));
    }
}

If we build, deploy and invoke our lambda this will work fine. However, I’m sure the clean coders amongst you will be thinking that this is dirty and we have polluted the code base a little.

Adding Environment Variables to Dependency Injection

Next we’ll create a class that we will use to store the environment variable, we will make available to the classes in which will make use of it via dependency injection.

In this case it’s a very simple class which is going t have a property we will make use of later.


namespace Threenine.ConfigTest.Config
{
    public class SpeakEnvironment
    {
        public string SaySomething { get; set; }
    }
}

The .net core framework enables us to really easily now configure and bind these variables at runtime using the Environment Variables Configuration Provider , all that we now really do is rename our Environment Variable in our serverless.yaml to include the name of our Class and a double underscore

When working with hierarchical keys in environment variables, a colon separator (:) may not work on all platforms (for example, Bash). A double underscore (__) is supported by all platforms and is replaced by a colon.

service: Hello-Configuration

provider:
  name: aws
  runtime: dotnetcore2.1
  environment:
    SpeakEnvironment__SaySomething: "Eating coconuts is cool"

package:
  individually: true

functions:
  hello:
    handler: HelloConfiguration::Threenine.ConfigTest.Functions.Speak::Greet


    package:
      artifact: bin/release/netcoreapp2.1/hello.zip

Modify the StartUp class to configure the environment variables and wire them up for Dependency Injection we do this on line 20, which is similar to what we did previously.

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Threenine.ConfigTest.Config;
using Threenine.ConfigTest.Services;

namespace Threenine.ConfigTest
{
    public class StartUp
    {
         public static IServiceCollection Container => ConfigureServices(LambdaConfiguration.Configuration); 


                private static IServiceCollection ConfigureServices(IConfigurationRoot root)
                {
                    var services = new ServiceCollection();
                    services.Configure<Greeting>(options =>
                        root.GetSection("greeting").Bind(options));

                    services.AddTransient<ISpeakService, SpeakService>();
                    services.Configure<SpeakEnvironment>(options => root.GetSection("SpeakEnvironment").Bind(options));
                   return services;

                }
    }
}

Additional Configuration Options

The above example works great, however you may have still spotted an additional concern. Perhaps you’re thinking this is great but what if you wanted to have different configuration options for your specific environments. For instance what if you wanted data that is created in your staging environment be redirected to different tables or queues than the ones you use in the Production ?

Fortunately, the Serverless Framework provides a super simple option, a configuration for your serverless.yml. By convention, this is typically implemented by creating an additional env.configs.yml

Typically you’ll use this file to create Environment Specific configuration information or sensitive information. For instance, you may want to store your AWS Account ID or even version or feature information.

This file will most likely not be stored in your Source Code Repository and will probably be managed by your DevOps process. However, in my case I included it in the repo to provide a sample.

I’ll create a simple file to provide a general idea:

feature: <feature_name>
version: 1.0.0.0
region: <aws_region>
accountId: <aws_account_id>
something: "Coconuts are cool to eat"

In our case we created a variable which we name something and provided an arbitrary value. We can now edit our serverless.yml to make use of this file


service: Hello-Configuration

provider:
  name: aws
  runtime: dotnetcore2.1
  environment:
    SpeakEnvironment__SaySomething: ${file(env.configs.yml):something}

package:
  individually: true

functions:
  hello:
    handler: HelloConfiguration::Threenine.ConfigTest.Functions.Speak::Greet

    package:
      artifact: bin/release/netcoreapp2.1/hello.zip

Summary

We now have an easy to configure Lambda and the ability to create environment variables within our Serverless.yaml and consume them in our .net core lambda.

Advanced Serverless AWS Lambda Dependency Injection

Gary Woodfine — Tue, 23 Apr 2019 16:08:28 +0000

I have previously provided a simple example of how to introduce simple dependency injection and configuration to your Serverless Framework AWS Lambda, In this post, we’ll dive a little deeper and learn how to completely implement dependency injection and how to layout your Lambda Project.

The issue when creating projects using frameworks and templates is that it often guides developers into thinking that the only way too can implement solutions is by following the guidelines provided by the project template.

The truth is when it comes to the Serverless Framework the only thing that is of any real importance is the YAML file, which is primarily used to create Cloud Formation script to create and manage the AWS resources to be used by your Lambda and the deployment script. When it comes to the actual code and structure of your lambda project and the code it contains, it really doesn’t care.

When generating a new AWS Lambda project, the Serverless Framework generates only the simplest project possible. A project which has hardly any features that most .net developers are typically used too and it falls on to them to implement all the features they need.

In this post, I will walk you through how to implement full-blown Dependency Injection, Configuration and even make use of IHost functionality in your AWS Lambda projects. The only restriction you’ll face in AWS Lambda Projects is that at the time of writing you are limited to using .net core 2.1

garywoodfine / HelloConfiguration

AWS Lambda and .net core dependency injection

Hello Configuration

Source Code to support a series of blog posts to detailing how to use Dotnet Core Configuration and Dependency Injection in AWS Dotnet core lambdas

Donate

Hello Configuration is a FREE tutorial developed and supported by Threenine.co.uk

If you would like to make a donation to keep the developers stocked with coffee and pizza's would be greatly appreciated.

View on GitHub

Start a new AWS Lambda Project

If you haven’t used or unfamiliar with the Serverless Framework then I suggest you read Getting started with .NET Core and the Serverless Framework.it will guide you through installing, provide a basic understanding of Serverless Framework and generate a typical project. I will assume you already have this knowledge for the remainder of this tutorial.

Information

We will be continuing to develop on the code presented inSimple Dependency
Injection In AWS Lambda

Let's generate a new Serverless project

sls create -t  aws-csharp -p HelloConfiguration -n Threenine.ConfigTest

The reality is we could just delete the .net project created and start again, because the only things of use for us in the generated project is the serverless.yml , build.sh but we’ll work with what we’ve got!

We’re going to do a fit of refactoring here to tidy up the generated project to better suit our conventions etc. In a future post, I will provide details on how you can create your own custom Project Templates with the Serverless Framework so you don’t have to do this Boilerplate grunt work on every project you start.

In the first instance, we will want to rename our assembly to more closely match its purpose. When you’re engaging in Micro-services Development and developing many Lambdas you don’t really want 100’s of lambdas all named aws-csharp and a default namespace of AwsDotnetCsharp, it really doesn’t describe the component you’re developing and is counter-intuitive to the Philosophy of Software Design

The process to renaming your Assembly and setting the default namespace is as normal in whichever IDE or Text Editor you’re using. I predominantly use Jet Brains Rider – A fast & powerful cross-platform .NET IDE , so my process will be slightly different to most. However, there are few important edits to make to your serverless.yml to ensure you don’t implement breaking changes.


service: Hello-Configuration

provider:
  name: aws
  runtime: dotnetcore2.1

package:
  individually: true

functions:
  hello:
    handler: HelloConfiguration::Threenine.ConfigTest.Handler::Hello


    package:
      artifact: bin/release/netcoreapp2.1/hello.zip

You’ll notice I simply edit line 12 to represent the fact I have renamed my Assembly to HelloConfiguration and my Namespace for my project is now Threenine.ConfigTest. For the purpose of this Demo code, this will suffice, I just wanted to highlight that you can edit these project files to better suit your needs.

Add a StartUp class

In the sample code for Simple Dependency Injection In AWS Lambda we followed some pretty bad coding practices and created one class that did everything, which is not SOLID and could cause all sorts of maintenance nightmares so we do some refactoring on that class and split core functional components into their own classes. I always have the principles of Adaptive Code in mind when developing!

So lets add a new class and by convention we’ll call this StartUp.cs

We are going to slightly refactor our ILambdaConfiguration and LambdaConfiguration to make use of IConfigurationRoot which represents the root of an IConfiguration hierarchy

public interface  ILambdaConfiguration
    {
        IConfigurationRoot Configuration { get; }
    }

public class LambdaConfiguration : ILambdaConfiguration
    {
        public static IConfigurationRoot Configuration  => new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .Build();


        IConfigurationRoot ILambdaConfiguration.Configuration => Configuration;
    }

Our new startUp class is going to be the location where we wire up our dependency and configuration data that our application is going to use.

So before we actually do that, we’ll have to create our services and do some more refactoring of our application. In my example I deleted the Handler.cs file created a new directory named Functions and created a new class in that directory named Speak.cs

For the sake of demo, I created an additional Directory named Services and created an interface of ISpeakService and a class called SpeakService

public interface ISpeakService
    {
        string Greeting { get; }
    }


public class SpeakService : ISpeakService
    {
        private readonly Greeting _greeting;
        public SpeakService(IOptions<Greeting> hello)
        {
            _greeting = hello.Value;
        }

        public string Greeting => _greeting.Message;
    }

You’ll notice that the SpeakService with make use of the Options patternprovide a mechanism to validate configuration data . We also seem to using a class called Greeting, let's go ahead and create that class

[JsonObject("greeting")]
    public class Greeting
    {
        [JsonProperty("message")]
        public string Message { get; set; }
    }

We can now wire up our dependencies in our StartUp class

public class StartUp
    {
        public static IServiceCollection Container => ConfigureServices(LambdaConfiguration.Configuration);


        private static IServiceCollection ConfigureServices(IConfigurationRoot root)
        {

            var services = new ServiceCollection();

            //Wire up all your dependencies here
            services.Configure<Greeting>(options =>
                root.GetSection("greeting").Bind(options));

            services.AddTransient<ISpeakService, SpeakService>();

            return services;
        }
    }

In our Speak.cs class we’ll now make use of all our dependencies. You’ll notice that we will create 2 class constructors one of which will take in an IServiceProvider and the other will instantiate this class by initialising out StartUp class.

Our greet method will then Get a service we from our IOC container and use it. We make use of the ServiceProvider.GetService method to get the service object of the specified type.


public class Speak
    {
        private readonly IServiceProvider _serviceProvider;

        public Speak(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }

        public Speak() : this(StartUp.Container.BuildServiceProvider())
        {
        }

        [LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]
        public string Greet(ILambdaContext context)
        {
            var talk = _serviceProvider.GetService<ISpeakService>();

            return talk.Greeting;
        }
    }

We need to update our Serverless yaml to take into consideration our refactoring

service: Hello-Configuration

provider:
  name: aws
  runtime: dotnetcore2.1

package:
  individually: true

functions:
  hello:
    handler: HelloConfiguration::Threenine.ConfigTest.Functions.Speak::Greet


    package:
      artifact: bin/release/netcoreapp2.1/hello.zip

We will also modify our AppSettings file slightly to create a Greeting section

{
    "greeting" : {
        "message": "This is from the configuration"
    }
}

Build, Deploy and Invoke

We can now build our lambda


sudo ./build.sh

We can then deploy our Lambda


sls deploy

Then we can invoke it to see if everything works as expected


sls invoke -f hello

Summary

In this sample, we have enabled our lambda to make use of some great .net core features of Dependency Injection and Configuration. This will enable developers to de-clutter their lambda functions and help to organise their code and also enable the use of additional libraries.

Simple Dependency Injection In AWS Lambda .net core

Gary Woodfine — Mon, 22 Apr 2019 22:30:47 +0000

I’ve previously discussed how to develop a .net core AWS Lambda with the serverless frameworkto provide an abstraction over the underlying operating system and execution runtime so that you can more easily achieve economies of scale using Cloud computing paradigms.

In this post, I will expand on these concepts and provide an introduction on how you can introduce concepts like dependency injection and configuration to your lambda functions.

Serverless Framework enables you to easily create and manage resources used by your Lambda components and creates a simple stub function enabling you to focus on developing your function.

The one problem with this is that developers may perceive that they can’t implement all the usual good things you would in any other development project and judging from some of the code I have had to deal with out in the wild this certainly is true!

garywoodfine / HelloConfiguration

AWS Lambda and .net core dependency injection

Hello Configuration

Source Code to support a series of blog posts to detailing how to use Dotnet Core Configuration and Dependency Injection in AWS Dotnet core lambdas

Donate

Hello Configuration is a FREE tutorial developed and supported by Threenine.co.uk

If you would like to make a donation to keep the developers stocked with coffee and pizza's would be greatly appreciated.

View on GitHub

AWS Lambda and .net core

AWS Lambda supports a number of programming languages and runtimes, well custom runtimes which enable the use of any language and execution environment. Included in the list of standard runtimes is Microsoft .NET Core, an open-source cross-platform runtime, which you can build apps on using the C# programming language.

When generating a project using the serverless framework template is that it lacks the usual hooks for setting up configuration and dependency injection. Youâ€™re on your own for adding the necessary code. I will walk you through the process of implementing all the boilerplate code required.

To generate a new serverless lambda project we’ll use the following Serverless command:

sls create -t  aws-csharp -p HelloConfiguration -n Threenine.ConfigTest

Information

To learn how to install the Serverless Framework and what these commands do I urge you to read Getting started with .NET Core and the Serverless Framework

Once the project has been generated we can set to work clearing out the Handler.cs and remove most of the code there so we’re only left with the following

using Amazon.Lambda.Core;
using System;

[assembly:LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]

namespace AwsDotnetCsharp
{
    public class Handler
    {

    }
}

Add .net core Dependency Injection to lambda

Anytime you directly create an object you are coupling yourself to a specific implementation. So it stands to reason that youâ€™d want to apply the same Inversion of Controlpattern and .NET Core Dependency Injection goodness to your AWS Lambda Functions as you would in a standard ASP.NET Core Web API project.

The additional benefit of making use of IOC and Dependency Injection code in an AWS Lambda project is that you can eventually make use of AWS Lambda Layers which enable you to configure your Lambda function to pull in additional code and content in the form of layers.

A layer is a ZIP archive that contains libraries, a custom runtime, or other dependencies. With layers, you can use libraries in your function without needing to include them in your deployment package.

First, we need to wire up dependency injection, so in order to do that add the following references to our project

dotnet add package Microsoft.Extensions.Hosting –version 2.1.0
dotnet add package Microsoft.Extensions.Configuration –version 2.1.0
dotnet add package Microsoft.Extensions.Configuration.Json –version 2.1.0

Note the version number, this is due to fact AWS lambda currently only supports .net core 2.1.0.

In our next step lets add a new Interface which we’ll name ILambdaConfiguration.cs

using Microsoft.Extensions.Configuration;

namespace AwsDotnetCsharp
{
    public interface  ILambdaConfiguration
    {
        IConfiguration Configuration { get; }
    }
}

Implement Lambda Configuration

We can now add a class that will implement the interface we’ll imaginatively call this LambdaConfiguration.cs

Initially, we are going to enable our Lambda to read configuration settings from an appsettings.json file so before we add the code to do so add the file to your project. Just add an empty json file, by convention .net developers name this file appsettings.json but you can call it whatever you want.

Your aws-csharp.csproj should now look something similar to this


<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
    <AssemblyName>CsharpHandlers</AssemblyName>
    <PackageId>aws-csharp</PackageId>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Amazon.Lambda.Core" Version="1.0.0" />
    <PackageReference Include="Amazon.Lambda.Serialization.Json" Version="1.3.0" />
    <PackageReference Include="Microsoft.Extensions.Hosting" Version="2.1.0" />
       <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.1.0" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.1.0" />
  </ItemGroup>

  <ItemGroup>
    <DotNetCliToolReference Include="Amazon.Lambda.Tools" Version="2.2.0" />
  </ItemGroup>

  <ItemGroup>
    <None Remove="appsettings.json" />
    <Content Include="appsettings.json">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
  </ItemGroup>

</Project>

We can edit the LambdaConfiguration to get data from our App Settings

using System.IO;
using Microsoft.Extensions.Configuration;

namespace AwsDotnetCsharp
{
     public class LambdaConfiguration : ILambdaConfiguration
    {
        public IConfiguration Configuration  => new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .Build();


    }
    }
}

We can now complete the code from our simple lambda. So edit the Handler.cs to contain the following code.

using Amazon.Lambda.Core;
using Microsoft.Extensions.DependencyInjection;

[assembly:LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]

namespace AwsDotnetCsharp
{
    public class Handler
    {
        private ILambdaConfiguration Configuration { get; }

        public Handler()
        {
            var serviceCollection = new ServiceCollection();
            ConfigureServices(serviceCollection);
            var serviceProvider = serviceCollection.BuildServiceProvider();
            Configuration = serviceProvider.GetService<ILambdaConfiguration>();
        }

        public string Hello( ILambdaContext context)
        {
            return LambdaConfiguration.Configuration["hello"] ?? "None";
        }

        private void ConfigureServices(IServiceCollection serviceCollection)
        {
            serviceCollection.AddTransient<ILambdaConfiguration, LambdaConfiguration>();
        }

    }
}

All this code is basically doing is wiring up the dependency injection and configuring the application. Online 20 we have created a simple Hello lambda method and the only thing it does is read a value from the app settings file, a key which we have called hello.

Our App Settings file is rather simple and looks like

{
    "hello": "This is from the configuration"
}

Build and Deploy the Lambda

We can now build and deploy our lambda using Serverless Framework. I typically work on my Linux box so I will build the application making use of the build.sh. I have kept the yaml file really simple and it contains the following

service: Hello-Configuration # NOTE: update this with your service name

provider:
  name: aws
  runtime: dotnetcore2.1

package:
  individually: true

functions:
  hello:
    handler: CsharpHandlers::AwsDotnetCsharp.Handler::Hello


    package:
      artifact: bin/release/netcoreapp2.1/hello.zip

Using the build command

sudo ./build.sh

Then once the build has completed we can simply deploy our application to AWS using


sls deploy

after the deploy has completed we can simply test our function by invoking it as follows


sls invoke -f hello

We should then see the response printed of whatever the value you placed in the appsettings file

Summary

In this simple tutorial, we have discovered how to implement a basic implementation of Dependency Injection and we have also provided an example of how you can make use of application configuration to make use of appsettings to store additional configuration information for your AWS Lambda and read this information at run time.

If you want to learn more advanced techniques on how to implement dependency injection in AWS Lambda with .net core check out Serverless AWS Lambda Dependency Injection

Making API calls with HttpClientFactory in Console applications

Gary Woodfine — Tue, 16 Apr 2019 07:55:57 +0000

.Net Core console applications are by far the most popular applications most developers will routinely develop in order to implement some kind of automation-based task.

I have previously discussed how by using IHost in .net core console applications developers can create asynchronous Linux Daemons and how to use Configuration API in .net core console application.

In this post, I will expand on both of these examples and provide an example of how to use .net core console applications and the HttpClient to develop a Linux daemon to interact with a Web-Based API to extract and process data.

What is the HttpClient

In .net core the HttpClient Class provides a base class for sending HTTP requests and receiving HTTP responses from a resource identified by a URI.

In previous versions on.net framework developers misused the HttpClient by typically wrapping it in a using block, primarily because the HttpClient implements a Dispose method.

The using statement is a C# language feature for dealing with disposable objects. Once the using block is complete then the disposable object. In fact, many refactoring tools like Jetbrains Resharper including my personal favourite cross-platform .net IDE Jetbrains Rider will explicitly warn if you don’t. However, In this case disposing of HttpClient was the wrong thing to do.

It is unfortunate that HttpClientimplements IDisposable which encourages the wrong behaviour.

The dispose method is called and whatever resources are in use are cleaned up. This is a typical pattern in .NET and is used for everything from database connections to stream writers. Any object which has external resources that must be cleaned up using the IDisposable interface.

You will undoubtedly find code similar to this in almost all code bases, where the HttpClient is used to download resources or connect to API’s.

   using (var client = new HttpClient())
    {
        var content = await client.GetStringAsync(Url);
        return JsonConvert.DeserializeObject<List<Model>>(content);
    }

The underlying issue with this code is that while this HttpClient class is disposable, using it with the using statement is not the best choice because even when you dispose HttpClient object, the underlying socket is not immediately released and can cause a serious issue named ‘sockets exhaustion’.

HttpClient is intended to be instantiated once and reused throughout the life of an application. Instantiating an HttpClient class for every request will exhaust the number of sockets available under heavy loads.

Possible approaches to solve the problem are based on the creation of the HttpClient object as singleton or static. However, the HttpClient was not designed to be used as a SIngleton or static object as it doesn’t respect DNS changes.

In .net core 2.1 , a new HttpClientFactory was introduced to be used to implement resilient HTTP calls by integrating Polly, which is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.

What is the HttpClientFactory

The HttpClientFactory is a new mechanism to create HttpClient instances that are properly managed behind the scenes. The HttpClientFactory manages the lifetime of the handlers so that we have a pool of them which can be reused, while also rotating them so that DNS changes are respected.

The expensive part of using HttpClient is actually creating the HttpClientHandler and the connection. By Pooling these within the HttpClientFactory enables more efficient use of the connections. Using the HttpClientFactory to request a HttpClient, creates a new instance each time, meaning no need to worry about mutating its state. The HttpClient may or may not use an existing HttpClientHandler from the pool and therefore use an existing open connection.

How to use the HttpClientFactory

Like most objects in the .net core framework, the HttpClientFactory has been optimised so it can be made use of by Dependency Injection. I will illustrate a typical approach take when making use of the HttpClientFactory, in this approach I’ll be developing a Linux Daemon which will be used to contact a Rest API end-point too extract and process data.

To do so we will be using IHost in .net core console applications and expand further on typical usage scenarios. We will also see an example how to use Configuration API in .net core console application .

In this scenario, we generate a simple Console Application then modify the code to make use of the IHost to enable dependency injection, logging and configuration. You will need to add a number of packages, details of which can be found in the articles referenced.

I have also added the requisite json files:

appsettings.json
appsettings.Development.json
appsettings.Production.json
hostsettings.json

class Program
    {
        private const string EnvironmentVariablePrefix = "ADZUNA_FEED_";
        public static async Task Main(string[] args)
        {

            var host = new HostBuilder()
                .ConfigureHostConfiguration(hostConfig =>
                {
                    hostConfig.SetBasePath(Directory.GetCurrentDirectory());
                    hostConfig.AddJsonFile("hostsettings.json", true);
                    hostConfig.AddEnvironmentVariables(EnvironmentVariablePrefix);
                    hostConfig.AddCommandLine(args);
                })
                .ConfigureAppConfiguration((hostingContext, config) =>
                {
                    config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                    config.AddJsonFile("appsettings.json", true, true);
                    config.AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json");
                })
                .ConfigureServices((hostContext, services) =>
                    {
                        services.AddLogging();


                    }
                )
                .Build();
            await host.RunAsync();                      
        }

Information

In .net core 3.0 you will be able to generate projects which will have all
this boiler plated code available as the Worker Service Template

Now that the basic project template has been configured we’re all good to go. As you might of deduced from the code, the service we’re going to develop is going to connect to the Adzuna API service to extract data. However, I will attempt to make the concepts as generic as possible so you can follow along and connect to any Web API service of choice.

The first thing we need to do before we wire up our HttpClientFactory is to edit our appsettings.[Environment].json files so the contain the configuration data we’ll need

{
   "adzuna": {
      "key" : "",
      "secret": "",
   }
}

You will notice we are going store our configuration details that we will need these are credentials you receive when you register to use the Adzuna API.

The Adzuna API enables developers to get the very latest ads, job, property and car ads, and data with Adzuna’s API. Adzuna’s up-to-the-minute employment data to power your own website, reporting and data visualisations.

In particular scenario I also wanted to create a Configuration class to contain the Base Urls that I will be using in my application. So I created another POCO class as follows.

 [JsonObject("baseUrls")]
    public class BaseUrls
    {
        [JsonProperty("adzuna")]
        public string Adzuna { get; set; }
    }

We add the details to our environment specific App Settings file as follows:

{
   "adzuna": {
      "key" : "",
      "secret": ""

   },
   "baseUrls": {
      "adzuna" : "http://api.adzuna.com/v1/api/"
   }

}

Information

Always ensure you include the trailing / when including a base address
because this is the only permutation that seems to work.

With the details we can now edit our Program.cs to enable the dependency injection and to retrieve the configuration details from our App Settings file

  dotnet add package Microsoft.Extensions.Http –version 2.2.0

We’re now ready to start writing code for our service,add a new class we’ll call JobProcessingService which will implement the IHostedService interface which defines two methods for objects that are managed by the host.

The daemon we’re going to be be developing here, will potentially be running several times an hour and will be running several jobs at least, so it is important for us to build in some kind of cancellation process using tokens. For this purpose of this post, I will implement a “Good Enough”approach but this is by no means a complete approach and it simply has the basics, but provides at least some understanding of what required.

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Threenine.Job.Feed.Entity;
using Threenine.Job.Feed.Interfaces;

namespace Threenine.Job.Feed.Services
{
    public class JobProcessingService : IHostedService, IDisposable
    {
        private CancellationTokenSource _cts;
        private Task _currentTask;

        private readonly IDownloadService<AdzunaFeed> _service;
        public JobProcessingService(IDownloadService<AdzunaFeed> service)
        {
            _service = service;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);

            // In later version of this task we will get a list of
            //skills which we will be make subsequent calls
            //however for now I just provided an example
          _currentTask = _service.GetFeed("C#",_cts.Token);

            return   _currentTask.IsCompleted ?  _currentTask : Task.CompletedTask;
        }

        public async Task StopAsync(CancellationToken cancellationToken)
        {

            if (_currentTask == null)
            {
                return;
            }

            try
            {
                _cts.Cancel();
            }
            finally
            {
               await Task.WhenAny(_currentTask, Task.Delay(Timeout.Infinite, cancellationToken));
            }
        }

        public void Dispose()
        {
            _cts.Cancel();
        }
    }
}

Now I background task is complete we’ll move onto the actual implementation of our Service which implements the HttpClient, again the implementation here is just enough to provide a flavour of the implementation for demo purpose, but you will see enough of how to implement the HttpClient and make use of it, in a real-world scenario.

The major drawback with the code in this implementation is that we make a call retrieve data and deserialize it but we don’t actually do anything with it! But it this just provides and example of how to use the HttpClient and the HttpClientFactory

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Options;
using Threenine.Job.Feed.Config;
using Threenine.Job.Feed.Entity;
using Threenine.Job.Feed.Interfaces;

namespace Threenine.Job.Feed.Services
{
    public class AdzunaDownloadService : IDownloadService<AdzunaFeed>
    {
        private readonly HttpClient _client;
        private readonly AdzunaCredentials _creds;

        public AdzunaDownloadService(HttpClient client, IOptions<AdzunaCredentials> creds)
        {
            _client = client;
            _creds = creds.Value;
        }

        public async Task<AdzunaFeed> GetFeed(string criteria, CancellationToken token)
        {
            var requestUrl = $"jobs/gb/search?app_id={_creds.Key}&app_key={_creds.Secret}&what={criteria}";
            var response = await _client.GetAsync(requestUrl, token);


            if (!response.IsSuccessStatusCode) throw new ApplicationException();

            var stream = await response.Content.ReadAsStreamAsync();
            return stream.DeserializeFromJson<AdzunaFeed>();
        }
    }
}

You may have noticed I am using an extension method on the Stream class to DeserializeFromJsonI thought I would include the extension method for clarity. The code for this method is in a new class I called StreamExtensions.cs

using System;
using System.IO;
using Newtonsoft.Json;

namespace Threenine.Job.Feed
{
    public static class StreamExtensions
    {
        public static T DeserializeFromJson<T>(this Stream stream)
        {
            if (stream == null) throw new ArgumentNullException(nameof(stream));

            if (!stream.CanRead) throw new NotSupportedException("can't read from stream");

            using (var sread = new StreamReader(stream))
            using (var jsonText = new JsonTextReader(sread))
            {
                var serialiser = new JsonSerializer();
                return serialiser.Deserialize<T>(jsonText);
            }
        }
    }
}

The code for these sections is almost complete, we now just need to wire up our application startup.

We’ll now edit the Program.cs to look like the following

using System;
using System.IO;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Threenine.Job.Feed.Config;
using Threenine.Job.Feed.Entity;
using Threenine.Job.Feed.Interfaces;
using Threenine.Job.Feed.Services;

namespace Threenine.Job.Feed
{
    class Program
    {
        private const string EnvironmentVariablePrefix = "ADZUNA_FEED_";

        public static async Task Main(string[] args)
        {
            var host = new HostBuilder()
                .ConfigureHostConfiguration(hostConfig =>
                {
                    hostConfig.SetBasePath(Directory.GetCurrentDirectory());
                    hostConfig.AddJsonFile("hostsettings.json", true);
                    hostConfig.AddEnvironmentVariables(EnvironmentVariablePrefix);
                    hostConfig.AddCommandLine(args);
                })
                .ConfigureAppConfiguration((hostingContext, config) =>
                {
                    config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
                    config.AddJsonFile("appsettings.json", true, true);
                    config.AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json");
                })
                .ConfigureServices((hostingContext, services) =>
                    {
                        var baseUrls = new BaseUrls();
                        hostingContext.Configuration.GetSection("baseUrls").Bind(baseUrls);
                        services.Configure<AdzunaCredentials>(options =>
                            hostingContext.Configuration.GetSection("adzuna").Bind(options));

                        services.AddHttpClient<IDownloadService<AdzunaFeed>, AdzunaDownloadService>(client =>
                        {
                            client.BaseAddress = new Uri(baseUrls.Adzuna);
                            client.DefaultRequestHeaders
                                .Accept
                                .Add(new MediaTypeWithQualityHeaderValue("application/json"));
                        });
                        services.AddHostedService<JobProcessingService>();
                        services.AddLogging();
                    }
                )
                .Build();
            await host.RunAsync();
        }
    }
}

Summary

We have seen an example of how to make use HttpClientFactory within a .net console application to create a HttpClient instance to be used within a HostedService application.

Product Review: System76 Darter Pro

Gary Woodfine — Fri, 12 Apr 2019 10:14:48 +0000

I recently wanted to upgrade most of my computing equipment mostly because I am fed up with my existing equipment mysteriously slowing down after some operating system upgrades. I won’t name the previous purveyor of said equipment, but needless to say, they are fruit based name.

I have always appreciated the build and design quality of the manufacturers and the fact that the OS is *nix based was always going to be a big draw. Although of the past few years I have been mostly focused on using Ubuntu.

I have a strange loyalty connection to Ubuntu, primarily based on the fact that I grew up in South Africa and the name is derived from a Zulu word and the Founder of Canonical, Mark Shuttleworth also grew up in South Africa.

Over the years my typical approach to buying laptops has been to buy Windows-based laptop then to format the drive and install Ubuntu on it. This obviously introduces risks because for the most part as soon as you do that in most cases you wipe out warranty.

In many ways, this was one of the primary reasons why I started using branded fruit products. Although not totally Linux it was close enough to the experience

For my new laptop, I wanted a device that had similar build and design quality but I wanted a purely Linux based. This is because my main Development machine is Viglen Desktop with Ubuntu 18.04 and I also have a fruit-based name Mini computer too.

The System76 Darter Pro immediately attracted my attention, especially when I spec-ed it up with:

Ubuntu 18.04 LTS (64-bit)
15" Matte FHD 1080p Matte FHD Display
4.6 GHz i7-8565U (1.8 up to 4.60 GHz – 8MB Cache, 4 Cores, 8 Threads)
32 GB Dual Channel DDR4 at 2400MHz (2 X 16 GB)
2 TB Seq Read: 545 MB/s, Write: 525 MB/s
WiFi up to 867 Mbps + Bluetooth

The Darter Pro is a new laptop that has been added to the line of Linux-powered computers and, in keeping with recent trends in the PC space, it's a relatively thin and light machine with a fairly big display and a big battery.

Like all System76 computers, the Darter Pro is available with a choice of Ubuntu 18.04 LTS, Ubuntu 18.10, or Pop!_OS 18.04 LTS (which is the company's own custom fork of Ubuntu).

I opted to go for the standard Ubuntu 18.04, primarily due to reasons discussed earlier and because I just wanted some kind of conformity. However, I will be more than likely be purchasing System76 Meerkat later in the year and will be tempted to try out the PoP OS.

I’m not typically one to place much stock in Benchmark tests, primarily because I much prefer real-world use cases and nothing beats personal experience. Despite this I did do some basic research in order to understand what I could potentially expect, I found the A Linux user review of the Darter Pro laptop from System76 to provide as much of the relevant information I needed, which provided enough justification to go ahead and make my purchase.

The purchase experience

I have to say on the whole I am totally stoked about the purchase experience. The customer experience was great from the beginning. Considering I’m based in the UK and System76 is based in US, there are no physical dealerships in the UK so the only way to purchase is via the website. Which is not a problem for me, as a vast majority of my purchases are made via the internet.

When I initially ordered the item, system76 notified me that due to fact that each device is only built on order that it could take up to 6 days before the item would be shipped, which really wasn’t an issue. Needless to say I was delighted when only 3 days later that my item had been shipped and I could expect to take delivery within the next 3 days.

Well after a minor delay, which due in part to UK customs and excise and an additional £300 in import taxes I took delivery of my new laptop within 10 days of purchase.

Which in reality is not long delay, considering each laptop is custom built on order.

The issues while the laptop was delayed by customs, which may have been caused by either a miscommunication or lack of communication between the courier and UK Customs and Excise. I contacted the System76 customer support and they endeavoured to do everything within their power to help move things along and were always available and responded promptly.

The device experience

System76 Darter Pro

The user experience of the device is awesome! In fact I am typing this blog post on the device and I totally dig the keyboard. The keys really do make for an addictive typing experience just like the marketing says!

The only minor thing I don’t like but reality is I can live with, is that keyboard is US layout. Which isn’t that too dissimilar from the UK on the whole but with minor annoyance of missing £ which helps me to not talk about money when working.

It’s still a bit of novelty to me, but I love changing the colour of backlit keys whenever I feel like a change, which I seem to do quite often! I’m sure the novelty will wear off, but I am enjoying it!

The keyboard layout, as you would expect is well suited for the Linux geek and I find it such a joy to use.

I have been only using the laptop this past week, primarily because I am working from the house in the French countryside and not in my usual home office, so I have been spending a vast majority of the day with the laptop on my lap and lying on the couch coding. I have to say it’s been a pleasure, do in part that not only is the laptop super light and you hardly know that it’s there, but also because the screen is just so good on the eyes and a joy to use.

The mouse pad is great to use and I have found the feedback and quick response fantastic.

The coding experience

I know most Linux based developers will more than likely be Vim based but personally, I can’t stand Vim and primarily make use of Jet Brains IDE’s.

I have a Jetbrains All Products Subscription so I am able to install all of my favourite IDE’s tailored for the specific languages. So I have Rider, Webstorm, PHPStorm, Pycharm, DataGrip and RubyMine installed.

Lately, I have also been doing a lot of AI-based development so I have also installed Set up Anaconda, Jupyter Notebook, Tensorflow for Deep Learning and have also installed Docker for development purposes.

I also have PHP and the full Laravel development with vagrant and the virtual box environments.

Over the past week, I have been engaging in a typical weekly development routine, which this week has been primarily been focused on .net core Web API development, Vue.Js frontend development, .net core console application developments, Docker and Kubernetes, AWS lambda development and then a bit of continued AI learning etc.

It’s been an absolute pleasure using the laptop and I have been really pleased with just how quick it is. There just never seems to any lag and it has coped really well with the demands of multi-tasking and multi workspaces.

The Tech Experience

The Darter Pro laptop comes in an ultra-portable and thin chassis only 18mm in size and 1.6 kg in weight.

Under the hood, it’s powered by:

8th generation Intel Core i5 (8265U‹) or Intel Core i7 (8565U) processors
6/8MB cache, 4 cores, and 8 threads
Intel UHD Graphics 620 graphics card
up to 32GB Dual-Channel DDR4 2400MHz RAM
up to 2TB M.2 SATA or PCIe NVMe SSD storage.

The Linux laptop also features a beautiful 15.6-inch Matte IPS Full HD (1920×1080) displayâ€‹ and a multi-colour backlit keyboard with tactile feedback.

It also comes with all the ports you need, including USB 3.1 Type-C with Thunderbolt 3, USB 3.1 Type-A, HDMI, MiniDP, and Gigabit Ethernet. An SD card reader is also present and the laptop features next-generation Intel Wireless-AC and Bluetooth support.

Software developers need connectivity ports, the Darter Pro comes with as many as you need.

Battery

It is my opinion that Developers will always struggle with Battery charge on most laptops, especially if like me you are doing a lot of AI and cloud-based work. It takes a lot of energy and battery power to drive those compute cycles. However, I have been quite impressed with the battery power on the laptop because I have been able in average to get at least 5 straight hours on one charge while doing quite a lot of heavy based development work. So, on the whole, I have been impressed with it.

Potential Drawbacks

There are 1 or 2 issues with the laptop worth highlighting just in case others think that these are deal breakers for them or manage expectations.

The first one that springs to mind is the Sound. If you are accustomed to listening to music or participating in video conferences via your laptop then you might be disappointed by the on-board sound because even with the volume up full blast the sound is poor.

Personally, this is not that much of an issue. I mostly use my laptop for when I am mobile from the office and working in coffee shops etc, so I always tend to carry my Bluedio HT Turbine Wireless Bluetooth 4.1 Stereo Headphones with Mic and I am effortlessly able to connect my headphones via Bluetooth, so using Zoom, WhatsApp, Slack and Skype is no problem at all and it is how I would typically use them anyway.

The other is as I mentioned earlier, which mostly only pertains to UK users is that the Keyboard is US layout but this really hasn’t inconvenienced myself at all.

Summary

I am extremely happy with my System76 Darter Pro it really has brought the joy back into coding on the move. So much so I will probably be purposely frequenting coffee shops just as an excuse to use my Darter Pro. It’s going to make going back to my beloved Desktop computer a real drag.

In all likelihood, I am probably going to persuade "she who should be obeyed" that I really need a System76 Thielotoo!

If you haven’t already guessed I have probably become one of those annoying System76 Fan Boys!

DEV Community: Gary Woodfine

How to use the Strategy Pattern in C#

Simplified Implementation

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Software Design Patterns

Contents

Conclusion

The Mediator Pattern

The Mediator Pattern

Benefits of the Mediator Pattern

Why use the Mediator pattern

How does the Mediator pattern solve issues

Example of the mediator pattern using MediatR

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Software Design Patterns

Contents

Conclusion

The Adapter Pattern

Two types of Adapters

Class adapters

Object adapters

When to use the Adapter Pattern?

Simple Adapter pattern implementation

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Software Design Patterns

Contents

Conclusion

Singleton Design Pattern C# .net core

Creational Design Patterns

Implementing the Singleton Pattern

Common Characteristics of Singleton Pattern Implementations.

Singleton Pattern Implementation

Processes and Threads

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Software Design Patterns

Contents

Simple Singleton Pattern

Simple Thread Safe Singleton Implementation

Double check Lock Singleton Pattern

Almost Lazy Singleton Pattern

Full Lazy Implementation

Generic Lazy Implementation

Example Scenarios for Singleton Classes

The Prototype Design Pattern C# .net core

Creational Design Patterns

Real World Implementation of the Prototype Pattern

Prototype Pattern Implementation

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Software Design Patterns

Contents

Practical Implementation of Prototype Pattern

Applications for the Prototype Pattern

Advantages of the Prototype Design Pattern

Summary

The importance of side projects

What is a Side Project ?

How I use side projects

The path to continual learning and improvement

My latest side project

Summary

The Builder Pattern .net core

Advantages of the Builder Pattern

Builder Pattern in Unit tests

Example Builder Pattern

garywoodfine / software-design-patterns

C# Design Patterns Tutorial Sample Code

Software Design Patterns in C# and .net core

Software Design Patterns

Contents

Fluent Builder Pattern implementation