Skip to main content

Composite Pattern

A implementation of the composite pattern similar to a class that would be used for constructing a binary search tree.  Better, more detailed implementations are known as red-black or AVL trees.

Salient Characteristic(s)

  • Reduces complexity by treating objects consistently, as opposed to having different methods and properties for each collection
  • Any modification method of a collection would nbe the same as modifying the container
Code

namespace DesignPatterns
{
    /// <summary>
    /// An example of composite that might be used in a binary tree
    /// In this case, the tree node is composed of tree nodes
    /// Any modification method of a node, would be the same as modifying the node itself
    /// </summary>
    public class TreeNode 
    {
        private int _Value;
        public int Value
        {
            get { return _Value; }
            set { _Value = value; }
        }

        private TreeNode _Parent;
        public TreeNode Parent
        {
            get { return _Parent; }
            set { _Parent = value; }
        }
    
        private TreeNode _LeftNode;
        public TreeNode LeftNode
        {
            get { return _LeftNode; }
            set { _LeftNode = value; }
        }
    
        private TreeNode _RightNode;
        public TreeNode RightNode
        {
            get { return _RightNode; }
            set { _RightNode = value; }
        }

        public void Add(TreeNode node)
        {
            //stub for method to add node correctly
            //would also manage and rearrange its own nodes
        }

        public void Remove(TreeNode node)
        {
            //stub for removing node
            //also responsible for managing and rearranging nodes when removing
        }
    
        public TreeNode(int value)
        {
            _Value = value;
        }
    }
}

Popular posts from this blog

Multiton

A fairly simple example of the multiton pattern, with a private constructor, and a tracker for created objects, the name being an integer identifier.

Salient Chacteristic(s)
A private keyed list for tracking objectsA private constructorNamed objectsCode

using System.Collections.Generic;
using System.Linq;

namespace DesignPatterns
{
    public class Multiton
    {
        //read-only dictionary to track multitons
        private static IDictionary<int, Multiton> _Tracker = new Dictionary<int, Multiton> { };

        private Multiton()
        {
        }

        public static Multiton GetInstance(int key)
        {
            //value to return
            Multiton item = null;

            //lock collection to prevent changes during operation
            lock (_Tracker)
            { 
                //if value not found, create and add
                if(!_Tracker.TryGetValue(key, out item))
                {
                    item = new Multiton();

                    //calculate next key
       …

Decorator Pattern

This is an example of the Decorator pattern, in this case a decorator for ObservableCollection.  Working with WPF and ObservableCollection using threads, one will run into the problem whereby the ObservableCollection cannot be updated from outside the owning thread; Delegates and Invoke will not work. A solution is to contain and expand the class, as is done in this example on michIG's Blog.

This linked file contains the original code in C#, as well as the same code converted to VB.NET.

Salient Characteristic(s)
Sets an internal pointer to the decorated object, sending method calls and property actions to the internal objectExtends the object by wrapping it and adding some aspect handled by the decorator
Code

using System;
using System.Collections.ObjectModel;
using System.Windows.Threading;
using System.Collections.Specialized;
using System.ComponentModel;

namespace DesignPatterns
{
    /// <summary>  
    /// This class is an observablecollection which invokes automatically.  
    /// T…