Comments on: Violations Of The “Tell, Don’t Ask” and “Don’t Repeat Yourself” Principles?

By: Trystan Spangler

Trystan Spangler — Fri, 01 Feb 2013 22:09:00 +0000

Another possible solution is continuation passing style. Make your Handle method take an Action to use if it can handle the input and an Action for when it can't handle it. Sort of like success and failure callbacks. I can't say if it's better or not - but seems very Tell Don't Ask.

By: deltreme

deltreme — Fri, 01 Feb 2013 13:31:00 +0000

Anyone would use the same pattern for files:

if (File.Exists(path))
File.Open(path);

As you should depend on the exception File.Open() would otherwise throw. I quite like the TryXxx alternatives from .NET:

int number;
if (int.TryParse(str, out number))
…

By: crushcrush

crushcrush — Fri, 01 Feb 2013 13:28:00 +0000

I think the idea is to encapsulate the “CanHandle()” logic inside of the GetMessageBody() function. If CanHandle() would be false, then GetMessageBody() would simply return an empty string.

By: Peter

Peter — Tue, 08 Jun 2010 10:28:59 +0000

Hi!
Why not do the following..
public class handler {
IRequest _theRequest;
public bool can_handle(IRequest someRequest) {
/// figure out if it can handle then store someRequest locally.
// if you cannot handle this… return false .. else…
_theRequest = someRequest;
return true;
}

public void Handle(){ /*does what it needs to… */ }
public IResult Handle() { /*does what it needs to but returns a status result… */ }

}

public class consumerClass {

public void some_method() {

foreach ( var item_to_test in some_collection_of_handlers ){
if ( item_to_test.can_handle(some_request) {
item_to_test.Handle();
}
}

}
}

By: Henning Anderssen

Henning Anderssen — Sun, 06 Jun 2010 22:26:54 +0000

Why not use a event system, such as Udi Dahan’s domain events.

http://www.udidahan.com/2009/06/14/domain-events-salvation/

It the GetThatFromIt passes, you send a passed event, else you send a failed event.
Then you can chain events that does one thing. Requires a bit more infrastructure in place, but I think events can solve a lot of problems :)

By: Ian Cooper

Ian Cooper — Tue, 01 Jun 2010 12:22:07 +0000

To remove an if statement polymorphism is your friend. Generally the model is something like this:

1: Ask factory to give you a strategy for your criteria
2: Exercise strategy

So in pseudo-code:

1: public string GetMessageBody(string fileContents)

2: {

3: 4: foreach(IFileFormatReader formatReader in _formatReaders)

5: {

6: var messageReader = new MessageReaderFactory(fileContents)
7: messageBody += messageReader .GetMessageBody();

8: return messageBody;

9: }

Where a messageReader than cannot process the file contents simply returns an empty string. This latter part is really just a variation of the null object pattern.

By: Andrew Chisholm

Andrew Chisholm — Sun, 30 May 2010 13:02:37 +0000

Response seems similar to the Maybe monad. I’ve used this in some C# projects which results in cleaner code and the ability to daisy chain methods together (fluent style).

See http://abdullin.com/journal/2009/10/6/zen-development-practices-c-maybe-monad.html or http://weblogs.asp.net/zowens/archive/2009/09/04/maybe-monad-my-c-version.aspx for examples

By: Aaron Ransley

Aaron Ransley — Sun, 30 May 2010 06:35:15 +0000

@Bill Christie: I like your solution the most. Would lend the tightest syntax, so long as the FallbackAction wasn’t too involved.

By: Bill Christie

Bill Christie — Fri, 28 May 2010 13:11:51 +0000

Here is an alternative that is relatively simple to implement and can work well in certain situations.

public class TellDonTAskAlternative
{
public void DoGoodThings()
{
var response something.GetThatFromIt(anotherThing, () => FallbackAction());
}
}

By: James Gregory

James Gregory — Fri, 28 May 2010 09:42:02 +0000

For those people suggesting the Chain of Responsibility: “Do not use Chain of Responsibility when each request is only handled by one handler, or, when the client object knows which service object should handle the request.” -c2 wiki *

Derick’s code implies that a request will only be handled by one handler,as the messageBody variable is overwritten rather than appended to.

Annoyingly though, the c2 wiki doesn’t suggest alternatives for this situation.

* http://www.c2.com/cgi/wiki?ChainOfResponsibilityPattern