Usually the process is the other way around. Do not go looking for situations where to use design patterns, look for code that can be optimized. When you have code that you think is not structured correctly. try to find a design pattern that will solve the problem. 

Design patterns are meant to help you solve structural problems, do not go design your application just to be able to use design patterns.

Learn them and slowly you&#39;ll be able to reconize and figure out when to use them. Start with something simple as the singleton pattern :)

if you want to create one instance of an object and just ONE. You use the singleton pattern. Let&#39;s say you&#39;re making a program with an options object. You don&#39;t want several of those, that would be silly. Singleton makes sure that there will never be more than one. Singleton pattern is simple, used a lot, and really effective.



I completely agree with @Peter Rasmussen.

Design patterns provide general solution to commonly occurring design problem. 

I would like you to follow below approach. 

1. Understand intent of each pattern
2. Understand checklist or use case of each pattern
3. Think of solution to your problem and check if your solution falls into checklist of particular pattern
4. If not, simply ignore the design-patterns and write your own solution.

Useful links:

[sourcemaking][1] : Explains **intent**, **structure** and **checklist** beautifully in multiple languages including C++ and Java

[wikipedia][2] : Explains structure, UML diagram and working examples in multiple languages including C# and Java . 

 
***Check list*** and ***Rules of thumb*** in each [sourcemakding][1] design-pattern provides alram bell you are looking for. 


  [1]: https://sourcemaking.com/design_patterns
  [2]: https://en.wikipedia.org/wiki/Software_design_pattern

I would like to use Short Date named string format in WPF.

