How would you implement a “trait” design-pattern in C#?

by

You can get the syntax by using marker interfaces and extension methods.

Prerequisite: the interfaces need to define the contract which is later used by the extension method. Basically the interface defines the contract for being able to “implement” a trait; ideally the class where you add the interface should already have all members of the interface present so that no additional implementation is required.

public class Client {
  public double Weight { get; }

  public double Height { get; }
}

public interface TClientWeight {
  double Weight { get; }
}

public interface TClientHeight {
  double Height { get; }
}

public class ClientA: Client, TClientWeight { }

public class ClientB: Client, TClientHeight { }

public class ClientC: Client, TClientWeight, TClientHeight { }

public static class TClientWeightMethods {
  public static bool IsHeavierThan(this TClientWeight client, double weight) {
    return client.Weight > weight;
  }
  // add more methods as you see fit
}

public static class TClientHeightMethods {
  public static bool IsTallerThan(this TClientHeight client, double height) {
    return client.Height > height;
  }
  // add more methods as you see fit
}

Use like this:

var ca = new ClientA();
ca.IsHeavierThan(10); // OK
ca.IsTallerThan(10); // compiler error

Edit: The question was raised how additional data could be stored. This can also be addressed by doing some extra coding:

public interface IDynamicObject {
  bool TryGetAttribute(string key, out object value);
  void SetAttribute(string key, object value);
  // void RemoveAttribute(string key)
}

public class DynamicObject: IDynamicObject {
  private readonly Dictionary<string, object> data = new Dictionary<string, object>(StringComparer.Ordinal);

  bool IDynamicObject.TryGetAttribute(string key, out object value) {
    return data.TryGet(key, out value);
  }

  void IDynamicObject.SetAttribute(string key, object value) {
    data[key] = value;
  }
}

And then, the trait methods can add and retrieve data if the “trait interface” inherits from IDynamicObject:

public class Client: DynamicObject { /* implementation see above */ }

public interface TClientWeight, IDynamicObject {
  double Weight { get; }
}

public class ClientA: Client, TClientWeight { }

public static class TClientWeightMethods {
  public static bool HasWeightChanged(this TClientWeight client) {
    object oldWeight;
    bool result = client.TryGetAttribute("oldWeight", out oldWeight) && client.Weight.Equals(oldWeight);
    client.SetAttribute("oldWeight", client.Weight);
    return result;
  }
  // add more methods as you see fit
}

Note: by implementing IDynamicMetaObjectProvider as well the object would even allow to expose the dynamic data through the DLR, making the access to the additional properties transparent when used with the dynamic keyword.

More Related Contents:

  1. C# Singleton Form pattern, how to run 2 and more forms? [closed]
  2. Why and How to avoid Event Handler memory leaks?
  3. Why does C# not provide the C++ style ‘friend’ keyword? [closed]
  4. Unity singleton manager classes
  5. Thread Safe C# Singleton Pattern
  6. How to implement Generic Repository Design Pattern with Dapper?
  7. Double dispatch in C#?
  8. Instantiate an object with a runtime-determined type
  9. Model-View-Presenter in WinForms
  10. What’s a good threadsafe singleton generic template pattern in C#
  11. lock keyword in C#
  12. Refactoring code to avoid anti-pattern
  13. When should I choose inheritance over an interface when designing C# class libraries? [closed]
  14. Design pattern for handling multiple message types
  15. Implementing the Producer/Consumer Pattern in C#
  16. Multiple Aggregates / Repositories in one Transaction
  17. MVVM show new window from VM when seperated projects
  18. Are empty interfaces code smell? [closed]
  19. Raise Events in .NET on the main UI thread
  20. Entity Framework Specification Pattern Implementation
  21. DDD Approach to Access External Information
  22. A way of casting a base type to a derived type
  23. Repository Pattern Step by Step Explanation [closed]
  24. Default Interface Methods. What is deep meaningful difference now, between abstract class and interface?
  25. Default implementation in interface is not seen by the compiler?
  26. Entities VS Domain Models VS View Models
  27. Non-virtual interface design pattern in C#/C++
  28. View Models and dependency injection
  29. Singleton with parameters
  30. Best practices for multi-form applications to show and hide forms? [closed]

Leave a Comment