What's the best way to "decorate objects with functionality"?
I have provided an example below that allows a factory to package objects with functionality, but the problem isis that functionality is divorced from the object .
My ultimate goal is to support features like log and save and display that works on the specific properties that every other object has.
How would I keep the look and feel of this example, but include features like "save", which saves the object's data to the database, or "log", which records its activity?
using System;
using System.Collections.Generic;
namespace FuncAdorn3923
{
class Program
{
static void Main(string[] args)
{
Customer customer = new Customer();
ObjectFactory.Instance.AdornFunctionality(customer, "add");
Console.WriteLine(customer.CallAlgorithm("add", 64, 36));
Employee employee = new Employee();
ObjectFactory.Instance.AdornFunctionality(employee, "add");
ObjectFactory.Instance.AdornFunctionality(employee, "subtract");
Console.WriteLine(employee.CallAlgorithm("add", 5, 15));
Console.WriteLine(employee.CallAlgorithm("subtract", 66, 16));
Console.ReadLine();
}
}
public class ObjectFactory
{
private static ObjectFactory singleton;
public void AdornFunctionality(AdornedObject ao, string idCode)
{
Func<int, int, int> add = (i, j) => i + j;
Func<int, int, int> subtract = (i, j) => i - j;
switch (idCode)
{
case "add":
ao.LoadAlgorithm(idCode, add);
break;
case "subtract":
ao.LoadAlgorithm(idCode, subtract);
break;
}
}
public static ObjectFactory Instance
{
get
{
if (singleton == null)
singleton = new ObjectFactory();
return singleton;
}
}
}
public abstract class AdornedObject
{
private Dictionary<string, Func<int, int, int>> algorithms =
new Dictionary<string, Func<int, int, int>>();
public void LoadAlgorithm(string idCode, Func<int,int,int> func)
{
algorithms.Add(idCode, func);
}
public int CallAlgorithm(string idCode, int i1, int i2)
{
Func<int,int,int> func = algorithms[idCode];
return func.Invoke(i1, i2);
}
}
public class Customer : AdornedObject
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int NumberOfProductsBought { get; set; }
}
public class Employee : AdornedObject
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int Age { get; set; }
}
}
source to share
I personally would recommend a better design framework like the visitor template, but for something worth doing, you can do your code by dropping the type of security. Use Delegate
, not its derived classes, Func
and Action
:
static void Main(string[] args)
{
Customer customer = new Customer();
ObjectFactory.Instance.AdornFunctionality(customer, "add");
Console.WriteLine(customer.CallAlgorithm("add", 64, 36));
Employee employee = new Employee();
ObjectFactory.Instance.AdornFunctionality(employee, "add");
ObjectFactory.Instance.AdornFunctionality(employee, "subtract");
ObjectFactory.Instance.AdornFunctionality(employee, "save");
Console.WriteLine(employee.CallAlgorithm("add", 5, 15));
Console.WriteLine(employee.CallAlgorithm("subtract", 66, 16));
Console.WriteLine(employee.CallAlgorithm("save"));
Console.ReadLine();
}
}
public class ObjectFactory
{
private static ObjectFactory singleton;
public void AdornFunctionality(AdornedObject ao, string idCode)
{
Func<int, int, int> add = (i, j) => i + j;
Func<int, int, int> subtract = (i, j) => i - j;
Action save = () => Console.WriteLine("{0} has been saved", ao.ToString());
switch (idCode)
{
case "add":
ao.LoadAlgorithm(idCode, add);
break;
case "subtract":
ao.LoadAlgorithm(idCode, subtract);
break;
case "save":
ao.LoadAlgorithm(idCode, save);
break;
}
}
public static ObjectFactory Instance
{
get
{
if (singleton == null)
singleton = new ObjectFactory();
return singleton;
}
}
}
public abstract class AdornedObject
{
private Dictionary<string, Delegate> algorithms = new Dictionary<string, Delegate>();
public void LoadAlgorithm(string idCode, Delegate func)
{
algorithms.Add(idCode, func);
}
public object CallAlgorithm(string idCode, params object[] args)
{
Delegate func = algorithms[idCode];
return func.DynamicInvoke(args);
}
}
source to share
This looks like a classic case for a template.
Algorithms (visitors) should be adapted to the objects they decorate (or visit), or at least adapted to some interface that your decorated objects implement.
For example, your object Employee
might have the following method:
public class Employee: IEmployee {
public void Accept(IEmployeeAlgorithm algorithm) {
algorithm.Visit(this);
}
}
IEmployeeAlgorithm
objects would have an interface like this (they could easily be delegates Action<Employee>
or use other signatures as needed):
public interface IEmployeeAlgorithm {
void Visit(IEmployee employee);
}
Finally, if you want to give the keys of the algorithms and call them dynamically, you can do it the same way you do by storing them in an element IDictionary<string, IEmployeeAlgorithm>
.
source to share
I would take a look at the PostSharp project . They allow for this separation of concerns and allow you to do a few simple ways to do this. They allow you to externally define code that is added to classes / properties at runtime. I'm not sure about your specific requirements (or this particular example), but you should check it out.
source to share