06 Saturday Jul 2019
Posted in C#, Functional Programming
Idiomatic approach in C# is to use Generators (using yield) that produce an IEnumerable, but once can hand-toss a lazy sequence a.k.a Stream from first principles using Lambda. Here is an implementation.
04 Thursday Jul 2019
Posted in C#, Functional Programming
I found it helpful to add these extension methods on while doing Functional Programming in C#.
IEnumerableFuncPredicateIDictionaryLets start with IEnumerable extension methods. But before that, below are the usage examples of each of these extension APIs:
// Single-Valued
string [] names = { "Brahma", "Vishnu", "Mahesh" };
names
.Select(name => name.ToUpper())
.ForEach(Console.WriteLine);
// BRAHMA
// VISHNU
// MAHESH
//2-element-tuple
IList alphabets = new List { 'a', 'b' };
IList numbers = new List { 1, 2 };
IList combinations = new List();
foreach (var alphabet in alphabets) {
foreach (var number in numbers) {
combinations.Add((alphabet, number));
}
}
combinations
.ForEach((a, n) => Console.WriteLine($"({a}, {n})"));
// (a, 1)
// (a, 2)
// (b, 1)
// (b, 2)
var result = "all mimsy were the borogoves and the momeraths"
.Split(" ")
.Peek(word => Console.WriteLine($"Where({word})"))
.Where(word => word.Length < 4)
.Peek(word => Console.WriteLine($"Select({word})"))
.Select(word => word.ToUpper())
.Aggregate("", (acc, elem) => acc + " " + elem)
.Trim();
// Where(all)
// Select(all)
// Where(mimsy)
// Where(were)
// Where(the)
// Select(the)
// Where(borogoves)
// Where(and)
// Select(and)
// Where(the)
// Select(the)
// Where(momeraths)
Console.WriteLine(result); // ALL THE AND THE
// Using Iterate
bool IsPrime(int number) {
return IEnumerableExtensions.Iterate(2, x => x + 1)
.Take(number)
.Where(n => n number % n != 0);
}
Console.WriteLine(IsPrime(2)); // True
Console.WriteLine(IsPrime(3)); // True
Console.WriteLine(IsPrime(4)); // False
// Using Generate
string Captcha(int howMany) {
var random = new Random();
return IEnumerableExtensions.Generate(() => random.Next(65, 123))
.Where(integer => Char.IsLetter((char)integer))
.Select(integer => (char)integer)
.Take(howMany)
.Aggregate(new StringBuilder(), (acc, elem) => acc.Append(elem))
.ToString();
}
Console.WriteLine(Captcha(4)); //RVkn, Ccmo etc... each run produces different output.
// Using Scan to print Running Sum
new List { 1, 2, 3, 4 }
.Scan(0, (acc, elem) => acc + elem)
.ForEach(Console.WriteLine);
// 1
// 3
// 6
// 10
var (first, second, third, rest) = new List { 1, 2, 3, 4 };
Console.WriteLine($"First = {first}"); // 1
Console.WriteLine($"Second = {second}"); // 2
Console.WriteLine($"Third = {third}"); // 3
Console.WriteLine($"Rest = {rest}"); // IEnumerable of remaining elements.
var people = new [] {
new { Name = "Eina", Age = 10 },
new { Name = "Mina", Age = 15 },
new { Name = "Dika", Age = 19 },
new { Name = "Tika", Age = 10 },
new { Name = "Maka", Age = 28 },
new { Name = "Naka", Age = 35 },
new { Name = "Saka", Age = 28 },
new { Name = "Taka", Age = 45 }
}.ToList();
Console.WriteLine("*** Eldest person ***");
Console.WriteLine(people.MaxBy(p => p.Age)); // { Name = Taka, Age = 45 }
Console.WriteLine("*** Youngest person ***");
Console.WriteLine(people.MinBy(p => p.Age)); // { Name = Eina, Age = 10 }
Finally, here is the IEnumerable extension class which implements all the above APIs.
static class IEnumerableExtensions {
// Doing Side-Effects
// Single-Valued
public static void ForEach<T>(this IEnumerable<T> @this, Action<T> action) {
if (@this == null)
throw new ArgumentNullException("Require non-null source!");
if (action == null)
throw new ArgumentNullException("Require non-null action!");
foreach (T item in @this) {
action(item);
}
}
// 2-element-tuple enumerable
public static void ForEach<T1, T2>(this IEnumerable<(T1, T2)> @this, Action<T1, T2> action) {
if (@this == null)
throw new ArgumentNullException("Require non-null source!");
if (action == null)
throw new ArgumentNullException("Require non-null action!");
foreach (var item in @this) {
action(item.Item1, item.Item2);
}
}
// Peek (but don't do side-effect)
public static IEnumerable<T> Peek<T>(this IEnumerable<T> @this, Action<T> action) {
IEnumerable<T> PeekedEnumerable() {
foreach (T item in @this) {
action(item);
yield return item;
}
}
if (@this == null)
throw new ArgumentNullException("Require non-null list!");
if (action == null)
throw new ArgumentNullException("Require non-null action!");
return PeekedEnumerable();
}
// Produce Infinite values using functions.
public static IEnumerable<T> Iterate<T>(T inital, Func<T, T> next) {
var nextValue = inital;
while(true) {
yield return nextValue;
nextValue = next(nextValue);
}
}
public static IEnumerable<T> Generate<T>(Func<T> generator) {
while(true) {
yield return generator();
}
}
// Deconstruction
public static void Deconstruct<T>(this IEnumerable<T> @this,
out T first, out IEnumerable<T> rest) {
if (@this == null) {
throw new ArgumentException("Collection cannot be null!");
}
first = @this.First();
rest = @this.Skip(1);
}
public static void Deconstruct<T>(this IEnumerable<T> @this,
out T first, out T second, out IEnumerable<T> rest) =>
(first, (second, rest)) = @this;
public static void Deconstruct<T>(this IEnumerable<T> @this,
out T first, out T second, out T third, out IEnumerable<T> rest) =>
(first, second, (third, rest)) = @this;
// Scanned Reduction
public static IEnumerable<U> Scan<T, U>(this IEnumerable<T> @this, U identity, Func<U, T, U> func) {
IEnumerable<U> ScannedEnumerable() {
var acc = identity;
foreach (var item in @this) {
acc = func(acc, item);
yield return acc;
}
}
return ScannedEnumerable();
}
// Minimum and Maximum by a key
public static T MinBy<T, Key>(this IEnumerable<T> @this, Func<T, Key> selector) {
if (@this == null)
throw new ArgumentNullException("Require non-null list!");
if (selector == null)
throw new ArgumentNullException("Require non-null selector!");
var minimum = @this.First();
var minKey = selector(minimum);
var comparer = Comparer<Key>.Default;
foreach (var item in @this) {
var currentKey = selector(item);
if (comparer.Compare(currentKey, minKey) < 0) {
minKey = currentKey;
minimum = item;
}
}
return minimum;
}
public static T MaxBy<T, Key>(this IEnumerable<T> @this, Func<T, Key> selector) {
if (@this == null)
throw new ArgumentNullException("Require non-null list!");
if (selector == null)
throw new ArgumentNullException("Require non-null selector!");
var maximum = @this.First();
var maxKey = selector(maximum);
var comparer = Comparer<Key>.Default;
foreach (var item in @this) {
var currentKey = selector(item);
if (comparer.Compare(currentKey, maxKey) > 0) {
maxKey = currentKey;
maximum = item;
}
}
return maximum;
}
}
Here are the examples of Function Composition and Currying.
Func<int, int> Square = x => x*x;
int Multiply(int x, int y) => x * y;
var uncurriedMultiply = new Func<int, int, int>(Multiply);
var multiplyCurried = uncurriedMultiply.Curry();
Console.Out.WriteLine($"multiplyCurried(2)(3) = {multiplyCurried(2)(3)}"); // 6
var uncurry = multiplyCurried.Uncurry();
Console.Out.WriteLine($"uncurry(2, 3) = {uncurry(2, 3)}"); // 6
// Express Twice in terms of multiplyCurried
int Twice(int x) => multiplyCurried(2)(x);
// Express Triple in terms of multiplyCurried
var thrice = multiplyCurried(3);
Func<int, int> Triple = x => thrice(x);
var st = Square.AndThen(Triple);
Console.Out.WriteLine($"st(2) = {st(2)}"); // 12
var ts = Square.Compose(Triple);
Console.Out.WriteLine($"ts(2) = {ts(2)}"); // 36
var twice = new Func<int, int>(Twice);
var ds = twice.AndThen(Square);
Console.Out.WriteLine($"ds(2) = {ds(2)}"); // 16
Now, lets look at the definitions of Function extension methods. All of them are Higher-Order functions.
public static class FuncExtensions {
// Compose functions using AndThen and Compose
public static Func<A, C> AndThen<A, B, C>(this Func<A, B> f1, Func<B, C> f2) =>
a => f2(f1(a));
public static Func<A, C> Compose<A, B, C>(this Func<B, C> f1, Func<A, B> f2) =>
a => f1(f2(a));
// Curry and Uncurry for 2-arg function
public static Func<A, Func<B, C>> Curry<A, B, C>(this Func<A, B, C> f) =>
a => b => f(a, b);
public static Func<A, B, C> Uncurry<A, B, C>(this Func<A, Func<B, C>> f) =>
(a, b) => f(a)(b);
}
Next, lets look at Predicate extension methods. These are on similar lines to the ones found in Java. Again, all of them are Higher-Order functions.
public static class PredicateExtensions {
public static Predicate<T> Not<T>(this Predicate<T> @this) {
if (@this == null)
throw new ArgumentNullException("Require non-null Predicate!");
return t => !@this(t);
}
public static Predicate<T> And<T>(this Predicate<T> @this, Predicate<T> that) {
if (@this == null || that == null)
throw new ArgumentNullException("Require non-null Predicate!");
return t => @this(t) && that(t);
}
public static Predicate<T> Or<T>(this Predicate<T> @this, Predicate<T> that) {
if (@this == null || that == null)
throw new ArgumentNullException("Require non-null Predicate!");
return t => @this(t) || that(t);
}
}
Next, lets look at IDictionary extension methods. It allows you to return a specified default value for a non-existent key in the dictionary. The two forms are:
In case you don’t have a return value, the third form GetValueOrThrow allows you to throw an exception. Again, these are on similar lines to the ones found in Java and Scala.
public static class IDictionaryExtensions {
public static V GetValueOrDefault<K, V>(this IDictionary<K, V> @this, K key, V defaultValue) {
if (@this == null)
throw new ArgumentNullException("Require non-null Dictionary!");
if (@this.ContainsKey(key))
return @this[key];
return defaultValue;
}
public static V GetValueOrDefault<K, V>(this IDictionary<K, V> @this, K key, Func<V> defaultValueSupplier) {
if (@this == null)
throw new ArgumentNullException("Require non-null Dictionary!");
if (@this.ContainsKey(key))
return @this[key];
return defaultValueSupplier();
}
public static V GetValueOrThrow<K, V, E>(this IDictionary<K, V> @this, K key, E exception)
where E : Exception {
if (@this == null)
throw new ArgumentNullException("Require non-null Dictionary!");
if (@this.ContainsKey(key))
return @this[key];
throw exception;
}
}
Hope you find these useful in your day-to-day work!
06 Wednesday Feb 2019
Posted in APL, C#, Clojure, Code Jugalbandi, JavaScript, Scala
This time at Functional Conf 2018, Morten Kromberg, CXO of Dyalog Ltd., Ravindra Jaju and myself presented CodeJugalbandi again. The theme was about exploring concurrency. Conversations between the three artists can be viewed by clicking the links below, or you can simple watch the embedded Youtube video herein.
| Melody Name | Languages Used | Examples |
|---|---|---|
| Concurrency and Parallelism | Java and APL |
|
| FP to the Rescue (Etymology of structure of code) | Scala, C#, Clojure, APL and JavaScript | Gathering Weather and Nearby Places Information |
| Everything is an Event (Pushing Multiple Values) | Reactive Extensions (Java) and Clojure CSP (Core-Async) | Portfolio networth using Streaming Stock prices |
At the conference, we could demo only first two melodies (see below for the video), The Github Repo has all the melodies mentioned herein.
Slides are simply an index to the melodies.
Note: Further work is in progress on creating other melodies under the theme Exploring Concurrency Codejugalbandi – Mutability, STM and the Actor Model.
12 Saturday May 2012
Posted in C#
In this second installment of the useful abstractions based on the earlier post, I’ll discuss about the WindowBuilder. There were quite a few scenarios where we wanted to pop-up a new window from the application, say for example, pop-up a Trade Ticket (in Read-Only as well as in Editable mode), the second is to pop-up an Exception Window when something goes wrong while processing, the third to display the main application window itself and so on… As this is a small application, we did not use Prism (for large applications, Prism is the way to go) for layouting, showing and hiding views etc…
This is how I expect the WindowBuilder to be invoked from Displayer
public class Displayer : IDisplayer
{
private readonly IBinder binder;
public Displayer(IBinder binder)
{
this.binder = binder;
}
public void OpenTradeTicket(Instrument instrument, Side side, int quantity, bool asReadOnly)
{
new WindowBuilder<TradeTicket, TradeTicketViewModel>(binder)
.Bind(vm => vm.InstrumentCode, instrument.Code)
.Bind(vm => vm.Side, side)
.Bind(vm => vm.Quantity, quantity)
.Bind(vm => vm.Price, instrument.Price)
.Bind(vm => vm.AsReadOnly, asReadOnly)
.Show();
}
}
Here is another usage example:
try
{
...
}
catch(Exception exception)
{
new WindowBuilder<ExceptionViewer, ExceptionViewerViewModel>(appCtx.Get<IBinder>())
.Bind(vm => vm.Message, exception.Message)
.Bind(vm => vm.Trace, exception.StackTrace)
.Bind(vm => vm.TraceVisibility, true)
.Show();
}
To achieve this, we evolved to this abstraction called the ViewBuilder, that builds the view and shows it on the screen.
public interface IViewBuilder<TView, TViewModel> where TView : Control
{
IViewBuilder<TView, TViewModel> Bind<TProperty>(Expression<Func<TViewModel, TProperty>> propertyOrField, TProperty data);
void Show();
}
Here is the concrete ViewBuilder that builds and displays window on the screen. It allows the user to bind the details on the Window before showing it on the screen. To achieve this, the WindowBuilder takes in a View and a ViewModel that that backs the view, populates the ViewModel proerties using the Binder from the earlier post and then finally tells the view to show itself.
public class WindowBuilder<TView, TViewModel> : IViewBuilder<TView, TViewModel> where TView : Window
{
private readonly IBinder binder;
private readonly TView view;
private readonly TViewModel viewModel;
public WindowBuilder(IBinder binder)
{
this.binder = binder;
viewModel = binder.Bind<TView, TViewModel>(ref view);
}
public IViewBuilder<TView, TViewModel> Bind<TProperty>(Expression<Func<TViewModel, TProperty>> propertyOrField, TProperty data)
{
binder.Bind(viewModel, propertyOrField, data);
return this;
}
public void Show()
{
view.Show();
}
}
23 Monday Apr 2012
Posted in C#
In this post, i’ll describe how we evolved to Binder abstraction, step-by-step and on the way talk about other useful abstractions that help alleviate the problem of coupling.
Trading System Scenario: On the Pricing Grid, each instrument receives prices updates, user can click on either Buy or Sell column for an instrument in the grid and it pops up a TradeTicket (a Window). This Trade ticket has few fields like the Instrument Code, Side, Price (that keeps updating as the instrument ticks), quantity (a user entered field) and finally a button to submit the trade.
Lets say, the TradeTicket view is defined by the XAML below and it is backed by TradeTicketViewModel.
<Window x:Class="TradingApplication.Views.TradeTicket"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Trade Ticket"
Name="tradeTicketWindow"
Height="285"
Width="300">
<Window.Resources>
<DataTemplate x:Key="ttvm" DataType="{x:Type ViewModels:TradeTicketViewModel}">
</DataTemplate>
</Window.Resources>
<Grid DataContext="{StaticResource ttvm}">
</Window>
Here is the TradeTicketViewModel class.
public class TradeTicketViewModel : Notifier
{
private readonly ITradingService tradingService;
private readonly InstrumentUpdateEvent instrumentUpdateEvent;
private Instrument instrument = Instrument.Empty;
private double price;
private Side side;
public TradeTicketViewModel(ITradingService tradingService, IEventAggregator eventHub)
{
this.tradingService = tradingService;
instrumentUpdateEvent = eventHub.GetEvent<InstrumentUpdateEvent>();
instrumentUpdateEvent.Subscribe(OnPriceUpdateReceived);
}
public bool AsReadOnly { get; set; }
public int Quantity { get; set; }
public string InstrumentCode { get; set; }
public Side Side { get; set; }
public double Price
{
get { return price; }
set
{
price = value;
RaisePropertyChanged("Price");
}
}
public ICommand SubmitTrade
{
get
{
return new RelayCommand(Execute, CanExecute);
}
}
public ICommand QuantityEntered
{
get
{
return new ValidationCommand(AssignValidQuantity);
}
}
private void AssignValidQuantity(object incomingQuantity)
{
int quantity;
var isValidQuantityType = int.TryParse(incomingQuantity.ToString(), out quantity);
var isValid = isValidQuantityType && IsValidQuantity(quantity);
if (isValid)
{
Quantity = quantity;
return;
}
}
private bool IsValidQuantity(int quantity)
{
return quantity > 0;
}
private bool CanExecute(object obj)
{
return IsValidQuantity(Quantity) && !AsReadOnly;
}
public void Execute(object obj)
{
var trade = new Trade(Side)
{
Price = Price,
Quantity = Quantity,
InstrumentCode = InstrumentCode
};
tradingService.Submit(trade);
}
private void OnPriceUpdateReceived(Instrument instrument)
{
if(AsReadOnly)
{
return;
}
if (insrument.Code.Equals(InstrumentCode))
{
this.instrument = instrument;
Price = GetPrice(instrument);
}
}
private double GetPrice(Instrument instrument)
{
return (side == Side.Buy) ? instrument.Bid : instrument.Ask;
}
}
Here is the Notifier implementation
public abstract class Notifier : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
protected void RaisePropertyChanged(string propertyName)
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
}
Please refer to this article on the MSDN site for RelayCommand. Here is the ValidationCommand Implementation:
public class ValidationCommand : ICommand
{
private readonly Action<object> callback;
public ValidationCommand(Action<object> callback)
{
this.callback = callback;
}
public void Execute(object parameter)
{
callback.Invoke(parameter);
}
public bool CanExecute(object parameter)
{
return true;
}
public event EventHandler CanExecuteChanged;
}
The XAML above will create the ViewModel instance at View Level. The Trading Service and Event Aggregator, lets say are Singleton-ish within the application and so the DataTemplate defined at the TradeTicket view level will not help much. Also, XAML requires a parameterless constructor on TradeTicketViewModel, but what we have is a parameterized constructor that takes in two collaborators
One option is to use the setter in the XAML. But good OO design principles tell us to inject the dependent collaborator without whom the object cannot function during object creation and not inject via setter. So, lets rule out the setter option.
So, the next option is to move the DataTemplate, at a higher level, say application level where we can access and set these collaborators. There are two ways in which this can be done. One is to define it inline within in the Application XAML and have that ViewModel available to the entire application.
<Application x:Class="TradingApplication"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Application.Resources>
<!-- This is will create the ViewModel instance at Application Level and not View Level -->
<DataTemplate x:Key="ttvm" DataType="{x:Type ViewModels:TradeTicketViewModel}" />
</Application.Resources>
</Application>
Another is to use the Resource Dictionary (this will be residing in a external file). This is also helpful when you want to share resources across applications (a rare re-use scenario for ViewModels atleast, for Styles, Themes its understandable). Resource Dictionary is a XAML based file and it will contain the above DataTemplate definition
<Application x:Class="TradingApplication"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Application.Resources>
<ResourceDictionary Source="filePath" />
</Application.Resources>
</Application>
However, Resource Dictionary is primarily intended to instantiate viewy stuff like Themes, Shaders etc… and not instantiate Models for Views (avoid mixing concerns). So, inside XAML, you really don’t want to:
So, Application XAML and Resource Dictionary are ruled out as well. What is another place where you could instantiate ViewModels? Lets take a look at the possibility of using the XAML Code Behind, where we can create the ViewModel and bind the Data Context. In there, one could do the following:
public partial class TradeTicket : Window
{
public TradeTicket()
{
InitializeComponent();
ITradingService tradingService = //Get Reference from somewhere
IEventAggregator eventHub = //Get Reference from somewhere
//Bind the DataContext here.
DataContext = new TradeTicketViewModel(tradingService, eventHub);
}
}
But, from a pure MVVM perspective, you really don’t want to see any non-View related stuff happening in the Code Behind. The only view-related stuff is, InitializeComponent(), whereas rest is creation of the ViewModel, getting references to the collaborators, injecting them in the ViewModel and finally binding to the DataContext.
So, we need to move this out from here, but where? It would be nice, if I have some abstraction like ApplicationContext and tell it to create a fresh instance of the ViewModel whenever required. It is the responsibility of the ApplicationContext to create and wire up the collaborators and dole out a fresh ViewModel instance when asked for. Here is how the above code would then look like:
public partial class TradeTicket : Window
{
public TradeTicket()
{
InitializeComponent();
//Bind the DataContext here.
DataContext = ApplicationContext.Instance.Get<TradeTicketViewModel>();
}
}
Here is the Application Context code. In my case, the ApplicationContext is based on Unity IoC, alternatively, you could use Spring.NET as your IoC container.
public class ApplicationContext
{
private readonly IUnityContainer unity;
private static readonly ApplicationContext instance = new ApplicationContext();
public static ApplicationContext Instance
{
get
{
return instance;
}
}
private ApplicationContext()
{
unity = new UnityContainer();
}
public void RegisterType<TType, TImpl>(Scope scope) where TImpl : TType
{
unity.RegisterType<TType, TImpl>(GetLifetimeManager(scope));
}
public void RegisterType<T>(Scope scope)
{
unity.RegisterType<T>(GetLifetimeManager(scope));
}
public void RegisterInstance<T>(T anObject, Scope scope)
{
unity.RegisterInstance(typeof(T), anObject, GetLifetimeManager(scope));
}
public void RegisterInstance<TType, TImpl>(TImpl anObject, Scope scope) where TImpl : TType
{
unity.RegisterInstance(typeof(TType), anObject, GetLifetimeManager(scope));
}
public TType Get<TType>()
{
return unity.Resolve<TType>();
}
public Dispatcher GetApplicationDispatcher()
{
return Application.Current.Dispatcher;
}
private LifetimeManager GetLifetimeManager(Scope scope)
{
switch (scope)
{
case Scope.Singleton:
return new ContainerControlledLifetimeManager();
case Scope.Prototype:
return new TransientLifetimeManager();
case Scope.Request:
return new PerThreadLifetimeManager();
}
throw new ArgumentException(string.Format("Undefined Lifetime Scope: {0}", scope));
}
}
ApplicationContext can be be instantiated at the Application level, in the application code behind. Take a look at the creation of ApplicationContext and registration of types with it.
public partial class TradingApplication : Application
{
private ApplicationContext appCtx;
public TradingApplication()
{
//Create Application Context Instance
appCtx = ApplicationContext.Instance;
}
protected override void OnStartup(StartupEventArgs e)
{
RegisterMainView();
RegisterInfraStructureServices();
RegisterViewModels();
RegisterViews();
}
private void RegisterMainView()
{
appCtx.RegisterType<MainView>(Scope.Singleton);
}
private void RegisterViewModels()
{
appCtx.RegisterType<TradeTicketViewModel>(Scope.Prototype);
}
private void RegisterViews()
{
appCtx.RegisterType<TradeTicket>(Scope.Prototype);
}
private void RegisterInfraStructureServices()
{
appCtx.RegisterType<IEventAggregator, EventAggregator>(Scope.Singleton);
appCtx.RegisterType<IBinder, ViewViewModelBinder>(Scope.Singleton);
appCtx.RegisterType<ITrader, Server.Trading.Service.Trader>(Scope.Singleton);
var tradingService = new TradingService(clientId, appCtx.Get<ITrader>());
appCtx.RegisterInstance(tradingService, Scope.Singleton);
}
}
So far so good, we have been able to move out the creation and wiring business to the ApplicationContext, we still have to get rid of the last line; binding to the DataContext.
Now, lets think how a user would perform a trade; pricing grid is the place where user will click on instrument row (either on the Bid or the Ask cell) and we should be able to pop-up a TradeTicket Window that is backed by the TradeTicketViewModel. The user then enters the quantity and hits Submit button to make a deal. For the user to do this effectively, we should show some of the instrument details on the ticket, that is, bind the row data, like the Instrument Code, Side and Price (current and continue to refresh updates) to the TradeTicket view’s DataContext to be displayed on the View.
Clearly there are many things involved here:
In the current context of discussion, two items are of importance to us, i.e., Bind required properties on to ViewModel and finally bind the View’s DataContext to the ViewModel. This calls for a role of Binder that can own that responsibility. Here is the what the Binder can do:
public interface IBinder
{
TViewModel Bind<TView, TViewModel>(ref TView view) where TView : FrameworkElement;
TViewModel Bind<TView, TViewModel>(TView view, TViewModel viewModel) where TView : FrameworkElement;
IBinder Bind<TTarget, TProperty>(TTarget target, Expression<Func<TTarget, TProperty>> propertyOrField, TProperty data);
}
Here is the concrete implementation of the Binder.
public class ViewViewModelBinder : IBinder
{
private readonly ApplicationContext appContext = ApplicationContext.Instance;
public TViewModel Bind<TView, TViewModel>(ref TView view) where TView : FrameworkElement
{
if (view == null)
{
view = appContext.Get<TView>();
}
var viewModel = appContext.Get<TViewModel>();
return Bind(view, viewModel);
}
public TViewModel Bind<TView, TViewModel>(TView view, TViewModel viewModel) where TView : FrameworkElement
{
view.DataContext = viewModel;
return viewModel;
}
public IBinder Bind<TTarget, TProperty>(TTarget target, Expression<Func<TTarget, TProperty>> propertyOrField, TProperty data)
{
SetPropertyOrFieldWithData(target, propertyOrField, data);
return this;
}
private void SetPropertyOrFieldWithData<T, TProperty>(T t, Expression<Func<T, TProperty>> propertyOrField, TProperty data)
{
var propertyExpression = propertyOrField.Body as MemberExpression;
if (propertyExpression == null)
{
throw new ArgumentException("Expecting Property or Field Expression of an object");
}
var targetExp = Expression.Parameter(typeof(T), "target");
var propertyExp = Expression.PropertyOrField(targetExp, propertyExpression.Member.Name);
var valueExp = Expression.Parameter(propertyExpression.Type, "value");
var assignExp = Expression.Assign(propertyExp, valueExp);
var expression = Expression.Lambda<Action<T, TProperty>>(assignExp, targetExp, valueExp);
var assignPropertyValueTo = expression.Compile();
assignPropertyValueTo(t, data);
}
}
Now, the Binder can be used it like this:
var binder =
new ViewViewModelBinder>TradeTicket, TradeTicketViewModel>()
.Bind(vm => vm.InstrumentCode, row.InstrumentCode)
.Bind(vm => vm.Side, row.Side)
.Bind(vm => vm.AsReadOnly, false);
By evolving this ViewViewModelBinder, we do not need any DataContext binding in the View now. Thus the, TradeTicket code behind will now be just reduced to
public partial class TradeTicket : Window
{
public TradeTicket()
{
InitializeComponent();
}
}
Phew! That was quite a long post, but it did not make sense to split it in to many. There are other interesting abstractions that I will cover in subsequent posts helping us retain the pure MVVM approach and not pollute the ViewModel with view-related concerns.
17 Saturday Mar 2012
Last week, at my current workplace, I did a demo session on C# for Java Developers. Here is the slide deck.
16 Friday Mar 2012
Posted in C#
I know this is a long post, but I think it just makes sense to put all the three in here. I have used the Linq Expressions to achieve the builders that would generate HashCode, build the String representation for an object and finally compare the two objects for equality based on the fields or properties that a user defines should participate during the creation of the Hashcode, the string representation and to determine the equality of the objects.
So, lets say I have a Money class and I want to be able to implement the Equals, GetHashCode and the ToString implementations for it as shown below:
public class Money
{
public string Currency { get; set; }
public double Amount { get; set; }
public override string ToString()
{
return new ToStringBuilder<Money>(this)
.Append(m => m.Currency)
.Append(m => m.Amount)
.ToString();
}
public override bool Equals(object that)
{
return new EqualsBuilder<Money>(this, that)
.With(m => m.Amount)
.With(m => m.Currency)
.Equals();
}
public override int GetHashCode()
{
return new HashCodeBuilder<Money>(this)
.With(m => m.Amount)
.With(m => m.Currency)
.HashCode;
}
}
In all the builders below, a common theme runs across – Accept the Linq Expression, Compile it so that it returns the delegate represented by the lambda and eventually invoke it by passing in the target object. The supplier of the delegate can return the appropriate value of the property or field on Type T, whose value would then be utilized for either equals comparison, or hashcode generation or to build the string representation of that object. Take a look at the EqualsBuilder below and its corresponding tests.
public class EqualsBuilder<T>
{
private readonly T left;
private readonly object right;
private bool areEqual = true;
public EqualsBuilder(T left, object right) {
this.left = left;
this.right = right;
if (ReferenceEquals(left, right))
{
areEqual = true;
return;
}
if (ReferenceEquals(left, null))
{
areEqual = false;
return;
}
if (ReferenceEquals(right, null))
{
areEqual = false;
return;
}
if (left.GetType() != right.GetType())
{
areEqual = false;
return;
}
}
public EqualsBuilder<T> With<TProperty>(Expression<Func<T, TProperty>> propertyOrField)
{
if (!areEqual)
{
return this;
}
if (left == null || right == null)
{
return this;
}
var expression = propertyOrField.Body as MemberExpression;
if (expression == null)
{
throw new ArgumentException("Expecting Property or Field Expression of an object");
}
Func<T, TProperty> func = propertyOrField.Compile();
TProperty leftValue = func(left);
TProperty rightValue = func((T)right);
if (leftValue == null && rightValue == null)
{
areEqual &= true;
return this;
}
if (leftValue != null && rightValue == null)
{
areEqual &= false;
return this;
}
if (leftValue == null && rightValue != null)
{
areEqual &= false;
return this;
}
areEqual &= leftValue.Equals(rightValue);
return this;
}
public bool Equals()
{
return areEqual;
}
}
Here is the specification that I used to Test-Drive the above implementation
using Assert = NUnit.Framework.Assert;
using Is = NUnit.Framework.Is;
using Specs = Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute;
using Specification = Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute;
using Moq;
[Specs]
public class EqualsBuilderSpecs
{
[Specification]
public void ItEvaluatesEqualPropertyValueOfAnObjectToTrue()
{
//Given
var left = new Money { Currency = "INR" };
var right = new Money { Currency = "INR" };
var builder = new EqualsBuilder<Money>(left, right);
//When
builder.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.True);
}
[Specification]
public void ItEvaluatesUnEqualPropertyValueOfAnObjectToFalse()
{
//Given
var left = new Money { Currency = "USD" };
var right = new Money { Currency = "INR" };
var builder = new EqualsBuilder<Money>(left, right);
//When
builder.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.False);
}
[Specification]
[ExpectedException(typeof(ArgumentException), "Expecting Property or Field Expression of an object")]
public void ItDoesNotEvaluateNonFieldsAndNonProperties()
{
//Given
var left = new Money { Currency = "USD" };
var right = new Money { Currency = "INR" };
var builder = new EqualsBuilder<Money>(left, right);
//When
builder.With(m => m.GetType());
}
[Specification]
public void ItEvaluatesEqualPropertiesOfAnObjectToTrue()
{
//Given
var left = new Money { Currency = "INR", Amount = 4 };
var right = new Money { Currency = "INR", Amount = 4 };
var builder = new EqualsBuilder<Money>(left, right);
//When
builder
.With(m => m.Currency)
.With(m => m.Amount);
//Then
Assert.That(builder.Equals(), Is.True);
}
[Specification]
public void ItEvaluatesUnEqualPropertyValuesOfAnObjectToFalse()
{
//Given
var left = new Money { Currency = "USD", Amount = 23 };
var right = new Money { Currency = "INR", Amount = 4 };
var builder = new EqualsBuilder<Money>(left, right);
//When
builder
.With(m => m.Currency)
.With(m => m.Amount);
//Then
Assert.That(builder.Equals(), Is.False);
}
[Specification]
public void ItShortCircuitsEqualsEvaluationWhenTheFirstPropertyEvaluatesToFalse()
{
//Given
var left = new Mock<Money>();
var right = new Mock<Money>();
left.SetupGet(m => m.Currency).Returns("INR");
left.SetupGet(m => m.Amount).Returns(4);
right.SetupGet(m => m.Currency).Returns("USD");
right.SetupGet(m => m.Amount).Returns(3);
//When
var builder = new EqualsBuilder<Money>(left.Object, right.Object)
.With(m => m.Currency)
.With(m => m.Amount);
//Then
Assert.That(builder.Equals(), Is.False);
left.VerifyGet(m => m.Currency);
right.VerifyGet(m => m.Currency);
left.VerifyGet(m => m.Amount, Times.Never());
right.VerifyGet(m => m.Amount, Times.Never());
}
[Specification]
public void ItEvaluatesNullComparisonsToTrue()
{
//Given
var left = new Money { Currency = null };
var right = new Money { Currency = null };
//When
var builder = new EqualsBuilder<Money>(left, right)
.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.True);
}
[Specification]
public void ItEvaluatesNullAndValidValueToFalse()
{
//Given
var left = new Money { Currency = null };
var right = new Money { Currency = "INR" };
//When
var builder = new EqualsBuilder<Money>(left, right)
.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.False);
}
[Specification]
public void ItEvaluatesValidValueAndNullToFalse()
{
//Given
var left = new Money { Currency = "INR" };
var right = new Money { Currency = null };
//When
var builder = new EqualsBuilder<Money>(left, right)
.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.False);
}
[Specification]
public void ItEquatesValidMoneyWithNullObjectAsFalse()
{
//Given
var left = new Money { Currency = "INR" };
object right = null;
//When
var builder = new EqualsBuilder<Money>(left, right)
.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.False);
}
[Specification]
public void ItEquatesNullMoneyWithValidMoneyAsFalse()
{
//Given
Money left = null;
var right = new Money { Currency = "INR" };
//When
var builder = new EqualsBuilder<Money>(left, right)
.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.False);
}
[Specification]
public void ItEquatesMoneyWithOtherTypeAsFalse()
{
//Given
Money left = new Money { Currency = "INR" };
var right = new { Length =20 };
//When
var builder = new EqualsBuilder<Money>(left, right)
.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.False);
}
[Specification]
public void ItEquatesNullMoniesAsTrue()
{
//Given
Money left = null;
Money right = null;
//When
var builder = new EqualsBuilder<Money>(left, right)
.With(m => m.Currency);
//Then
Assert.That(builder.Equals(), Is.True);
}
}
Here is the Hash code builder.
public class HashCodeBuilder<T>
{
private readonly T target;
private int hashCode = 17;
public HashCodeBuilder(T target)
{
this.target = target;
}
public HashCodeBuilder<T> With<TProperty>(Expression<Func<T, TProperty>> propertyOrField)
{
var expression = propertyOrField.Body as MemberExpression;
if (expression == null)
{
throw new ArgumentException("Expecting Property or Field Expression of an object");
}
var func = propertyOrField.Compile();
var value = func(target);
hashCode += 31 * hashCode + ((value == null) ? 0 : value.GetHashCode());
return this;
}
public int HashCode
{
get
{
return hashCode;
}
}
}
Here is the ToStringBuilder
public class ToStringBuilder<T>
{
private readonly T target;
private readonly string typeName;
private const string DELIMITER = "=";
private IList<string> values = new List<string>();
public ToStringBuilder(T target) {
this.target = target;
typeName = target.GetType().Name;
}
public ToStringBuilder<T> Append<TProperty>(Expression<Func<T, TProperty>> propertyOrField)
{
var expression = propertyOrField.Body as MemberExpression;
if (expression == null) {
throw new ArgumentException("Expecting Property or Field Expression");
}
var name = expression.Member.Name;
var func = propertyOrField.Compile();
var returnValue = func(target);
string value = (returnValue == null) ? "null" : returnValue.ToString();
values.Add(name + DELIMITER + value);
return this;
}
public override string ToString()
{
return typeName + ":{" + string.Join(",", values) + "}";
}
}
12 Monday Mar 2012
Posted in C#
Playing around with the new features of C# 4.0, I was able to put ExpandoObject and dynamic to some real use. Lets say we have this Xml configuration to parse and extract the node values and attributes value
<configuration>
<pageappearance remoteonly="true">
<color background="000000" foreground="FFFFFF"></color>
<border>Solid</border>
</pageappearance>
</configuration>
I would like to access the object that represents the Xml by traversing the nodes using the object graph traversal notation, some thing like the one show below
var configXml = "Solid"; XmlDocument document = new XmlDocument(); document.LoadXml(configXml); //See XmlDocumentExtension var config = document.ToObject(); Console.Out.WriteLine(config.PageAppearance.RemoteOnly); //true Console.Out.WriteLine(config.PageAppearance.Color.Foreground); //FFFFFF Console.Out.WriteLine(config.PageAppearance.Border);//Solid
So I ended up writing an XmlDocumentExtension class that does that
public static class XmlDocumentExtension
{
public static dynamic ToObject(this XmlDocument document)
{
XmlElement root = document.DocumentElement;
return ToObject(root, new ExpandoObject());
}
private static dynamic ToObject(XmlNode node, ExpandoObject config, int count = 1)
{
var parent = config as IDictionary<string, object>;
foreach (XmlAttribute nodeAttribute in node.Attributes)
{
var nodeAttrName = nodeAttribute.Name.Capitalize();
parent[nodeAttrName] = nodeAttribute.Value;
}
foreach (XmlNode nodeChild in node.ChildNodes)
{
if (IsTextOrCDataSection(nodeChild))
{
parent["Value"] = nodeChild.Value;
}
else
{
string nodeChildName = nodeChild.Name.Capitalize();
if (parent.ContainsKey(nodeChildName))
{
parent[nodeChildName + "_" + count] = ToObject(nodeChild, new ExpandoObject(), count++);
}
else
{
parent[nodeChildName] = ToObject(nodeChild, new ExpandoObject());
}
}
}
return config;
}
private static bool IsTextOrCDataSection(XmlNode node)
{
return node.Name == "#text" || node.Name == "#cdata-section";
}
}
The above can be easily used in a custom implementation of IConfigurationSectionHandler to parse the incoming section xml and convert it to a object graph for dot traversal, thus avoiding the need to write ConfigurationSection and ConfigurationElement implementations for section elements in App.config or Web.config
Any other scenario where you need to parse the incoming XML, say for example receiving an XML response from a Service or any messaging system, you can use the above XMLDocumentExtension and avoid creating abstractions that represent the XML document structure.
28 Tuesday Apr 2009
Posted in C#
NCover has gone commercial and I needed a replacement…googling for Open Source Code Coverage Tool in C# yielded PartCover. I integrated PartCover to calculate code coverage in our NAnt build. In summary, in this post, I have shown:
1. Using PartCover:
Unlike NCover, PartCover does not have a NAnt task, its easy to write one, but not when one is racing against time…so I ended up using the standard “exec” task to implement code coverage calculation as a part of the build. Below are set of targets that I created to incorporate PartCover:
<!-- Reports Artifacts Publish Directory -->
<property name="reports.dir.root" value="reports" overwrite="false" />
<!-- Index.html for all types of reports -->
<property name="index.file.name" value="index.html" overwrite="false" />
<target name="set.coverage.properties">
<!-- PartCover Related Properties -->
<property name="partcover.base.dir" value="${root.dir}/${src.dir.root}/ReferenceLibraries/PartCover-2.2" dynamic="true" />
<property name="partcover.exe" value="${partcover.base.dir}/PartCover.exe" dynamic="true"/>
<property name="partcover.report.xsl" value="${root.dir}/build-common/coverage/common-partcover-report.xslt" />
<property name="coverage.report.css.file.name" value="coverage-report.css" />
<property name="coverage.report.css.file" value="${root.dir}/build-common/coverage/${coverage.report.css.file.name}" />
<property name="coverage.result.file.prefix" value="CoverageResult-" overwrite="false" />
<property name="coverage.result.file" value="${coverage.result.file.prefix}${include.coverage.assembly}" dynamic="true" overwrite="true"/>
<property name="coverage.reports.dir.root" value="${reports.dir.root}/coverage" overwrite="false"/>
<property name="coverage.baseline" value="75" overwrite="false"/>
<!-- Assemblies for which a Test project wants to calculate coverage -->
<property name="include.coverage.assembly" value="*" overwrite="true" dynamic="true" />
</target>
<target name="calculate.coverage" depends="init" description="Calculate Code Coverage using PartCover" verbose="true">
<exec program="${partcover.exe}" workingdir="." failonerror="false">
<arg value="--target '${root.dir}${src.dir.root}ReferenceLibrariesNUnit-2.4.8nunit-console.exe'" />
<arg value="--target-work-dir '${root.dir}${src.dir.root}ReferenceLibrariesNUnit-2.4.8'"/>
<arg value="--target-args '../${module.bin.dir}/${project.output}'" />
<arg value="--include '[${include.coverage.assembly}]*'" />
<arg value="--exclude '[nunit*]*'" />
<arg value="--exclude '[log4net*]*'" />
<arg value="--exclude '[Iesi*]*'" />
<arg value="--exclude '[NHibernate*]*'" />
<arg value="--exclude '[Castle*]*'" />
<arg value="--exclude '[Rhino*]*'" />
<arg value="--exclude '[${module.prefix}.*Test*]*'" />
<arg value="--exclude '[${module.prefix}.*]*Test'" />
<arg value="--output '${module.bin.dir}/${coverage.result.file}.xml'" />
</exec>
</target>
2. Tweaking PartCover’s XSLTs:
PartCover, by default, generates coverage results in XML and we need to transform it to HTML using XSLT. Also, PartCover provides two levels of reports, one report is by assemblies and another by classes…however, it was more meaningful for us to see both these reports as one. So, I ended up creating another XSL:
coverage-report.css).
You can download all the stylesheets from here (please change the extension to .rar after download as Jroller does not allow rars pr zips to be uploaded) and place them inside build-common/coverage directory.
<target name="generate.coverage.report" depends="calculate.coverage" description="Prepare HTML Report by Assembly and Classes">
<tstamp property="coverage.report.generation.datetime" pattern="dd-MMM-yyyy HH:mm:ss" />
<style style="${partcover.report.xsl}" in="${module.bin.dir}/${coverage.result.file}.xml" out="${root.dir}${coverage.reports.dir.root}${coverage.result.file}.html">
<parameters>
<parameter name="assemblyName" value="${include.coverage.assembly}" />
<parameter name="moduleCompany" value="${module.company}" />
<parameter name="generatedOn" value="${coverage.report.generation.datetime}" />
<parameter name="coverageBaseline" value="${coverage.baseline}" />
</parameters>
</style>
</target>
3. Generating Coverage Summary Index Page:
Also, the way our project components are structured, we perform a top-level build (at solution level) and an individual component level build (at project level), we needed a way to summarize the coverage reports for all the components (as well as at component level => project level) when we do a top-level build. To that end, I ended up creating a index.html that would generate the summary report and serve as an entry point to drill-down to individual assemblies for detail coverage report by class within that assembly. Here is the NAnt target to achieve that (In reality, this task is present in a different build file, but I have shown this as inlined here).
<target name="generate.coverage.reports.index" depends="generate.coverage.report" description="Prepare Index.html for all coverage reports">
<copy file="${coverage.report.css.file}" todir="${root.dir}${coverage.reports.dir.root}" />
<property name="index.file" value="${root.dir}${coverage.reports.dir.root}${index.file.name}" dynamic="true" />
<echo file="${index.file}">
<![CDATA[
<html>
<head>
<title>[SOLUTION NAME] Coverage Reports</title>
<link rel="stylesheet" type="text/css" href="coverage-report.css" />
</head>
<body>
<h1><center>[SOLUTION NAME] Code Coverage Reports</center></h1>
<center>Generated on: ${coverage.report.generation.datetime} IST.</center>
<hr size="1"/>
<p>
This coverage report contains all code coverage statistics. Current Code Coverage Percentage Baseline is: <b>${coverage.baseline}%</b>. Code Coverage below this baseline is not acceptable.
<table>
<tr>
<th class="TableHeader">Legend</th>
</tr>
<tr>
<td class="cov0style">0%</td>
</tr>
<tr>
<td class="cov20style">0%-19%</td>
</tr>
<tr>
<td class="cov40style">20%-39%</td>
</tr>
<tr>
<td class="cov60style">40%-59%</td>
</tr>
<tr>
<td class="cov80style">60%-79%</td>
</tr>
<tr>
<td class="cov100style">80%-100%</td>
</tr>
</table>
</p>
<h2>Assemblies Summary</h2>
<table border="0" cellpadding="2" cellspacing="0" width="60%" style="border: #dcdcdc 1px solid;">
<tr class=TableHeader><td>Assembly Name</td><td>Coverage (%)</td></tr>
]]>
</echo>
<foreach item="File" in="${root.dir}${coverage.reports.dir.root}" property="fileNameWithPath">
<property name="fileNameWithExtn" value="${path::get-file-name(fileNameWithPath)}" />
<if test="${not (string::starts-with(fileNameWithExtn, index.file.name)
or string::starts-with(fileNameWithExtn, coverage.report.css.file.name))}">
<property name="fileName" value="${path::get-file-name-without-extension(fileNameWithPath)}" />
<property name="displayFileName" value="${string::replace(fileName, coverage.result.file.prefix, '')}" />
<loadfile file="${fileNameWithPath}" property="coverageFileContent" />
<property name="start.position" value="${string::index-of(coverageFileContent, '~~') + 2}" />
<property name="length" value="${string::last-index-of(coverageFileContent, '~~') - int::parse(start.position)}" />
<property name="assembly.coverage.percentage" value="${string::substring(coverageFileContent, start.position, length)}"/>
<echo file="${index.file}" append="true">
<![CDATA[
<tr></a></td>
<td><span class="
]]>
</echo>
<if test="${int::parse(assembly.coverage.percentage) == 0}">
<echo file="${index.file}" append="true">
<![CDATA[cov0style]]>
</echo>
</if>
<if test="${int::parse(assembly.coverage.percentage) >= 1 and (int::parse(assembly.coverage.percentage) < 20)}">
<echo file="${index.file}" append="true">
<![CDATA[cov20style]]>
</echo>
</if>
<if test="${int::parse(assembly.coverage.percentage) >= 20 and (int::parse(assembly.coverage.percentage) < 40)}">
<echo file="${index.file}" append="true">
<![CDATA[cov40style]]>
</echo>
</if>
<if test="${int::parse(assembly.coverage.percentage) >= 40 and (int::parse(assembly.coverage.percentage) < 60)}">
<echo file="${index.file}" append="true">
<![CDATA[cov60style]]>
</echo>
</if>
<if test="${int::parse(assembly.coverage.percentage) >= 60 and (int::parse(assembly.coverage.percentage) < 80)}">
<echo file="${index.file}" append="true">
<![CDATA[cov80style]]>
</echo>
</if>
<if test="${int::parse(assembly.coverage.percentage) >= 80 and (int::parse(assembly.coverage.percentage) <= 100)}">
<echo file="${index.file}" append="true">
<![CDATA[cov100style]]>
</echo>
</if>
<echo file="${index.file}" append="true">
<![CDATA[
" style="width:100%">${assembly.coverage.percentage}</span></td></tr>
]]>
</echo>
</if>
</foreach>
<echo file="${index.file}" append="true">
<![CDATA[
</table>
<hr size="1"/>
© ${module.company}
</body>
</html>
]]>
</echo>
</target>
4. Failing the Build:
Also, we want to fail the build when the coverage falls below a desired level. To that end, I created a simple target that would fail the build incase actual coverage was less than the expected coverage baseline.
27 Friday Mar 2009
Posted in C#
It would be difficult to find enterprise projects that do not talk to other systems (external or internal), unless yours is an application that is purely a sourcing system or is a system that is independently catering to a small audience or a department. On my current project, we are talking to other internal systems within the enterprise and need to store references to entities inside external systems within our system. To be more precise, this storing boils down to two cases:
In either of the above cases, at minimum, we need to store reference to that external entity. As we need to express external entity as a part of our model, we end up creating an abstraction for it in our system. We should note the following characteristics of such an external entity:
In an effort to make this distinction clear in the model, I extended the DDD Entities concept by classifying Entities as Internal Entity and External Entity.
A sample implementation of such a classification could be rendered with simple interface based static hierarchy or you could choose to use Annotations (in Java)/Attributes (in C#) to achieve this classification. Below is a sample implementation using marker interfaces and abstract classes in C#.
public interface Entity
{
}
InternalEntity or you can have an abstract class InternalEntity. Surrogate Id generation is taken care-of within this and so is identity based equality implementation.
// Any entity whose life-cycle is controlled by our project/module is an Internal Entity and hence we
// assign a surrogate Id to our entities and hence this is manifested as "id" field in this abstract class. All
// our internal entities will derive from this class.
public abstract class InternalEntity : Entity
{
private int id;
public virtual int Id
{
get { return id; }
private set { id = value; }
}
public override string ToString()
{
return GetType().Name + " Id = " + id;
}
public override bool Equals(object obj)
{
if (ReferenceEquals(obj, null))
{
return false;
}
if (ReferenceEquals(obj, this))
{
return true;
}
if (this.GetType() != typeof(obj))
{
return false;
}
InternalEntity that = (InternalEntity) obj;
return (Id == that.Id);
}
public override int GetHashCode()
{
return id.GetHashCode();
}
}
ExternalEntity. We cannot provide a common behavior as we do not know the primary keys that will uniquely identify this entity.
// Any entity whose life-cycle is not controlled within our module/project is an external entity for us.
// Hence, any reference that we need to store in our module/project for external entities should
// be assigned by the classes implementing this interface.
public interface ExternalEntity : Entity
{
}
Having applied this on my project, I found that this segregation has following positive side-effect:
