False Wall Creating Storage

The study - a sample EBC

Again and again I am asked if I can provide a complete example of EBC, which I will do that here.
However, I have to say beforehand that I thought at first that the coding is sufficient by Ralf (Ralf's EBC blog entries ) in order to identify the scope and benefits of the EBC. Since this is not so, I hereby make a first complete example available that were built on the basis of the first generation EBC and its Post from Christopher's ( Christophe review ) inspired.

The scenario

Christof described a board that calculates the gross value of an amount and then rounds the result to two decimal places. He was to bear in mind that a board contains an implicit logic in the wiring, resulting from the task. One could make the rounds before or after the calculation.
At this point I want to talk but no implicit or explicit logic in the board, but EBC present in a sample. I opted for the round after the calculation.

textual formulation of the components

quote from Christophe's post:
"Component A:
- calculating VAT from an input
- Input: any number
- Issue: Entry * value added tax rate (2% :-())

Part B:
- Task: Formatting the input
- Input: any numbers
- Issue: number with exactly 2 decimal places, if necessary suitably rounded

Both devices are connected to board "VAT" "

Graphic formulation - Wiring Diagram

This diagram shows the components and the interaction, ie the. Making the first requirement to calculate and then by rounding, dar.
I plead for a tool to have with the wiring is shown graphically, because this form of representation is much easier to understand than the underlying code.

The project

The Solution Project (Visual C # 2010 Express) I have to request such a way that is clear, where what happens. A project for the contracts, one for the implementation and one for the tests. So that it is running and can be tried once, I have not created a motherboard that instantiates the Tax Board and shall provide the parts.
Unfortunately I have to mix Concerns, because I have no further project for EBC is planned to open the framework, as a component, the numbers round, has now really looking to do with the calculation of gross value. But looking ahead I have the component and its carrying Contract de.ebc.Framework in the namespace for the event that it would later be such a framework.
The tests are still (!) Implemented with NUnit, but I prefer Behavior Driven Testing, and will probably get in the near future or NSpec MSpec back out of mothballs and then write all my tests with it. I find this kind of testing much easier to understand.

The Contracts

The Contracts define the components, that is not special, because now should be state of the art. The special feature of these contracts but the fact that no pins are defined and methods, functions and / or fields.
Good, the input pin is also a method, but that is the nature of the thing. In some way so the signal must be, the message will be introduced into the component. It must, however, a fundamental difference between the pins of a board and where the parts are made.
In some tests, I checked the readability of the code by using pin variations and found that the difference increases the readability.
here once a complete example using the method of Ralf;

  / / Variant 1 InPin  
  / / In Contract:  
    public interface IComponent   { 
  void  In_InMessage  ( TypeOfMessage message )  ;  
 }  
 
  / / The board  
  public   class  MyBoard  {
 
   private  Action  \u0026lt; TypeOfMessge >  _channelMethod ;  
 
  public  MyBoard  (  IComponent component) {   
  / / wiring on the board  
  this  .  _channelMethod  =   component.   In_InMessage  ;  
  ...  
 } 
  
  / / Board InPin  
  public void    In_BoardMessage  ( MessageType message )   { 
  this  .  _channnelMethod  ( message )  ;  
 }}  
   

This version I think While quite nice, but I did not find it particularly easy to read. Just the need for an extra box _channelMethod "came to pass in order to define the message to the first of the first component InPin me bulky. Other tools such as wire

classes that connect the pins have not please me. So I have found by trial and error the following variant of sufficiently good.

EBC Pins

1. namespace de.ebc.Framework
2. {
3. public delegate void InPin \u0026lt;TInput> (TInput inmessages);
4. public delegate void OutPin \u0026lt;TOut> (Tout outMessage);}

How these pins can be integrated into the code you see in the following codeing.

I start with the definition of the board, on which the two parts are connected. Two pins on the board are defined. One receives the message (In_CalcToGross) and the other returns the result (Out_Gross). Attention, here is the InPin as Field have been defined from the said above reason.

EBC IVatBoard Contract

1. namespace de.ebc.vatboard
3. {/ / / \u0026lt;summary>
4. / / / Defines a component that can handle VAT
5. / / / \u0026lt;/ summary>
6. public interface IVatBoard
7. {
8. / / / \u0026lt;summary>
9. / / / Computes the gross value of a number
10. /// </summary>
11.          /// <param name="netto"></param>
12.          InPin < Decimal > In_CalcToGross { get ; set ; }
13.  
14.          / / / \u0026lt;summary>
15. / / / Is the gross returns
16. / / / \u0026lt;/ summary>
17. event OutPin \u0026lt; Decimal > Out_Gross;
18. }}

The component that performs the calculation is defined by the interface IVatCalculator. Again, it is no surprise, because it describes only the required pins. However, a part of InPin not represented by a delegate, here again is a method used.

EBC IVatCalculator Contract

1. namespace de.ebc.vatboard
2. {
3. / / / \u0026lt;summary>
4. / / / Defines a component that calculates the gross value of a number
5. / / / \u0026lt;/ summary> public
6. interface IVatCalculator
7. {
8. / / / \u0026lt;summary>
9. / / / Berchnet the gross value of a number
10. ; / / / \u0026lt;/ summary>
11. / / / \u0026lt;param name="netValue"> \u0026lt;/ param>
12. void In_CalculateGross ( Decimal NetValue);
14. / / / \u0026lt;summary>
15. / / / Is the gross returns
16. / / / \u0026lt;/ summary>
17. event OutPin \u0026lt; Decimal > Out_Gross;
18. ;}}

Now even the definition of the component that takes the rounding of numbers, and you are ready Contracts. Note that this contract is not the namespace of the VatBoards is assigned (for reasons of Separation of Concerns).

EBC IRoundDecimals Contract

1. namespace de.ebc.Framework
3. {/ / / \u0026lt;summary>
4. can / / / Defines a component, round the numbers
5. / / / \u0026lt;/ summary>
6. ; public interface IRoundDecimals
7. {
8. / / / \u0026lt;summary>
9. / / / number rounded to two decimal
10. /// </summary>
11.          /// <param name="number"></param>
12.          void In_RoundingToTwoDecimals( Decimal number);
13.         
14.          / / / \u0026lt;summary>
15. / / / Returns the number rounded back
16. ; / / / \u0026lt;/ summary>
17. event OutPin \u0026lt; ; Decimal > Out_RoundedNumber;
18. }}

The Components (Parts and boards) What is to be expected, the components of the meat of the Contracts and it is waiting for us, again, no surprise.

First, the Board, which is home to the wiring.

EBC VatBoard

1. namespace de.ebc.vatboard.Components
2. {
3. public class VatBoard : IVatBoard
4.     {
5.          public VatBoard( IVatCalculator vatCalculator, IRoundDecimals numberRounder)
6.         {
7.              / / InPin the Board with the first component wiring
8. this In_CalcToGross = vatCalculator.In_CalculateGross;.
10. / / Result for rounding to the next component forward
11. vatCalculator.Out_Gross + = numberRounder.In_RoundingToTwoDecimals;
12. ;
13. / / round number return
14.             numberRounder.Out_RoundedNumber += this .OnOutRoundedNumber;
15.         }
16.  
17.          private void OnOutRoundedNumber( Decimal number) {
18.              this .Out_Gross(number);
19.         }
20.  
21.          public InPin < Decimal > In_CalcToGross {
22.              get ;
23.              set;}
26. public event OutPin \u0026lt; decimal> = Out_Gross delegate {};}
28. }

Here is visible, why I have a Delegeate InPin use, because I can now InPin connect the board directly with the InPin of the first component, no code noise.

Now just the two working components:

EBC VatCalculator

1. namespace de.ebc.vatboard.Components
2. {
3. public class VatCalculator : IVatCalculator
4. {
5. public VatCalculator ( decimal vatInPercent) {
6.              this .VatInPercent = vatInPercent;
7.         }
8.  
9.          public Decimal VatInPercent { get ; private set ; }
10.  
11.          public void In_CalculateGross( decimal netValue)
12.         {
13.              Decimal gross = GetGross(netValue);
14.              this .Out_Gross(gross);
15.         }
16.  
17.          private decimal GetGross( decimal netValue)
18.         {
19.              return netValue * (1 + VatInPercent / 100);
20.         }
21.  
22.          public event OutPin < decimal > Out_Gross = delegate { };
23.     }
24. }

und

EBC RoundDecimals

1. namespace de.ebc.vatboard.Components
2. {
3.      public class RoundDecimals : IRoundDecimals
4.     {
5.          public event OutPin < decimal > Out_RoundedNumber = delegate { };
6.  
7.          public void In_RoundingToTwoDecimals( decimal number)
8.         {
9.              decimal roundedNumber = RoundNumber(number);
10.              this .Out_RoundedNumber(roundedNumber);
11.         }
12.  
13.          private decimal RoundNumber( decimal number)
14.         {
15.              return Decimal Round (number, 2);.
16. }
17. }}

Yes, it can be refactored, I see it now, but for the example is not relevant now.

When I wrote the code well, it needs no further explanation of what happened here. And to determine this, I will make no further comment, because I hope for what the reader ;-)

The testing of the solution Testing is simple, because I can test each component individually through their paces. I could also try all the modules for the test and create. I have not done here.

As mentioned NUnit is used, what will I think change in the near future.

Testing of VatCalculator component is a fixed net value of 12 to send into the component into it, only to receive the gross value and evaluate.

testing VatCalculator

1. [ TestFixture ]
2. public class TestVatCalculator : WithVatCalculator
3. {
4.     [ Test ]
5.      public void Calculate_For_Number_12()
6.     {
7.          decimal netValue = 12;
8.          decimal vat = this .VatCalculator.VatInPercent;
9.          decimal shouldBrutto = (netValue * (1+vat/100));
10.  
11.          this .VatCalculator.Out_Gross += brutto =>
12.         {
13.              Assert AreEqual (should gross, gross).
14. };
16. ;. this VatCalculator.In_CalculateGross (NetValue);
17. }}

Yes well, it's not really the Brain Burner, but it illustrates the ease with which an EBC can be tested.

The second Component, the curvature component, we tested the same way.

testing RoundDecimals

1. [ TestFixture ]
2. public class TestRounding : WithRoundDecimals
3. {
4. [ Test ]
5. public void Round_To_Two_Decimals () {
7. ; decimal aNumber = 12.34567m;
8.          this .RoundDecimals.Out_RoundedNumber += roundedNumber =>
9.         {
10.              Assert .AreEqual(12.35m, roundedNumber);
11.         }; .
13. this RoundDecimals.In_RoundingToTwoDecimals (aNumber);}
15. }

The solution as an application

And how the whole thing looks in the application context?

I chose the example of the Console, which is not really about rachend and then the call to the following terms:

VatBoard as application

1. namespace de.ebc.VatMainBoard
2. {
3.      class Program
4.     {
5.          static void Main( string [] args)
6.         {
7.  
8.              Decimal vat = 16m;
9.  
10.              IVatCalculator vatCalculator = new VatCalculator (vat);
11.              IRoundDecimals numberRounder = new RoundDecimals ();
12.  
13.              IVatBoard vatBoard = new VatBoard (vatCalculator, rounder number);
15. / / Result output
16. vatBoard.Out_Gross + = large => {
17. Console .WriteLine(gross);
18.             };
19.  
20.              string netValueString = Console .ReadLine();
21.              Decimal netValue = 0;
22.  
23.              Decimal .TryParse(netValueString, out netValue);
24.             vatBoard.In_CalcToGross(netValue);
25.  
26.              Console ReadLine ();.
27. }
28. }}

And not lose many words because it is just an example and it should explain itself, otherwise I've just not written well.

The project can be downloaded from CodePlex at the following link EBC samples.

Well then ran times and forth with the comments.


Jan (ek)