I tried something like:

    &lt;TextBlock Text=&quot;{Binding Date, StringFormat=&#39;Short Date&#39;}&quot; /&gt;

How to do this?



WPF Binding StringFormat Short Date String

I am designing a website (e.g. mywebsite.com) and this site loads font-face fonts from another site (say anothersite.com). I was having problems with the font face font loading in Firefox and I read on [this blog][1]: 

&gt; Firefox (which supports @font-face
&gt; from v3.5) does not allow cross-domain
&gt; fonts by default.  This means the font
&gt; must be served up from the same domain
&gt; (and sub-domain) unless you can add an
&gt; “Access-Control-Allow-Origin” header
&gt; to the font.

How can I set the Access-Control-Allow-Origin header to the font?

  [1]: http://geoff.evason.name/2010/05/03/cross-domain-workaround-for-font-face-and-firefox/

How to add an Access-Control-Allow-Origin header

I like design patterns very much, but I find it difficult to see when I can apply one. I have read a lot of websites where design patterns are explained. I do understand the most of them, but I find it difficult to recognize a pattern in my own situations.

So, that is why I ask this question. Are there any guidelines / alarm bells when to use which design pattern.

For example, if you are doing a switch statement to determine which object you need to create, you probably want to use the factory design pattern. So the switch statement in this case is a &#39;alarm bell&#39; to use the Factory pattern.

So, do you know more &#39;alarm bells&#39; to determine a design pattern?

When to use which design pattern?

I like design patterns very much, but I find it difficult to see when I can apply one. I have read a lot of websites where design patterns are explained. I do understand the most of them, but I find it difficult to recognize a pattern in my own situations.
So, that is why I ask this question. Are there any guidelines / alarm bells when to use which design pattern.
For example, if you are doing a switch statement to determine which object you need to create, you probably want to use the factory design pattern. So the switch statement in this case is a 'alarm bell' to use the Factory pattern.
So, do you know more 'alarm bells' to determine a design pattern?

I am getting XML from a web service.  Here is what the XML looks like:

    &lt;parent&gt;
        &lt;child&gt;
            Text
        &lt;/child&gt;
    &lt;/parent&gt;
    &lt;parent&gt;
        &lt;child&gt;
            &lt;grandchild&gt;
                Text
            &lt;/grandchild&gt;
            &lt;grandchild&gt;
                Text
            &lt;/grandchild&gt;
        &lt;/child&gt;
        &lt;child&gt;
            Text
        &lt;/child&gt;
    &lt;/parent&gt;
    
    etc.

And here is my C# code:

    StringBuilder output = new StringBuilder();
    
    // Create an XmlReader
    using (XmlReader reader = XmlReader.Create(new StringReader(xoResponse.@return)))
    {
        XmlWriterSettings ws = new XmlWriterSettings();
        //ws.Indent = true;
        using (XmlWriter writer = XmlWriter.Create(output, ws))
        {
            // Parse the file and display each of the nodes.
            while (reader.Read())
            {
                switch (reader.NodeType)
                {
                    case XmlNodeType.Element:
                        writer.WriteStartElement(reader.Name);
                        break;
                    case XmlNodeType.Text:
                        writer.WriteString(reader.Value);
                        break;
                    case XmlNodeType.XmlDeclaration:
                    case XmlNodeType.ProcessingInstruction:
                        writer.WriteProcessingInstruction(reader.Name, reader.Value);
                        break;
                    case XmlNodeType.Comment:
                        writer.WriteComment(reader.Value);
                        break;
                    case XmlNodeType.EndElement:
                        writer.WriteFullEndElement();
                        break;
                }
            }
        }
    }

I believe that the error is thrown on the second parent element.  How can I avoid this error?  Any help is greatly appreciated.![enter image description here](https://i.stack.imgur.com/rqIAW.jpg)

XML Error: There are multiple root elements

I&#39;m looking for some in depth end-to-end CQRS examples with a reasonable set of unit tests.

Also, if anyone knows of some CQRS screencasts as well it would be extremely handy.

I&#39;m already aware of these examples

 - [CQRS Info][1]
 - [Super Simple CQRS][2]


  [1]: http://dddcqrs.com/examples/
  [2]: http://codebetter.com/gregyoung/2010/08/31/super-simple-cqrs-example/

CQRS Examples and Screencasts

I love `string.IsNullOrEmpty` method. I&#39;d love to have something that would allow the same functionality for IEnumerable. Is there such? Maybe some collection helper class? The reason I am asking is that in `if` statements the code looks cluttered if the patter is `(mylist != null &amp;&amp; mylist.Any())`. It would be much cleaner to have `Foo.IsAny(myList)`. 

This post doesn&#39;t give that answer: https://stackoverflow.com/questions/3779817/ienumerable-is-empty.



How to check if IEnumerable is null or empty?

I have a list that contains a bunch of Points (with an X and Y component).

I want to get the Max X for all points in the list, like this:

    double max = pointList.Max(p=&gt; p.X);

The problem is when I have a null in the list instead of a point.  What would be the best way to get around this issue?

LINQ Max() with Nulls

I have a DateTime object `2/19/2011 12:00:00 AM`. I want to convert this object to a string `19/2/2011`. 

Please help me to convert DateTime to string format.

convert datetime to date format dd/mm/yyyy

In JSF MVC framework who is Model, View, and Controller?

What components are MVC in JSF MVC framework?

There&#39;s this one thing in C++ which has been making me feel uncomfortable for quite a long time, because I honestly don&#39;t know how to do it, even though it sounds simple:

**How do I implement Factory Method in C++ correctly?**
==

Goal: to make it possible to allow the client to instantiate some object using factory methods instead of the object&#39;s constructors, without unacceptable consequences and a performance hit. 

By &quot;Factory method pattern&quot;, I mean both static factory methods inside an object or methods defined in another class, or global functions. Just generally &quot;the concept of redirecting the normal way of instantiation of class X to anywhere else than the constructor&quot;.

Let me skim through some possible answers which I have thought of.


---
0) Don&#39;t make factories, make constructors.
----------------------------------------

This sounds nice (and indeed often the best solution), but is not a general remedy. First of all, there are cases when object construction is a task complex enough to justify its extraction to another class. But even putting that fact aside, even for simple objects using just constructors often won&#39;t do.

The simplest example I know is a 2-D Vector class. So simple, yet tricky. I want to be able to construct it both from both Cartesian and polar coordinates. Obviously, I cannot do:

    struct Vec2 {
        Vec2(float x, float y);
        Vec2(float angle, float magnitude); // not a valid overload!
        // ...
    };

My natural way of thinking is then:

    struct Vec2 {
        static Vec2 fromLinear(float x, float y);
        static Vec2 fromPolar(float angle, float magnitude);
        // ...
    };

Which, instead of constructors, leads me to usage of static factory methods... which essentially means that I&#39;m implementing the factory pattern, in some way (&quot;the class becomes its own factory&quot;). This looks nice (and would suit this particular case), but fails in some cases, which I&#39;m going to describe in point 2. Do read on.

*another case: trying to overload by two opaque typedefs of some API (such as GUIDs of unrelated domains, or a GUID and a bitfield), types semantically totally different (so - in theory - valid overloads) but which actually turn out to be the same thing - like unsigned ints or void pointers.*

---

1) The Java Way
---------------

Java has it simple, as we only have dynamic-allocated objects. Making a factory is as trivial as:

    class FooFactory {
        public Foo createFooInSomeWay() {
            // can be a static method as well,
            //  if we don&#39;t need the factory to provide its own object semantics
            //  and just serve as a group of methods
            return new Foo(some, args);
        }
    }

In C++, this translates to:

    class FooFactory {
    public:
        Foo* createFooInSomeWay() {
            return new Foo(some, args);
        }
    };

Cool? Often, indeed. But then- this forces the user to only use dynamic allocation. Static allocation is what makes C++ complex, but is also what often makes it powerful. Also, I believe that there exist some targets (keyword: embedded) which don&#39;t allow for dynamic allocation. And that doesn&#39;t imply that the users of those platforms like to write clean OOP.

Anyway, philosophy aside: In the general case, I don&#39;t want to force the users of the factory to be restrained to dynamic allocation.

------------------
2) Return-by-value
------------------

