Other posts:

• Part I - Using a class

  • Part II - Making the class bet­ter

    • Part III - Using a struct
    • Part IV - A class with a spe­cial value In the last post we pre­sented a vari­a­tion of im­ple­ment­ing a value ob­ject us­ing a class. Everything works (obviously), but the amount of code to write is un­pleas­ing. In this post we ex­am­ine a li­brary based so­lu­tion. I just de­scribe how to use the Record class, not how it is im­ple­mented. You can read the at­tached im­ple­men­ta­tion code (it is in func­tional.cs). There is much more in there than Record<>. I’ll talk about the rest in a (hopefully) up­com­ing se­ries.

    To use the record class you need to in­herit from it, as in:

    public class DateSpan: Record<DateTime, DateTime, bool> {...}

    The generic ar­gu­ment types rep­re­sent the types that com­prise the (immutable) state of the ob­ject. You then need a friendly way for folks to ac­cess this state:

    public DateTime Start { get { return state.Item1; } }
    

  pub­lic DateTime End { get { re­turn state.Item2; } } pub­lic bool HasValue { get { re­turn state.Item3; } }

  This is all you have to do. You don't need to implement Equals, ==, != and GetHashCode. Structural equivalence is given to you by the Record class. Such a property is recursive, in the sense that you can embed value objects inside other value objects and the implementation would walk your object graph as necessary.
  
  For example, given the following class hierarchy:
  
  <pre class="code"><span style="color:rgb(0,0,255);">public</span> <span style="color:rgb(0,0,255);">class</span> <span style="color:rgb(43,145,175);">Order</span>: <span style="color:rgb(43,145,175);">Record</span>&lt;<span style="color:rgb(0,0,255);">string</span>, <span style="color:rgb(0,0,255);">int</span>&gt; {
  <span style="color:rgb(0,0,255);">public</span> Order(<span style="color:rgb(0,0,255);">string</span> item, <span style="color:rgb(0,0,255);">int</span> qty): <span style="color:rgb(0,0,255);">base</span>(item,qty) {}
  <span style="color:rgb(0,0,255);">public</span> <span style="color:rgb(0,0,255);">string</span> Item { <span style="color:rgb(0,0,255);">get</span> { <span style="color:rgb(0,0,255);">return</span> state.Item1;}}
  <span style="color:rgb(0,0,255);">public</span> <span style="color:rgb(0,0,255);">int</span> Quantity { <span style="color:rgb(0,0,255);">get</span> { <span style="color:rgb(0,0,255);">return</span> state.Item2; } }
  

  } pub­lic class Customer: Record<string, IEnumerable<Order>> { pub­lic Customer(string name, IEnumerable<Order> or­ders) : base(name, or­ders) { } pub­lic string Name { get { re­turn state.Item1; } } pub­lic IEnumerable<Order> Orders { get { re­turn state.Item2; } } }

  The following test case succeed:
  
  <pre class="code">[<span style="color:rgb(43,145,175);">TestMethod</span>]
  <span style="color:rgb(0,0,255);">public</span> <span style="color:rgb(0,0,255);">void</span> Record2Test() {
      <span style="color:rgb(0,0,255);">var</span> c1 = <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Customer</span>(<span style="color:rgb(163,21,21);">"Luca"</span>, <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>[] { <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>(<span style="color:rgb(163,21,21);">"car"</span>,1), <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>(<span style="color:rgb(163,21,21);">"stereo"</span>, 3)});
      <span style="color:rgb(0,0,255);">var</span> c11 = <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Customer</span>(<span style="color:rgb(163,21,21);">"Luca"</span>, <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>[] { <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>(<span style="color:rgb(163,21,21);">"car"</span>, 1), <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>(<span style="color:rgb(163,21,21);">"stereo"</span>, 3) });
      <span style="color:rgb(0,0,255);">var</span> c2 = <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Customer</span>(<span style="color:rgb(163,21,21);">"Bob"</span>, <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>[] { <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>(<span style="color:rgb(163,21,21);">"car"</span>, 1), <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>(<span style="color:rgb(163,21,21);">"stereo"</span>, 3) });
      <span style="color:rgb(0,0,255);">var</span> c3 = <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Customer</span>(<span style="color:rgb(163,21,21);">"Bob"</span>, <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>[] { <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>(<span style="color:rgb(163,21,21);">"car"</span>, 1), <span style="color:rgb(0,0,255);">new</span> <span style="color:rgb(43,145,175);">Order</span>(<span style="color:rgb(163,21,21);">"stereo"</span>, 2) });
      <span style="color:rgb(43,145,175);">Assert</span>.AreEqual(c1, c11);
      <span style="color:rgb(43,145,175);">Assert</span>.AreNotEqual(c1, c2);
      <span style="color:rgb(43,145,175);">Assert</span>.AreNotEqual(c1, c3);
      <span style="color:rgb(43,145,175);">Assert</span>.AreNotEqual(c2, c3);
  }</pre>
  
  Please don't take my library as production ready code. The amount of test I put into it is limited. You can probably find obvious bugs with it. 
  
  Let's look at other drawbacks. The biggest one is that I'm stealing your base class. If you want your value object to inherit from something else, you cannot. You cannot even have value objects inherit from each other. In that case you are back to implementing your own Equals, == and so on. The only tools at your disposal are interfaces and composition.
  
  Another drawback is that writing classes in this way is slightly unnatural. You have to think about the &#8216;type' of your state in the declaration of the class itself instead of more naturally writing it closer to where you assign names to it (property/field declaration).
  
  Having considered these drawbacks, I'm using this library in all my code wherever I need value objects (which is almost everywhere these days). Writing all the Equals explicitly is too error prone for my taste. I will also be creating IDE snippets for myself that make writing these classes easier.
  
  I don't think I have anything else to say on this topic, so this will be my last post on it. If something else comes up, I'll let you know.
  
  [TimeLineUsingRecord.zip](https://msdnshared.blob.core.windows.net/media/MSDNBlogsFS/prod.evol.blogs.msdn.com/CommunityServer.Components.PostAttachments/00/07/07/77/13/TimeLineUsingRecord.zip)