Visitor Pattern - Revision history

Henon at 22:52, 21 November 2007

2007-11-21T22:52:48Z

← Older revision		Revision as of 22:52, 21 November 2007
Line 1:		Line 1:
	[[Category:CSharp]]		[[Category:CSharp]]
-		+	__NOTOC__
	<div style = "margin-left:100px; margin-right:200px;">		<div style = "margin-left:100px; margin-right:200px;">
	= Motivation for applying the Visitor Pattern (C#)=		= Motivation for applying the Visitor Pattern (C#)=
	Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.		Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.

-	=== Example ===	+	== Example ==
	<span><span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>A<span class="S0"> </span><span class="S10">{}</span><br />		<span><span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>A<span class="S0"> </span><span class="S10">{}</span><br />
	<span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>B<span class="S0"> </span><span class="S10">:</span><span class="S0"> </span>A<span class="S0"> </span><span class="S10">{}</span><br />		<span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>B<span class="S0"> </span><span class="S10">:</span><span class="S0"> </span>A<span class="S0"> </span><span class="S10">{}</span><br />

Henon: /* Motivation for applying the Visitor Pattern (C#) */

2007-11-21T22:51:38Z

Motivation for applying the Visitor Pattern (C#)

← Older revision		Revision as of 22:51, 21 November 2007
Line 2:		Line 2:

	<div style = "margin-left:100px; margin-right:200px;">		<div style = "margin-left:100px; margin-right:200px;">
-	== Motivation for applying the Visitor Pattern (C#)==	+	= Motivation for applying the Visitor Pattern (C#)=
	Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.		Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.

Henon: /* Motivation for applying the Visitor Pattern (C#) */

2007-11-21T13:20:09Z

Motivation for applying the Visitor Pattern (C#)

← Older revision		Revision as of 13:20, 21 November 2007
Line 1:		Line 1:
	[[Category:CSharp]]		[[Category:CSharp]]

		+	<div style = "margin-left:100px; margin-right:200px;">
	== Motivation for applying the Visitor Pattern (C#)==		== Motivation for applying the Visitor Pattern (C#)==
	Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.		Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.
Line 29:		Line 30:
	<span class="S10">}</span><br />		<span class="S10">}</span><br />
	<span class="S0"></span></span>		<span class="S0"></span></span>
		+	<div>

	== Applying the Visitor Pattern ==		== Applying the Visitor Pattern ==

Henon: /* Applying the Visitor Pattern */

2007-11-21T10:38:02Z

Applying the Visitor Pattern

← Older revision		Revision as of 10:38, 21 November 2007
Line 33:		Line 33:
	As you can imagine this naive implementation would become very complicated for a larger and deeper class hierarchies. It would be error prone and unmaintainable. Every time you add a new class to your hierarchy you would need to extend the dispatching logic in the Printer class.		As you can imagine this naive implementation would become very complicated for a larger and deeper class hierarchies. It would be error prone and unmaintainable. Every time you add a new class to your hierarchy you would need to extend the dispatching logic in the Printer class.

-	The '''Visitor Pattern [Gamma et al. 95]''' offers a better solution. It makes use of the polymorphic method dispatching functionality of object oriented programming languages effectively eliminating the error prone part of our naive implementation. The idea is to '''double dispatch''' the method call by asking each type to re-dispatch the call to Print accordingly. The drawback is that we have to extend our class hierarchy with boilerplate dispatching methods like this:	+	The '''Visitor Pattern [Gamma et al. 95]''' offers a better solution. It makes use of the polymorphic method dispatching functionality of object oriented programming languages (also called '''late binding''') effectively eliminating the error prone part of our naive implementation. The idea is to '''double dispatch''' the method call by asking each type to re-dispatch the call to Print accordingly. The drawback is that we have to extend our class hierarchy with boilerplate dispatching methods like this:

	<span><span class="S0"></span><br />		<span><span class="S0"></span><br />

Henon: /* The complete example program */

2007-11-21T10:16:18Z

The complete example program

← Older revision		Revision as of 10:16, 21 November 2007
Line 129:		Line 129:
	<span class="S10">}</span><br />		<span class="S10">}</span><br />
	<span class="S0"></span></span>		<span class="S0"></span></span>
		+
		+	--[[User:Henon\|Henon]] 11:16, 21 November 2007 (CET)

Henon: /* Applying the Visitor Pattern */

2007-11-21T09:59:15Z

Applying the Visitor Pattern

← Older revision		Revision as of 09:59, 21 November 2007
Line 42:		Line 42:
	<span class="S0"></span></span>		<span class="S0"></span></span>

-	These however are not complicated and thus less prone to errors. Of course the Visitor Pattern is prone to another type of error, namely, forgetting the dispatching method for some subtype in the hierarchy. See the following example program for the implementation of the Visitor Pattern.	+	These, however, are not complicated and thus less prone to errors. Of course the Visitor Pattern is prone to another type of error, namely, forgetting the dispatching method for some subtype in the hierarchy. See the following example program for the implementation of the Visitor Pattern.

	== The complete example program ==		== The complete example program ==

Henon: /* Motivation for applying the Visitor Pattern */

2007-11-21T09:45:00Z

Motivation for applying the Visitor Pattern

← Older revision		Revision as of 09:45, 21 November 2007
Line 1:		Line 1:
	[[Category:CSharp]]		[[Category:CSharp]]

-	== Motivation for applying the Visitor Pattern ==	+	== Motivation for applying the Visitor Pattern (C#)==
	Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.		Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.

Henon at 09:42, 21 November 2007

2007-11-21T09:42:07Z

← Older revision		Revision as of 09:42, 21 November 2007
Line 30:		Line 30:
	<span class="S0"></span></span>		<span class="S0"></span></span>

		+	== Applying the Visitor Pattern ==
	As you can imagine this naive implementation would become very complicated for a larger and deeper class hierarchies. It would be error prone and unmaintainable. Every time you add a new class to your hierarchy you would need to extend the dispatching logic in the Printer class.		As you can imagine this naive implementation would become very complicated for a larger and deeper class hierarchies. It would be error prone and unmaintainable. Every time you add a new class to your hierarchy you would need to extend the dispatching logic in the Printer class.

-	== ~~Applying~~ the Visitor Pattern ==	+	The '''Visitor Pattern [Gamma et al. 95]''' offers a better solution. It makes use of the polymorphic method dispatching functionality of object oriented programming languages effectively eliminating the error prone part of our naive implementation. The idea is to '''double dispatch''' the method call by asking each type to re-dispatch the call to Print accordingly. The drawback is that we have to extend our class hierarchy with boilerplate dispatching methods like this:
		+
		+	<span><span class="S0"></span><br />
		+	<span class="S0">    </span><span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>B<span class="S0"> </span><span class="S10">:</span><span class="S0"> </span>A<br />
		+	<span class="S0">    </span><span class="S10">{</span><br />
		+	<span class="S0">        </span><span class="S5">public</span><span class="S0"> </span><span class="S5">override</span><span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>Print<span class="S10">(</span>VisitorPattern<span class="S10">.</span>Printer<span class="S0"> </span>printer<span class="S10">)</span><span class="S0"> </span><span class="S10">{</span><span class="S0"> </span>printer<span class="S10">.</span>Print<span class="S10">(</span><span class="S5">this</span><span class="S10">);</span><span class="S0"> </span><span class="S10">}</span><span class="S0"> </span><span class="S2">// calls Print(B element)</span><br />
		+	<span class="S0">    </span><span class="S10">}</span><br />
		+	<span class="S0"></span></span>
		+
		+	These however are not complicated and thus less prone to errors. Of course the Visitor Pattern is prone to another type of error, namely, forgetting the dispatching method for some subtype in the hierarchy. See the following example program for the implementation of the Visitor Pattern.

	== The complete example program ==		== The complete example program ==

Henon: /* Example */

2007-11-21T09:24:09Z

Example

← Older revision		Revision as of 09:24, 21 November 2007
Line 30:		Line 30:
	<span class="S0"></span></span>		<span class="S0"></span></span>

-	As you can imagine this naive implementation would become very complicated for a larger and deeper class ~~hierarchy~~. It would be error prone and unmaintainable. Every time you add a new class to your hierarchy you would need to extend the dispatching logic in the Printer class.	+	As you can imagine this naive implementation would become very complicated for a larger and deeper class hierarchies. It would be error prone and unmaintainable. Every time you add a new class to your hierarchy you would need to extend the dispatching logic in the Printer class.

	== Applying the Visitor Pattern ==		== Applying the Visitor Pattern ==

Henon: /* Motivation for applying the Visitor Pattern */

2007-11-21T09:23:34Z

Motivation for applying the Visitor Pattern

← Older revision		Revision as of 09:23, 21 November 2007
Line 2:		Line 2:

	== Motivation for applying the Visitor Pattern ==		== Motivation for applying the Visitor Pattern ==
		+	Imagine you have a big class hierarchy and you are writing a sophisticated class that does something different for each type in the hierarchy. You cannot put the functionality into the respective classes for some reason. Here is a very simplified code example which demonstrates the situation and implements a naive solution.
		+
		+	=== Example ===
		+	<span><span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>A<span class="S0"> </span><span class="S10">{}</span><br />
		+	<span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>B<span class="S0"> </span><span class="S10">:</span><span class="S0"> </span>A<span class="S0"> </span><span class="S10">{}</span><br />
		+	<span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>C<span class="S0"> </span><span class="S10">:</span><span class="S0"> </span>B<span class="S0"> </span><span class="S10">{}</span><br />
		+	<br />
		+	<span class="S5">public</span><span class="S0"> </span><span class="S5">class</span><span class="S0"> </span>Printer<br />
		+	<span class="S10">{</span><br />
		+	<span class="S0">    </span><span class="S5">public</span><span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>Print<span class="S10">(</span>A<span class="S0"> </span>element<span class="S10">)</span><span class="S0"> </span><span class="S10">{</span><span class="S0"> </span>Console<span class="S10">.</span>WriteLine<span class="S10">(</span><span class="S6">"A"</span><span class="S10">);</span><span class="S0"> </span><span class="S10">}</span><br />
		+	<span class="S0">    </span><span class="S5">public</span><span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>Print<span class="S10">(</span>B<span class="S0"> </span>element<span class="S10">)</span><span class="S0"> </span><span class="S10">{</span><span class="S0"> </span>Console<span class="S10">.</span>WriteLine<span class="S10">(</span><span class="S6">"B"</span><span class="S10">);</span><span class="S0"> </span><span class="S10">}</span><br />
		+	<span class="S0">    </span><span class="S5">public</span><span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>Print<span class="S10">(</span>C<span class="S0"> </span>element<span class="S10">)</span><span class="S0"> </span><span class="S10">{</span><span class="S0"> </span>Console<span class="S10">.</span>WriteLine<span class="S10">(</span><span class="S6">"C"</span><span class="S10">);</span><span class="S0"> </span><span class="S10">}</span><br />
		+	<span class="S0">    </span><span class="S5">public</span><span class="S0"> </span><span class="S5">void</span><span class="S0"> </span>Print<span class="S10">(</span>A<span class="S10">[]</span><span class="S0"> </span>array<span class="S10">)</span><br />
		+	<span class="S0">    </span><span class="S10">{</span><br />
		+	<span class="S0">        </span><span class="S5">foreach</span><span class="S0"> </span><span class="S10">(</span>A<span class="S0"> </span>element<span class="S0"> </span><span class="S5">in</span><span class="S0"> </span>array<span class="S10">)</span><br />
		+	<span class="S0">        </span><span class="S10">{</span><br />
		+	<span class="S0">            </span><span class="S2">// here we reimplement polymorphic method dispatching!</span><br />
		+	<span class="S0">            </span><span class="S5">if</span><span class="S0"> </span><span class="S10">(</span>element<span class="S0"> </span><span class="S5">is</span><span class="S0"> </span>C<span class="S10">)</span><br />
		+	<span class="S0">                </span>Print<span class="S10">(</span>element<span class="S0"> </span><span class="S5">as</span><span class="S0"> </span>C<span class="S10">);</span><br />
		+	<span class="S0">            </span><span class="S5">else</span><span class="S0"> </span><span class="S5">if</span><span class="S0"> </span><span class="S10">(</span>element<span class="S0"> </span><span class="S5">is</span><span class="S0"> </span>B<span class="S10">)</span><br />
		+	<span class="S0">                </span>Print<span class="S10">(</span>element<span class="S0"> </span><span class="S5">as</span><span class="S0"> </span>B<span class="S10">);</span><br />
		+	<span class="S0">            </span><span class="S5">else</span><span class="S0"> </span><span class="S5">if</span><span class="S0"> </span><span class="S10">(</span>element<span class="S0"> </span><span class="S5">is</span><span class="S0"> </span>A<span class="S10">)</span><br />
		+	<span class="S0">                </span>Print<span class="S10">(</span>element<span class="S10">);</span><br />
		+	<span class="S0">        </span><span class="S10">}</span><br />
		+	<span class="S0">    </span><span class="S10">}</span><br />
		+	<span class="S10">}</span><br />
		+	<span class="S0"></span></span>
		+
		+	As you can imagine this naive implementation would become very complicated for a larger and deeper class hierarchy. It would be error prone and unmaintainable. Every time you add a new class to your hierarchy you would need to extend the dispatching logic in the Printer class.
		+
		+	== Applying the Visitor Pattern ==

	== The complete example program ==		== The complete example program ==