I think this entry has been in the pipeline for a couple of years now and today i have decided to finally post it I got frustrated with the annoying out parameter in TryGet methods so i decided to use a different signature using TryGetResult:

public class TryGetResult<T>
{
 public TryGetResult()
 {
  Success = false;
 }

 public TryGetResult(T result)
 {
  Success = true;
  Result = result;
 }

 public bool Success { get; private set; }
 public T Result { get; private set; }
}

And now your TryGet methods can have the following signature:

public TryGetResult<Person> TryGetPersonByName(string name)
{
 // person is not available
 if(name.IsInvalidPersonName()) return new TryGetResult(); 
 // return the person
 return new TryGetResult(new Person(name)); 
}

Yesterday a colleague of mine, Neil Robbins, asked me how a piece of code would look like if I apply the Hollywood principle on it (Don’t call us, we’ll cal you).

Let me start with setting the scene: The purpose of the code is to provide items via provider and to consume those items via a consumer.

Here is how my oldskool function signatures would look like:

class ItemProviderFactory {
 public ItemProvider Create() { .. }
}

class ItemProvider {
 public IEnumerable<Item> Provide() { .. }
}

class ItemConsumerFactory {
 public ItemConsumer Create() { .. }
}

class ItemConsumer {
 public void Consume(IEnumerable<Item> items) { .. }
}

My Hollywood style function signatures look like the following:

class ItemProviderFactory {
 public void WithItemProvider(Action<ItemProvider> action) { .. }
}

class ItemProvider {
 public void Provide(Action<IEnumerable<Item>> action) { .. }
}

class ItemConsumerFactory {
 public void WithItemConsumer(Action<ItemConsumer> action) { .. }
}

class ItemConsumer {
 public void Consume(IEnumerable<Item> items) { .. }
}

And now I am able compare the code that glues everything together:

void OldStyle(OldStyle.ItemProviderFactory itemProviderFactory, OldStyle.ItemConsumerFactory itemConsumerFactory) {
 var provider = itemProviderFactory.Create();
 var items = provider.Provide();
 var consumer = itemConsumerFactory.Create();
 consumer.Consume(items);
}

void HollywoodStyle(HollywoodStyle.ItemProviderFactory itemProviderFactory, HollywoodStyle.ItemConsumerFactory itemConsumerFactory) {
 itemProviderFactory.With(provider => 
  provider.Provide(items => 
    itemConsumerFactory.With(consumer 
      => consumer.Consume(items))));
}

Let me refactor this Hollywood code a bit:

// An itemconsumer consumes items as following:
Action<HollywoodStyle.ItemConsumer, IEnumerable<Item>> consumerAction = (consumer, items) => consumer.Consume(items);

// As soon as I have items, I want a consumer to consume them:
Action<IEnumerable<Item>> itemsAction = (items) => itemConsumerFactory.With(consumer => consumerAction(consumer, items));

// I can get items as following:
Action<HollywoodStyle.ItemProvider> providerAction = (provider) => provider.Provide(itemsAction);

// I can get an ItemProvider as following: 
itemProviderFactory.With(providerAction);

I think that most colleagues are quite thankful that i’m not a Hollywood star