strategy-pattern

When I first discovered the Strategy pattern, I was amazed of the seemingly endless possibilities it offered to me and my programs. I could better encapsulate my models' behaviour and even exchange this behaviour on the fly. But the strategy could also be used to to provide traits and payload to the containing object - data that was declared in a superclass. Life was fine. class MyMonsterAI { float const see_radius_; virtual void attack () = 0; /* .. */ }; class ElveAI { ElveAI() : see_radius_(150.0f) {} /* ... */ }; class CycloneAI { CycloneAI() : see_radius_(50.0f) {} /* ... */ }; class

What is the difference between Strategy pattern and Delegation pattern (not delegates)? the strategy pattern is a very specific design solution to a common software problem. the strategy pattern implies that there will be an interface called Strategy (or with Strategy as part of the name). this interface should have a method called execute(). one or more concrete classes called something like ConcreteStrategyA, ConcreteStrategyB, etc. that implement the Strategy interface. there should also be a context class that contains the Strategy delegation is more a principal than a pattern. delegation

I've looked at this explanation on Wikipedia , specifically the C++ sample, and fail to recognize the difference between just defining 3 classes, creating instances and calling them, and that example. What I saw was just placing two other classes into the process and cannot see where there would be a benefit. Now I'm sure I'm missing something obvious (wood for the trees) - could someone please explain it using a definitive real-world example? What I can make from the answers so far, it seems to me to be just a more complex way of doing this: have an abstract class: MoveAlong with a virtual

Can someone please explain to me what is the difference between the template method pattern and the strategy pattern is? As far as I can tell they are 99% the same - the only difference being that the template method pattern has an abstract class as the base class whereas the strategy class uses an interface that is implemented by each concrete strategy class. However, as far as the client is concerned they are consumed in exactly the same way - is this correct? thehouse The main difference between the two is when the concrete algorithm is chosen. With the Template method pattern this happens

I am having following application : 1) Mvc app : Hangfire client from where i will just enqueue jobs and host dashboard.This app will contains reference of my class library. 2) Console App : Hangfire server will live in this console application. 3) Class library : Shared library between hangfire server(Console app) and hangfire client(asp.net mvc) where my long running code will reside.Hangfire server will execute code of this library. I am having structure like below in Class library following strategy design pattern. Code taken from following : Reference: Interfaces: public interface