OK, so we know that 1) is cool when we want dynamic allocation. Why won&#39;t we add static allocation on top of that?

    class FooFactory {
    public:
        Foo* createFooInSomeWay() {
            return new Foo(some, args);
        }
        Foo createFooInSomeWay() {
            return Foo(some, args);
        }
    };

What? We can&#39;t overload by the return type? Oh, of course we can&#39;t. So let&#39;s change the method names to reflect that. And yes, I&#39;ve written the invalid code example above just to stress how much I dislike the need to change the method name, for example because we cannot implement a language-agnostic factory design properly now, since we have to change names - and every user of this code will need to remember that difference of the implementation from the specification.

    class FooFactory {
    public:
        Foo* createDynamicFooInSomeWay() {
            return new Foo(some, args);
        }
        Foo createFooObjectInSomeWay() {
            return Foo(some, args);
        }
    };

OK... there we have it. It&#39;s ugly, as we need to change the method name. It&#39;s imperfect, since we need to write the same code twice. But once done, it works. Right?

Well, usually. But sometimes it does not. When creating Foo, we actually depend on the compiler to do the return value optimisation for us, because the C++ standard is benevolent enough for the compiler vendors not to specify when will the object created in-place and when will it be copied when returning a temporary object by value in C++. So if Foo is expensive to copy, this approach is risky.

And what if Foo is not copiable at all? Well, doh. (*Note that in C++17 with guaranteed copy elision, not-being-copiable is no problem anymore for the code above*)

Conclusion: Making a factory by returning an object is indeed a solution for some cases (such as the 2-D vector previously mentioned), but still not a general replacement for constructors.

-------------------------
3) Two-phase construction
-------------------------

Another thing that someone would probably come up with is separating the issue of object allocation and its initialisation. This usually results in code like this:

    class Foo {
    public:
        Foo() {
            // empty or almost empty
        }
        // ...
    };

    class FooFactory {
    public:
        void createFooInSomeWay(Foo&amp; foo, some, args);
    };

    void clientCode() {
        Foo staticFoo;
        auto_ptr&lt;Foo&gt; dynamicFoo = new Foo();
        FooFactory factory;
        factory.createFooInSomeWay(&amp;staticFoo);
        factory.createFooInSomeWay(&amp;dynamicFoo.get());
        // ...
    }

One may think it works like a charm. The only price we pay for in our code...

Since I&#39;ve written all of this and left this as the last, I must dislike it too. :) Why?

First of all... I sincerely dislike the concept of two-phase construction and I feel guilty when I use it. If I design my objects with the assertion that &quot;if it exists, it is in valid state&quot;, I feel that my code is safer and less error-prone. I like it that way.

Having to drop that convention AND changing the design of my object just for the purpose of making factory of it is.. well,  unwieldy.

I know that the above won&#39;t convince many people, so let&#39;s me give some more solid arguments. Using two-phase construction, you cannot:

- initialise `const` or reference member variables,
- pass arguments to base class constructors and member object constructors.

And probably there could be some more drawbacks which I can&#39;t think of right now, and I don&#39;t even feel particularly obliged to since the above bullet points convince me already.
 
So: not even close to a good general solution for implementing a factory.

---


Conclusions:
------------

We want to have a way of object instantiation which would: 

- allow for uniform instantiation regardless of allocation,
- give different, meaningful names to construction methods (thus not relying on by-argument overloading),
- not introduce a significant performance hit and, preferably, a significant code bloat hit, especially at client side,
- be general, as in: possible to be introduced for any class.

I believe I have proven that the ways I have mentioned don&#39;t fulfil those requirements.

Any hints? Please provide me with a solution, I don&#39;t want to think that this language won&#39;t allow me to properly implement such a trivial concept.

How to implement the factory method pattern in C++ correctly

I want to have an instance of class registered when the class is defined.  Ideally the code below would do the trick.

    registry = {}
    
    def register( cls ):
       registry[cls.__name__] = cls() #problem here
       return cls
    
    @register
    class MyClass( Base ):
       def __init__(self):
          super( MyClass, self ).__init__() 

Unfortunately, this code generates the error `NameError: global name &#39;MyClass&#39; is not defined`.

What&#39;s going on is at the `#problem here` line I&#39;m trying to instantiate a `MyClass` but the decorator hasn&#39;t returned yet so it doesn&#39;t exist.

Is the someway around this using metaclasses or something?



How to auto register a class when it&#39;s defined

Is *facade* a class which contains a lot of other classes? 

What makes it a design pattern? To me, it is like a normal class. 

Can you explain to me this *Facade* pattern?

Content Type	Original Author	Original Content on Stackoverflow
Question	Martijn	View Question on Stackoverflow
Solution 1 - C#	Joep Killaars	View Answer on Stackoverflow
Solution 2 - C#	Peter Rasmussen	View Answer on Stackoverflow
Solution 3 - C#	Ravindra babu	View Answer on Stackoverflow

When to use which design pattern?

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

How to add an Access-Control-Allow-Origin header

WPF Binding StringFormat Short Date String

Attributions