feed.xml

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Scott Hannen</title>
    <description>Scott Hannen is a software development consultant specializing in improving the quality of code.</description>
    <link>http://scotthannen.org/</link>
    <atom:link href="http://scotthannen.org/feed.xml" rel="self" type="application/rss+xml"/>
    <pubDate>Sun, 26 Jul 2020 12:26:20 -0400</pubDate>
    <lastBuildDate>Sun, 26 Jul 2020 12:26:20 -0400</lastBuildDate>
    <generator>Jekyll v3.8.5</generator>
    
      <item>
        <title>Sometimes It's Easier to Mock Without Moq</title>
        <description>&lt;p&gt;I like &lt;a href=&quot;https://github.com/Moq/moq4/wiki/Quickstart&quot;&gt;Moq&lt;/a&gt;. It’s easy to use and it’s used frequently enough
that developers are familiar with it. But sometimes there’s an even easier way to write tests, and that
involves creating classes that mock interfaces.&lt;/p&gt;

&lt;p&gt;As an example (I’ll try not to convolute this) suppose we have a class that&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;listens to messages from a queue&lt;/li&gt;
  &lt;li&gt;reads the contents of the message and converts it into a command&lt;/li&gt;
  &lt;li&gt;invokes a command handler&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I want to write a test to verify that given a message with specific contents,
the command sent to the command handler has the expected properties.&lt;/p&gt;

&lt;p&gt;Here’s what that test might look like using Moq:
)&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;na&quot;&gt;[TestMethod]&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;async&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;CommandHandlerInvokedWithCorrectCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;commandHandlerMock&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ICommandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DoSomethingCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&amp;gt;();&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;DoSomethingCommand&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;null&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;commandHandlerMock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Setup&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;HandleCommandAsync&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;It&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IsAny&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DoSomethingCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;()))&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Callback&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DoSomethingCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;command&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;command&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;subject&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;MessageListener&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;commandHandlerMock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Object&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;message&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;CreateMessage&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;X&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;subject&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ReceiveMessage&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;message&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;

    &lt;span class=&quot;n&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;IsTrue&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomeProperty&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;x&quot;&lt;/span&gt;
                  &lt;span class=&quot;p&quot;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomeOtherProperty&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In case you haven’t used this, here’s what we’re doing:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;Using Moq to create a &lt;code class=&quot;highlighter-rouge&quot;&gt;Mock&amp;lt;ICommandHandler&amp;lt;DoSomethingCommand&amp;gt;&amp;gt;&lt;/code&gt;&lt;/li&gt;
  &lt;li&gt;Setting up the mock so that when &lt;code class=&quot;highlighter-rouge&quot;&gt;HandleCommandAsync&lt;/code&gt; is called,
it executes a callback that assigns the &lt;code class=&quot;highlighter-rouge&quot;&gt;DoSomethingCommand&lt;/code&gt; parameter
passed to the command handler to the &lt;code class=&quot;highlighter-rouge&quot;&gt;handledCommand&lt;/code&gt; variable so that
we can inspect the command that was sent to the handler.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This isn’t bad. I’ve written it a bunch of times, and developers who’ve
used Moq know what it means. But can we make it a little simpler?
Judge for yourself.&lt;/p&gt;

&lt;p&gt;In the time it takes me to set up that mock, I can create this class:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;MockCommandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;T&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ICommandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;T&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;T&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;HandledCommand&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;set&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;async&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;HandleCommandAsync&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;T&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;command&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;HandledCommand&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;command&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;That took seconds. What does it do for the unit test?
I think it’s an improvement.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;na&quot;&gt;[TestMethod]&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;async&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;CommandHandlerInvokedWithCorrectCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;commandHandler&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;MockCommandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DoSomethingCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;subject&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;MessageListener&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;commandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;message&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;CreateMessage&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;X&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;subject&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ReceiveMessage&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;message&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;commandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;HandledCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;IsTrue&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomeProperty&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;x&quot;&lt;/span&gt;
                  &lt;span class=&quot;p&quot;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomeOtherProperty&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Isn’t that easier to read? It’s undeniably shorter. And I can reuse that
mock command handler in other tests. It also makes a difference if a
test necessarily sets up more dependencies. We want to keep our tests as
short and easy to read as possible.&lt;/p&gt;

&lt;h3 id=&quot;the-wall-of-moq&quot;&gt;The Wall of Moq&lt;/h3&gt;

&lt;p&gt;As a side note, sometimes if classes have too many dependencies we declare
a bunch of Moq mocks as private variables in our tests followed by lots of initialization code that
instantiates them and sets them up, and still individual tests have to do different setup for some of them.
All we see when we open the file is Moq.&lt;/p&gt;

&lt;p&gt;That’s not a Moq problem - it’s a problem with the classes we’re testing. They
have too many dependencies. Anyway, I don’t like it. I call it “the Wall of Moq.”
It makes tests difficult to read. We’ll see mocks set up with behaviors they don’t
need because no one can keep track of which ones are needed for any one test.
Once that happens we can no longer understand either the tests or the code
we’re testing.&lt;/p&gt;

&lt;h3 id=&quot;its-really-easy-with-delegates&quot;&gt;It’s Really Easy With Delegates&lt;/h3&gt;

&lt;p&gt;What if instead of an &lt;code class=&quot;highlighter-rouge&quot;&gt;ICommandHandler&amp;lt;T&amp;gt;&lt;/code&gt; interface we have a delegate,
and we inject that into our class? (More on that &lt;a href=&quot;/blog/2018/03/18/depending-on-functions-instead-of-interfaces.html&quot;&gt;here&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;If we inject this delegate into our message listener instead of an interface:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;delegate&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;CommandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;T&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;T&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;command&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;…then we can use a local method as our mock:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;na&quot;&gt;[TestMethod]&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;async&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;CommandHandlerInvokedWithCorrectCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;DoSomethingCommand&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;null&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;async&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;CommandHandlerMock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DoSomethingCommand&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;command&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;command&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;subject&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;MessageListener&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CommandHandlerMock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;message&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;CreateMessage&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;X&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;subject&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ReceiveMessage&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;message&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;IsTrue&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomeProperty&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;x&quot;&lt;/span&gt;
                  &lt;span class=&quot;p&quot;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;handledCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomeOtherProperty&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;==&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now we don’t have to declare a separate &lt;code class=&quot;highlighter-rouge&quot;&gt;MockCommandHandler&lt;/code&gt;, and
we can still declare and set up the mock in a single succint line.&lt;/p&gt;

&lt;p&gt;It’s not a huge difference, but these alternatives will save us some typing,
make it easier to reuse code in our tests, and keep our tests a little bit
easier to read. And if I’m just mocking a method that returns something
I’ll still use Moq.&lt;/p&gt;

</description>
        <pubDate>Fri, 10 Jul 2020 00:00:00 -0400</pubDate>
        <link>http://scotthannen.org/blog/2020/07/10/easier-to-mock-without-moq.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2020/07/10/easier-to-mock-without-moq.html</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>Pragmatism, Perfectionism, and Static Code Analysis</title>
        <description>&lt;p&gt;There are two extremes when it comes to the cleanliness and maintainability of code:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;I’m pragmatic. The most important thing is that it works. The other details don’t matter.&lt;/li&gt;
  &lt;li&gt;We should endlessly chase unattainable perfection.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&quot;pragmatism&quot;&gt;“Pragmatism”&lt;/h2&gt;
&lt;p&gt;Pragmatism is good, right? It means to value what is practical over what is theoretical. Unfortunately 
that word is often used to mean, “I do what makes sense to me and don’t waste time learning to improve.”
It amounts to taking whatever we don’t want to learn or do and labeling it “theoretical” so we 
can ignore it.&lt;/p&gt;

&lt;p&gt;That’s harsh, but I’ll go a step further. I’m going to guess that most developers who call themselves
“pragmatic” couldn’t define the word without looking it up. Be wary of anyone who justifies 
making messes for others to clean up by using a word they don’t understand.&lt;/p&gt;

&lt;h2 id=&quot;perfection&quot;&gt;Perfection&lt;/h2&gt;
&lt;p&gt;The other end of the spectrum recognizes that technical debt and defects don’t always result from large
decisions made badly. They’re caused by an accumulation of tiny choices that gradually make code harder
to understand, making changes difficult and defects more likely. Those developers scour over their own
code and that of others looking for variables with the wrong scope and interface segregation violations.&lt;/p&gt;

&lt;p&gt;While I’d rather lean toward the second group than the first, that pursuit of perfection is still
problematic. Why?&lt;/p&gt;

&lt;p&gt;Reviewing code to comment on every minute detail is time-consuming and introduces a long feedback cycle. 
It’s also subjective. One developer says a class is large and confusing. But how large is too large? Confusing
  to whom? Why?&lt;/p&gt;

&lt;p&gt;It’s also a miserable experience for everyone involved. Even if I agree in principle with adhering to 
exacting standards, I wouldn’t want to be on either side of that code review. I don’t want someone pointing 
out 20 minor issues to me, and then five more that I introduce by fixing those 20.&lt;/p&gt;

&lt;p&gt;The only thing worse is being the reviewer who finds and highlights those issues. I don’t know about
you, but I don’t have it in me to point out every single potential flaw I see, no matter how small.
Not even if I believe they matter.
I can’t sustain that for any period of time. Between the effort and my empathy for a fellow human developer
I’m going to relent, ignoring the small things and focusing on the big ones. And those small things
will accumulate. We may have empathy but our code doesn’t.&lt;/p&gt;

&lt;p&gt;That brings us back to pragmatism. Seeking code utopia by carefully reviewing to enforce standards may sound
like a good idea in theory, but it’s not practical. It’s going to take too long, we’ll start to hate ourselves
and each other, and we’ll end up cutting corners anyway.&lt;/p&gt;

&lt;h2 id=&quot;a-pragmatic-solution---static-code-analysis&quot;&gt;A Pragmatic Solution - Static Code Analysis&lt;/h2&gt;
&lt;p&gt;How do we make consistent adherence to standards less theoretical and more practical, and therefore pragmatic?&lt;/p&gt;

&lt;p&gt;What we need is feedback similar to what we get from the compiler when we make a type, omit a semicolon, 
don’t close our braces, etc. The compiler is ultra nitpicky. Very little gets past it. Such constant
negative feedback coming from a person would be unbearable, but coming from the compiler we don’t take it
personally, because it isn’t. Feedback comes quickly, not in a wave that hits us a day later. It helps us.
We rely on it and value it.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Static code analysis&lt;/em&gt; provides that feedback. After the code has compiled, a code analyzer applies another
set of rules to identify potential issues within our code, much like a human code reviewer might but with less pain.&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;An analyzer can evaluate in a minute what would take a reviewer hours to read and document. That means less
expenditure of time and a rapid feedback cycle.&lt;/li&gt;
  &lt;li&gt;Its evaluation is not subjective. Teams can tweak the rules as they see fit, but an analyzer applies those rules consistently.&lt;/li&gt;
  &lt;li&gt;It reduces the unpleasant human experience of correcting and being corrected.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Static code analysis doesn’t (or shouldn’t) eliminate code review. It just does a lot of the heavy lifting, pointing
out the small things so that we can focus on the architecture and behavior of code. And as it does so it finds issues 
we might not recognize otherwise. They are not robot overlords. If we understand what they are telling us and disagree. we
can and should tweak the rules or mute them.&lt;/p&gt;

&lt;h2 id=&quot;ndepend&quot;&gt;NDepend&lt;/h2&gt;

&lt;p&gt;At this point I’ll start referring to a particular product, &lt;a href=&quot;https://www.ndepend.com/&quot;&gt;NDepend&lt;/a&gt;. Full disclosure: I was given
a license to work with and evaluate, although not with any requirement that I advertise it or promote it. I’m not paid to
write this. I’m writing (a year later) because I’m convinced of the value of products like it and this one in particular.&lt;/p&gt;

&lt;h3 id=&quot;what-issues-does-it-identify&quot;&gt;What Issues Does It Identify?&lt;/h3&gt;
&lt;p&gt;There are &lt;a href=&quot;https://www.ndepend.com/docs/code-metrics&quot;&gt;many&lt;/a&gt;. I’ll highlight a few. 
They’re significant because any one of them can make code difficult to maintain
and increase the risk of defects. They’re also not easy for a person to spot when reviewing code:&lt;/p&gt;

&lt;h4 id=&quot;long-methods&quot;&gt;Long Methods&lt;/h4&gt;
&lt;p&gt;Limiting the lines of code per method is like setting a speed limit. Is 70mph really the perfect limit, and is 71mph too fast?
There’s no perfect one-size-fits-all number. But the idea isn’t that any number is perfect. Rather, if we set the limit at 70mph
then we won’t drive 120mph.&lt;/p&gt;

&lt;p&gt;The same goes for lines of code. My arbitary limit is fifteen per method. It’s not perfect, but if I stick to it and only rarely
violate it, it’s impossible to write a method with 100 lines. NDepend warns that 20 is difficult to understand and maintain
while 40 or more makes a method extremely complex. You can change those numbers. The tool doesn’t carve the rules in stone -
it helps to enforce what you and your team decide so you don’t have to count lines of code.&lt;/p&gt;

&lt;h4 id=&quot;classes-lacking-cohesion&quot;&gt;Classes Lacking Cohesion&lt;/h4&gt;
&lt;p&gt;Massive “god classes” create all sorts of pain and are difficult to break up. What if we could spot the first step toward
creating such a class and prevent it before it even begins to grow?&lt;/p&gt;

&lt;p&gt;NDepend and other methods look for cohesion in classes. Suppose a class has a method that depends on certain private fields,
and then we add another method that depends on different fields. Should that be one class? Why not put the one method with its
fields in one class and the other method with its fields in a different one? The more we add, the harder it becomes to see, 
and then it snowballs. Static analysis can catch that when it starts.&lt;/p&gt;

&lt;h4 id=&quot;cyclomatic-complexity&quot;&gt;Cyclomatic Complexity&lt;/h4&gt;
&lt;p&gt;While not a perfect measurement, it helps to identify classes and methods in which too many decisions are made. If a method
contains so many decisions that there are 20, 30, or more paths within its execution then it may be impossible for a developer
to read it and comprehend what it’s going to do in all of those scenarios or to write tests for them. 
Consider what that potentially means: We could write or modify code that we literally don’t understand.&lt;/p&gt;

&lt;p&gt;I’ve heard the objection that calculations of cyclomatic complexity vary. It’s true. Compare it to thermometer that might
be off by a degree. And while we’re at it, 98.6°F isn’t everyone’s perfect temperature. But if the thermometer says your
temperature is 107°F (and you’re still conscious) you don’t worry about that one degree of accuracy.&lt;/p&gt;

&lt;p&gt;That’s how I view all code metrics. They’re not magic numbers that tell us whether or not our code is perfect. They’re 
guidelines that tell us when we’re at or over the limit of what’s okay.&lt;/p&gt;

&lt;p&gt;Wouldn’t we want a code reviewer to say why the issues they point out matter? NDepend (and other analyzers) explain the signifance
of the rules. NDepend links to articles for further reading so that we can understand and evaluate for ourselves the principles that
underly its suggestions.&lt;/p&gt;

&lt;h2 id=&quot;conclusion&quot;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;Static code analysis helps us to strike the balance between fake pragmatism and unattainable perfection. It doesn’t ensure 
that we follow all of our standards and adhere to all of our principles, but it guides us in that direction. It’s harder to 
violate the Single Responsibility principle if we’re not creating giant, incohesive classes with a dozen public methods. It’s
harder to violate the Interface Segregation Principle if we limit the number of methods per interface. And then the chaos and
messiness that we prevent will make it easier for human reviewers to see what remains to improve.&lt;/p&gt;

&lt;p&gt;Does this sound like a sales pitch? I suppose it is. I want to work in code developed by people who use NDepend or something
like it because it’s going to be easier to understand and modify. I hate the feeling when I’ve introduce a defect and I
realize that in part it’s because the code was difficult to read, change, and test, but it was my change and I own it. It’s 
going to happen. I want less of it.&lt;/p&gt;

&lt;p&gt;What does it cost? Depending on the number of developers, $300-$400, more for a build server. That’s the cost of a few hours
of our time. That’s the cost of a single in-depth code review and a fraction of the cost of fixing a single defect (not counting)
the cost of the defect itself). It’s the cost of an extra few hours spent trying to understand code before we
change it.&lt;/p&gt;

&lt;p&gt;Reason on it this way: It’s paid software to do what a person does except faster and more reliably, which in turn saves
money and pays for itself. That’s not a sales pitch for NDepend - it’s a sales pitch for software. It’s the underlying reason
why computers and software exist. It’s beneficial for the same reason why whatever software we’re paid to write is beneficial.&lt;/p&gt;

&lt;p&gt;It’s genuine  pragmatism, and I believe that it’s an edge for developers and teams who use it.&lt;/p&gt;

</description>
        <pubDate>Mon, 06 Jul 2020 00:00:00 -0400</pubDate>
        <link>http://scotthannen.org/blog/2020/07/06/static-code-analysis.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2020/07/06/static-code-analysis.html</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>No, MediatR Didn't Run Over My Dog</title>
        <description>&lt;p&gt;I’m slightly concerned that this could be taken as some animus-driven screed against MediatR. 
But we’re using it wrong, and we’re using it wrong for the wrong reasons. 
Here’s the really short TL;DR version:&lt;/p&gt;

&lt;h2 id=&quot;tldr&quot;&gt;TL;DR&lt;/h2&gt;
&lt;p&gt;Injecting command handler abstractions into classes that depend on command handlers is good. 
Replacing that by injecting an &lt;code class=&quot;highlighter-rouge&quot;&gt;IMediator&lt;/code&gt; and sending commands to that is probably bad. 
The reasons given for using it are often meaningless.
We often use it to implement the service locator anti-pattern, not the mediator design pattern.&lt;/p&gt;

&lt;h2 id=&quot;illustrated&quot;&gt;Illustrated&lt;/h2&gt;

&lt;p&gt;This code depends on two abstractions, a command handler and a query handler. They are injected into the constructor.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DoesThings&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ICommandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DoThisCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;doThisHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IQueryHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomeQuery&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Data&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;someQueryHandler&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoesThings&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;ICommandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DoThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;doThisHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;ICommandHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DoThat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;doThatHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
	&lt;span class=&quot;k&quot;&gt;this&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;doThisHandler&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;doThisHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;this&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;someQueryHandler&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IQueryHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomeQuery&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Data&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;someQueryHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;async&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Task&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoSomething&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Input&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;input&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;/// ...create a DoThisCommand&lt;/span&gt;
       &lt;span class=&quot;k&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;doThisHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Handle&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;doThisCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Data&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GetData&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Input&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;input&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;/// ...create a SomeQuery&lt;/span&gt;
       &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;result&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;someQueryHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Handle&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;query&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;Replacing it with this code is detrimental, not beneficial:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DoesThings&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IMediator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoesThings&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IMediator&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mediator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
	&lt;span class=&quot;k&quot;&gt;this&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;mediator&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mediator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoSomething&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Input&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;input&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;/// ...create a DoThisCommand&lt;/span&gt;
       &lt;span class=&quot;n&quot;&gt;mediator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Send&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;doThisCommand&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Data&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GetData&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Input&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;input&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;/// ...create a SomeQuery&lt;/span&gt;
       &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;result&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mediator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Handle&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;query&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;For the rest of this post I’ll refer to “MediatR”, but to be clear I’m not referring to any and all use of MediatR. I’m referring specifically to replacing abstracted query and command handlers (the first example) with sending commands and queries through &lt;code class=&quot;highlighter-rouge&quot;&gt;IMediator&lt;/code&gt; (the second example).&lt;/p&gt;

&lt;h2 id=&quot;does-this-implement-the-mediator-pattern&quot;&gt;Does This Implement the Mediator Pattern?&lt;/h2&gt;
&lt;p&gt;Articles describing the mediator pattern describe it as:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;Simplifying complex interactions between objects&lt;/li&gt;
  &lt;li&gt;Reducing coupling by preventing objects from interacting directly with each other&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;When do we use this pattern? When interactions between objects have become too complex. For example:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;Performing some logical behavior requires setting a number of properties on another object&lt;/li&gt;
  &lt;li&gt;Groups of objects must interact with each other. A common illustration is taxi drivers communicating with each
other. Instead of each taxi driver knowing about every other taxi driver and sending messages to all of them, they
send messages to a dispatcher. Now each taxi driver has a simple relationship with the dispatcher instead of a
complex relationship with lots of taxi drivers.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;How does replacing command and query handlers with MediatR fit this pattern? It doesn’t.&lt;/p&gt;

&lt;p&gt;Injecting &lt;code class=&quot;highlighter-rouge&quot;&gt;IQueryHandler&amp;lt;FooQuery&amp;gt;&lt;/code&gt; into a class and calling its &lt;code class=&quot;highlighter-rouge&quot;&gt;Handle&lt;/code&gt; method is as simple as it gets. It is
absurd to replace&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;result&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;someQueryHandler&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Handle&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;query&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;with&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;result&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;await&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mediator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Handle&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;query&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;…and try to convince ourself or others that we have replaced a complex interaction with a simpler one.&lt;/p&gt;

&lt;p&gt;Does it reduce coupling? Not at all. Our class already depended on an abstraction. It was not coupled to any
implementation of the command or query handler. We can add decorators to the implementations if we need to. 
We can mock them in unit tests. Once we’ve accomplished that decoupling, adding another level of abstraction doesn’t make our code super-extra
200% decoupled. It’s just pointlessly “clever.”&lt;/p&gt;

&lt;p&gt;If injecting an abstraction and calling a single method - simple dependency injection - creates complex interactions
and coupling and MediatR solves it, then shouldn’t every dependency injected into every class be replaced with MediatR?
Unless we’ve got something far more complex going on, it’s a solution we don’t need to a problem we don’t have.&lt;/p&gt;

&lt;p&gt;Another way to tell whether we’re actually implementing the mediator pattern correctly: The mediator will be
an abstraction we define, and its name will indicate what it mediates, like &lt;code class=&quot;highlighter-rouge&quot;&gt;IChatRoomMessageMediator&lt;/code&gt;. If we
have two different classes doing different things and they both depend on the same &lt;code class=&quot;highlighter-rouge&quot;&gt;IMediator&lt;/code&gt; because that’s
what mediates all the things everywhere, we should revisit that.&lt;/p&gt;

&lt;h2 id=&quot;does-mediatr-help-us-implement-cqrs&quot;&gt;Does MediatR Help Us Implement CQRS?&lt;/h2&gt;
&lt;p&gt;Command/Query Responsibility Segregation (CQRS) means (in brief) that we avoid combining commands that change something with queries that return data. An operation is either a command or a query, but not both.&lt;/p&gt;

&lt;p&gt;Look again at the two examples. Which implements CQRS? Both. Neither. Let me explain:&lt;/p&gt;

&lt;p&gt;In both examples we have a command and a query, and they are separate. Was it a challenge to implement CQRS without MediatR? 
Not at all. MediatR did not sprinkle magic CQRS dust on our code. 
Both code samples do the same thing, the second one with a pointless extra layer of abstraction.&lt;/p&gt;

&lt;p&gt;The answer is also that neither necessarily implements CQRS. 
What if our query handler, which is supposed to read and not write, violates that segregation by doing something 
command-like anyway? Which example prevents it? Neither. 
The only way to keep our commands and queries segregated is to segregate them. 
Nothing will enforce that for us.&lt;/p&gt;

&lt;p&gt;I could be way off, but I suspect that some developers learn about CQRS and MediatR at the same time 
and see them as more closely related than they are. 
Or perhaps they get the impression that CQRS is inherently intertwined with the mediator pattern.
It’s true that MediatR provides a handler interface, encouraging us to think in terms of handlers. 
But how long does it take to create those generic interfaces? 
Thirty seconds? About the same time it takes to add a NuGet package?&lt;/p&gt;

&lt;p&gt;And, peculiarly, MediatR names all of its interfaces &lt;code class=&quot;highlighter-rouge&quot;&gt;IRequestHandler&lt;/code&gt;. 
Why not &lt;code class=&quot;highlighter-rouge&quot;&gt;ICommandHandler&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;IQueryHandler&lt;/code&gt;? 
Names matter. They don’t enforce anything, but they communicate intent. 
Having commands and queries both implement &lt;code class=&quot;highlighter-rouge&quot;&gt;IRequest&lt;/code&gt; and their handlers implement &lt;code class=&quot;highlighter-rouge&quot;&gt;IRequestHandler&lt;/code&gt; does not express the intent to keep commands separate from queries.&lt;/p&gt;

&lt;h2 id=&quot;what-about-reducing-the-number-of-injected-dependencies&quot;&gt;What About Reducing the Number of Injected Dependencies?&lt;/h2&gt;
&lt;p&gt;The first example above injects two dependencies, a command handler and a query handler. 
In the second example, MediatR reduces that to one dependency, &lt;code class=&quot;highlighter-rouge&quot;&gt;IMediator&lt;/code&gt;. 
Is fewer better? It depends. In this case, no.&lt;/p&gt;

&lt;p&gt;One of the many benefits of dependency injection is that we can easily look at a class and tell how many dependencies 
it has and what they are. 
If a class has five or more dependencies (that’s an arbitrary number) then it’s almost certainty violating the Single Responsibility Principle. 
If it has ten dependencies it’s certainly violating the SRP.&lt;/p&gt;

&lt;p&gt;If performing a single logical operation involves invoking multiple dependencies, creating a single abstraction
to represent that behavior (like a facade) is beneficial. How can we tell if it is? Because instead of invoking
three methods on three dependencies, we’re invoking one method on one dependency. That’s a good way to 
reduce the number of dependencies.&lt;/p&gt;

&lt;p&gt;But if we have three or five or ten calls to different dependencies, we merge all of those dependencies into one, 
and then make the same number of calls to one dependency (MediatR), we’re sweeping the problem under the rug.&lt;/p&gt;

&lt;p&gt;It’s like adding more and more unrelated methods to a single interface where they don’t belong because we don’t 
want to inject more dependencies. It’s like packing &lt;code class=&quot;highlighter-rouge&quot;&gt;HandlePlaceSalesOrderCommand&lt;/code&gt;, 
&lt;code class=&quot;highlighter-rouge&quot;&gt;HandleProductInventoryQuery&lt;/code&gt;, and &lt;code class=&quot;highlighter-rouge&quot;&gt;HandleDeleteAccountCommand&lt;/code&gt; all into one interface
and leaving the door open to add keep adding more methods. If our code allows us to do all of those unrelated things
from one class without adding more dependencies, that’s a smell.&lt;/p&gt;

&lt;p&gt;Injecting too many dependencies is undesirable, but it’s a problem that reveals itself as we add the &lt;em&gt;n&lt;/em&gt;th dependency. 
The ability to hide or obscure them is harmful because it makes the problem harder to see.&lt;/p&gt;

&lt;p&gt;Is there perhaps a misunderstanding that this is where MediatR helps us with complex interactions? It doesn’t.
If we have five interactions (complex or not) with five dependencies and we replace it with the same five interactions
with one dependency, we have not reduced the complexity of interactions.&lt;/p&gt;

&lt;p&gt;Finally, if we’ve got a simple class with a handful of dependencies, why are we even talking about reducing them.
A class having more than one dependency is not a problem. Unless our class has too many dependencies, reducing
the number solves a non-existent problem.&lt;/p&gt;

&lt;h2 id=&quot;its-a-service-locator&quot;&gt;It’s a Service Locator&lt;/h2&gt;
&lt;p&gt;The service locator is a &lt;a href=&quot;https://blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern/&quot;&gt;known anti-pattern&lt;/a&gt;.
An example of that anti-pattern might be injecting an IoC container (like &lt;code class=&quot;highlighter-rouge&quot;&gt;IServiceProvider&lt;/code&gt;) into a 
class so that class can resolve dependencies from it. 
A service locator version of the first two examples might look like this:&lt;/p&gt;

&lt;div class=&quot;highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;public class DoesThings
{
    private readonly IServiceProvider serviceProvider;

    public DoesThings(IServiceProvider serviceProvider
    {
        this.serviceProvider = serviceProvider;
    }

    public void DoSomething(Input input)
    {
       /// ...create a DoThisCommand
       var commandHandler = serviceProvider.GetService&amp;lt;ICommandHandler&amp;lt;DoThisCommand&amp;gt;&amp;gt;();
       await commandHandler.Handle(doThisCommand)
    }

    public Data GetData(Input input)
    {
       /// ...create a SomeQuery
       var queryHandler = serviceProvider.GetService&amp;lt;IQueryHandler&amp;lt;SomeQuery, Data&amp;gt;&amp;gt;();
       var result = await queryHandler.Handle(query);
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;Just as the last section decribed, the service locator is an unhealthy way to combine multiple unrelated dependencies.&lt;/p&gt;

&lt;p&gt;Do you see what the MediatR example has in common with the service locator example? 
With the service locator example, the only way to know what the class depends on is to look for every 
single reference to &lt;code class=&quot;highlighter-rouge&quot;&gt;serviceProvider&lt;/code&gt; &lt;em&gt;and&lt;/em&gt; to see what’s resolved from it. 
It’s also easy to add behaviors to a class that don’t belong in it just by requesting difference services 
that are registered with &lt;code class=&quot;highlighter-rouge&quot;&gt;serviceProvider&lt;/code&gt;. What can we request? Anything that’s registered.&lt;/p&gt;

&lt;p&gt;Code that depends on MediatR is similar. We must look at every use of &lt;code class=&quot;highlighter-rouge&quot;&gt;mediator&lt;/code&gt; &lt;em&gt;and&lt;/em&gt; see what commands or queries are sent to it. 
There could be dozens of command and query handlers registered with MediatR. 
What restricts a class from sending a different command or query, something unrelated to the purpose of that class? 
Nothing. Those new dependencies are hidden, obscured behind the &lt;code class=&quot;highlighter-rouge&quot;&gt;IMediator&lt;/code&gt;. 
MediatR opens the door to the same code smells as a service locator if we use it as a service locator.&lt;/p&gt;

&lt;h2 id=&quot;other-thoughts-and-concerns&quot;&gt;Other Thoughts and Concerns&lt;/h2&gt;
&lt;p&gt;MediatR scans our assemblies to find classes that implement its handler interface. 
Do we really have so many commands and handlers that registering them with our IoC container is a problem? 
Likely not. If we do, there are NuGet packages like &lt;a href=&quot;https://www.nuget.org/packages/Scrutor/&quot;&gt;Scrutor&lt;/a&gt; 
that do the same thing without asserting control over how we inject those dependencies. Or we can write our own.&lt;/p&gt;

&lt;p&gt;We should define the abstractions on which our classes depend, not import them from a NuGet package.
Try writing interfaces (or delegates) to represent your command and query handlers. 
How long does it take to create an abstraction like &lt;code class=&quot;highlighter-rouge&quot;&gt;interface ICommandHandler&amp;lt;TCommand&amp;gt;&lt;/code&gt; or &lt;code class=&quot;highlighter-rouge&quot;&gt;interface IOrderStatusQueryHandler&lt;/code&gt;?
It’s easy.&lt;/p&gt;

&lt;h2 id=&quot;the-underlying-principle&quot;&gt;The Underlying Principle&lt;/h2&gt;
&lt;p&gt;Wow, that sounded dogmatic and harsh. I hope I don’t sound like MediatR murdered
someone I care about in a deal gone wrong and now I’m lurking in dark alleys waiting for the chance to get even.&lt;/p&gt;

&lt;p&gt;There is an underlying principle to what may sound like dogmatism, and it has nothing specifically to do with MediatR:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;All code must justify itself. When we write code we should be able to describe in words what problems it solves. 
This is also true of implementing design patterns or importing libraries.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We don’t need to say what our reasoning is or write it. But can we think it? 
Can we explain it if asked?&lt;/p&gt;

&lt;p&gt;Those descriptions might sound like&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;I shouldn’t modify this class and everything that depends on it so that implements a different interface. 
I’ll apply the adapter pattern so that I can implement this interface without breaking changes to other code.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
  &lt;p&gt;I need to serialize and deserialize JSON, and this well-tested library already does that.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
  &lt;p&gt;This code works if I write it all in one line, but it might take someone longer to figure out what it does, so 
if I break it up into intermediate steps the next person will be able to understand it quickly.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If our reason is a principle that we understand then citing the principle may be sufficient explanation.&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;I understand how violating the Single Responsibility Principle creates problems later that might not seem
obvious today, so I’m going to keep these unrelated functions in separate classes.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;These are not good reasons to add code or apply a pattern:&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;It’s the “XYZ” pattern&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;(without explaining why “XYZ” pattern is applicable or helpful in this case.)&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;Here’s an article about it&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;(without explaining in our own words why it’s beneficial.)&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;We did it here for a reason that made sense, so now we have to do it everywhere whether we need it or not
or future developers will be confused.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;(Give future developers a little credit. They’ll be confused because we &lt;em&gt;did&lt;/em&gt; something that made no sense,
not because we &lt;em&gt;didn’t&lt;/em&gt;.)&lt;/p&gt;

&lt;p&gt;If we use MediatR it should pass that test. We should be able to explain in our own words what complex interactions it simplified.
Does it reduce coupling? Was adding MediatR really the only way to prevent that coupling?&lt;/p&gt;

&lt;p&gt;If we can answer some of those questions we should use it. It we can’t I’m on the side of leaving it out.&lt;/p&gt;

</description>
        <pubDate>Sat, 20 Jun 2020 00:00:00 -0400</pubDate>
        <link>http://scotthannen.org/blog/2020/06/20/mediatr-didnt-run-over-dog.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2020/06/20/mediatr-didnt-run-over-dog.html</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>Improve Your Stack Overflow Questions With Unit Tests</title>
        <description>&lt;p&gt;Suppose you’re trying to write code to solve this problem:&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;I’ve got a start date and end date. I want to count the number of times between
those dates where a given day (like 10) appears.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;You try writing it, get stuck, and decide to try asking for help on &lt;a href=&quot;https://stackoverflow.com/&quot;&gt;Stack Overflow&lt;/a&gt;. 
You post the problem above and include the code from your Winforms app, which looks something like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;partial&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Form1&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Form&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Form1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;nf&quot;&gt;InitializeComponent&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;btnCalculate_Click&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;object&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;sender&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;EventArgs&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;e&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;try&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;txtStartDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Text&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;txtEndDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Text&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;day&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;txtDay&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Text&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;

            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;numberOfTimesDayHappensInDateRange&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

             &lt;span class=&quot;c1&quot;&gt;// Some code that tries to calculate this, but isn't getting&lt;/span&gt;
             &lt;span class=&quot;c1&quot;&gt;// the results you want&lt;/span&gt;

            &lt;span class=&quot;n&quot;&gt;MessageBox&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Show&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;$&quot;The answer is &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;numberOfTimesDayHappensInDateRange&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;!&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;catch&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;MessageBox&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Show&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;I think something is wrong with the values you entered!&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Some variation of the following will likely happen:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;You’ll get downvoted&lt;/li&gt;
  &lt;li&gt;Your question will get closed&lt;/li&gt;
  &lt;li&gt;You’ll get no response&lt;/li&gt;
  &lt;li&gt;You’ll get answers that don’t relate to your question&lt;/li&gt;
  &lt;li&gt;Someone will leave a comment saying, “I have no idea what you’re trying to do. Can you give an example showing what results you expect?”&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;We’re sad when that happens. How can we improve our question?
One approach is to write a unit test that shows our inputs and the results
we expect.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Disclaimer: I asked some other folks on Stack Overflow what they thought of this.
The response amounted to, “Sure, but no one is going to do that.” And they might be right.
But that’s okay. I’m an optimist and I like to think this will help someone, even
if it has nothing to do with asking questions on Stack Overflow.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;What if we could make this easier to understand by isolating the code that contains the problem from everything else?&lt;/p&gt;

&lt;p&gt;We could start by putting just this part of the code in a separate class and method:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DateFunctions&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;c1&quot;&gt;// Some code that tries to calculate this, but isn't getting&lt;/span&gt;
        &lt;span class=&quot;c1&quot;&gt;// the results you want&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;&lt;em&gt;In case it’s not obvious yet, this post doesn’t include a working version of this function. This is about how to ask the question,
not the solution itself.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;That’s a long function name, isn’t it? But it’s also a lot clearer what it’s supposed to return. If we just called it &lt;code class=&quot;highlighter-rouge&quot;&gt;NumberOfTimesDayOccursInDateRange&lt;/code&gt;
it might be less obvious that we’re talking about a calendar day (1, 15, 27) and not a day of the week (Monday, Tuesday.)&lt;/p&gt;

&lt;p&gt;All we’ve done so far is move the code from one place to another. That’s a start. Now someone who wants to understand the method
and help us with it doesn’t have to look at all of the extra code. What they’re looking at is just the part we’re trying to figure out.&lt;/p&gt;

&lt;p&gt;It might seem obvious to us what results we expect to get for different inputs, but how can we communicate that clearly to someone else?&lt;/p&gt;

&lt;p&gt;One way to accomplish that is with one or more unit tests. If we don’t already have a unit test project in our solution, we can add one:&lt;/p&gt;

&lt;p&gt;Right-click on the &lt;em&gt;solution&lt;/em&gt; and select Add -&amp;gt; New Project… -&amp;gt; Visual C# -&amp;gt; Test -&amp;gt; Unit Test Project (.NET Framework).&lt;/p&gt;

&lt;p&gt;There are other options such as NUnit and xUnit, but we’ll just look at Microsoft’s default version. The others do essentially the
same thing but with additional capabilities.&lt;/p&gt;

&lt;p&gt;Our project will contain a single test class with a single unit test, like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;namespace&lt;/span&gt; &lt;span class=&quot;nn&quot;&gt;UnitTestProject1&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TestClass&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;UnitTest1&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TestMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;TestMethod1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The &lt;code class=&quot;highlighter-rouge&quot;&gt;[TestClass]&lt;/code&gt; attribute indicates that the class contains tests. The &lt;code class=&quot;highlighter-rouge&quot;&gt;[TestMethod]&lt;/code&gt; attribute indicates that the method
&lt;em&gt;is&lt;/em&gt; a test. This is how the test runner knows which parts of the code in this project are tests that we need to run.&lt;/p&gt;

&lt;p&gt;For the sake of simplicity, a unit test is a method that &lt;em&gt;passes&lt;/em&gt; if it runs without throwing any exceptions, and &lt;em&gt;fails&lt;/em&gt; if 
it throws an exception. We write these methods so that if our code does what we expect it to do, it won’t throw an exception. 
It will pass. If doesn’t do what we expect, it will throw an exception and fail.&lt;/p&gt;

&lt;p&gt;This will be clearer with an example. First, let’s copy our &lt;code class=&quot;highlighter-rouge&quot;&gt;DateFunctions&lt;/code&gt; class into the same file as our test. We don’t have
to do that. Eventually that class will be in our “real” project - not the test project - and our test project will reference it. 
But at this step it’s often convenient to have them both in one place. It’s going to help with our Stack Overflow question. This
is also how I work if I’m answering someone’s question and I want to be sure that my answer works. I just create a test project
and write both the code and the unit tests.&lt;/p&gt;

&lt;p&gt;Here’s what our file looks like with the &lt;code class=&quot;highlighter-rouge&quot;&gt;DateFunctions&lt;/code&gt; class included and a simple unit test:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;na&quot;&gt;[TestClass]&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DateFunctionTests&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TestMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange_returns_correct_result&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;1/1/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;2/15/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;14&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;expectedResult&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;actualResult&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateFunctions&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;AreEqual&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;expectedResult&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;actualResult&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DateFunctions&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; 
        &lt;span class=&quot;cm&quot;&gt;/*
         * I just put this here so it compiles. This would be your
         * work in progress code. You've written something. It just
         * doesn't return the right results.
         */&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;I made the test a little bit verbose, declaring everything as a variable, to make it easier to follow.
It shows that we’re going to execute our function with specific inputs, and we know what result
we expect.&lt;/p&gt;

&lt;p&gt;The last statement - &lt;code class=&quot;highlighter-rouge&quot;&gt;Assert.AreEqual&lt;/code&gt; - will check to see if our actual result is the same as our 
expected result. If it is not, it will throw an exception and the test will fail.&lt;/p&gt;

&lt;p&gt;To try it out, right-click on the test class and select &lt;strong&gt;Run Test(s)&lt;/strong&gt;. The project will compile, Visual Studio
will run the test, and a “Test Explorer” window will open showing us the result.&lt;/p&gt;

&lt;p&gt;This test will fail, because our function returned &lt;em&gt;0&lt;/em&gt;, not the expected result. If we drill down into that
test result by clicking on the red “X” icons, we’ll eventually see this exception:&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;Message: Assert.AreEqual failed. Expected:&amp;lt;2&amp;gt;. Actual:&amp;lt;0&amp;gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If we figure out how to fix our method so that it returns the correct result, this
test will no longer fail. Our test results will be green, not red.&lt;/p&gt;

&lt;p&gt;If we want to step through the code, we can set breakpoints and then right-click
and select &lt;strong&gt;Debug Test(s)&lt;/strong&gt;. This will enable us to step through the code.&lt;/p&gt;

&lt;h3 id=&quot;how-this-is-better-so-far&quot;&gt;How This Is Better, So Far&lt;/h3&gt;

&lt;p&gt;Let’s say that you’re trying over and over again to fix your function. 
Which is easier:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;Starting up your Windows Forms app, typing in some values, pressing the button, and looking at the result&lt;/li&gt;
  &lt;li&gt;Running a unit test and seeing if it passes or fails&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The unit test is much easier. Perhaps we’ve already caught on that creating a form
is a horrible way to test. Maybe we tend to use console apps instead. Even still, isn’t running a unit test even easier than that?
A unit test is a lot like a console app, except that instead of us  &lt;em&gt;looking&lt;/em&gt; at the result to see if it’s correct,
the test already knows what the correct result is that it’s looking for. It’s built into the test.&lt;/p&gt;

&lt;p&gt;Imagine if we pasted this code into our Stack Overflow question. It says, in effect,&lt;/p&gt;
&lt;blockquote&gt;
  &lt;p&gt;Here’s the code I need help with. Here’s a unit test that describes exactly what it should do.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If I were trying to help with this question, I would probably start by creating a unit test project,
pasting this code into it, and writing some unit tests. I would use the unit tests
to confirm that my solution works. (I want to give you a good answer, which means I’m not going to guess.)&lt;/p&gt;

&lt;p&gt;But now, by providing both your code and the unit test, you’ve made it even easier
to help you. I can paste both the code and the unit test, and all I’ve got to do is
work with your code to make the unit test pass.&lt;/p&gt;

&lt;h3 id=&quot;it-gets-even-better&quot;&gt;It Gets Even Better&lt;/h3&gt;

&lt;p&gt;Do we really trust that our code works as expected because it returns the correct
result for just one set of inputs? Wouldn’t we rather test it with multiple inputs? Maybe 
we have some weird edge cases. How do we test this with multiple inputs?&lt;/p&gt;

&lt;p&gt;We could copy and paste the test method so that we have several test methods, 
each with different inputs and expected outputs, and then we could run all of those tests.
That’s acceptable. That means that we can test our code with a range of inputs
all at the same time. Imagine trying that with a console app. It would be a pain. 
Unit tests make it easy.&lt;/p&gt;

&lt;p&gt;But there’s an easier approach than creating multiple tests. We can create a
single test that takes multiple inputs. This is called &lt;em&gt;parameterized test&lt;/em&gt;. 
It might look like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;na&quot;&gt;[TestClass]&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DateFunctionTests&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DataTestMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DataRow&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;1/1/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;2/15/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;14&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)]&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DataRow&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;1/1/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;1/13/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;14&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)]&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DataRow&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;1/1/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;12/31/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;31&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;7&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange_returns_correct_result&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;expectedResult&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;actualResult&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateFunctions&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;AreEqual&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;expectedResult&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;actualResult&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Each &lt;code class=&quot;highlighter-rouge&quot;&gt;DataRow&lt;/code&gt; attribute contains a set of values - a start date, an end date, a day of the month, 
and an expected result. Instead of having to write more test methods to test a different
set of values, we can just add a new data row. The test runner will run the test once
for each set of values.&lt;/p&gt;

&lt;p&gt;Imagine the frustration if we fix the function so that it works with one set of inputs,
but then returns the wrong results for different inputs. Imagine having to test over and over
with each set of inputs. Now it’s easy to verify that the function returns the
correct result for all of the inputs at the same time.&lt;/p&gt;

&lt;h3 id=&quot;our-improved-question&quot;&gt;Our Improved Question&lt;/h3&gt;
&lt;p&gt;Now, instead of posting a bunch of irrelevant code that other people have to read through, 
we can post this:&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;I’m trying to write a function that returns the number of times a given day of the
month appears in a date range. Here’s my code, which isn’t working yet, and
some unit tests that show what the results should be.&lt;/p&gt;

&lt;p&gt;Can you help me to find the problem in my code?&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DateFunctions&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
       &lt;span class=&quot;c1&quot;&gt;// Whatever code you have that isn't working right&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;na&quot;&gt;[TestClass]&lt;/span&gt;
&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DateFunctionTests&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DataTestMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DataRow&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;1/1/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;2/15/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;14&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)]&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DataRow&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;1/1/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;1/13/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;14&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)]&lt;/span&gt; 
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DataRow&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;1/1/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;12/31/2019&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;31&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;m&quot;&gt;8&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange_returns_correct_result&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;expectedResult&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;actualResult&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateFunctions&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;NumberOfTimesDayOfMonthOccursInDateRange&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;startDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Parse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;endDate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;),&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dayOfMonth&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;Assert&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;AreEqual&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;expectedResult&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;actualResult&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;hr /&gt;

&lt;p&gt;You may have seen people on Stack Overflow ask for an &lt;a href=&quot;https://stackoverflow.com/help/minimal-reproducible-example&quot;&gt;MCVE&lt;/a&gt; which
stands for “Minimal, Complete, Verifiable Example.” In other words, they’re
asking you to provide just the part of your code that you need help with, not
all sorts of extraneous details, make sure you don’t leave out the important parts,
and show how you know whether or not it’s working.&lt;/p&gt;

&lt;p&gt;That’s exactly what we’ve accomplished:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;strong&gt;Minimal&lt;/strong&gt; - we’ve stripped away all of the code that’s &lt;em&gt;not&lt;/em&gt; related to the
date function.&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Complete&lt;/strong&gt; - the whole date calculation is in that function&lt;/li&gt;
  &lt;li&gt;&lt;strong&gt;Verifiable&lt;/strong&gt; - the unit test shows both what you expect and how you know if it’s working.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Assuming that you’ve made some effort to write the code - you’re showing your attempt at writing the function - 
you’ve written the perfect question.&lt;/p&gt;

&lt;h3 id=&quot;the-best-part&quot;&gt;The Best Part&lt;/h3&gt;
&lt;p&gt;The effort that you put into asking this question will make understanding and 
debugging your code so much easier that you’re far more likely to solve your own
problem before you even post the question.&lt;/p&gt;

&lt;p&gt;These are roughly the same steps that most developers take to make their own problems
easier to understand and solve. We put code that performs specific functions into separate
classes and methods so that we can test it in isolation from other code. And then
we write unit tests to verify that our code does what we think it should do.&lt;/p&gt;

&lt;p&gt;We all make mistakes in our code, even in code that should seem trivial. This allows
us to catch our mistakes more quickly. We can often find our mistakes right after we make them.
It also means that if we must step through our code in the debugger, we won’t have to step through
as much of it. Instead of setting breakpoints, starting up an app, and providing inputs just to test some
tiny piece of code, we can isolate just the part we’re working on.&lt;/p&gt;

&lt;p&gt;In the long run this means that we work faster and with greater confidence. If we haven’t worked with unit tests 
we might expect that writing the extra test code will cause us to work more slowly, but it’s actually the opposite.
When we subtract the time that we would have spent searching for defects that turn up later, re-reading code we
wrote days or weeks ago, and stepping through lots of code in the debugger, the net result is that we save lots of time.&lt;/p&gt;

&lt;p&gt;It’s not immediate. There is a little bit of a learning curve, and it might slow us down at first. 
But if you were ever going to a make a leap of faith, this is the one to make. Once you’re on the other side of it, you’ll 
never want to go back. You might even find yourself wondering how you ever wrote code without unit tests. It’s that good.&lt;/p&gt;

&lt;p&gt;You may have read articles critical of unit testing, arguing that we can end up writing way too many useless tests and that 
it somehow damages the design of our code. There is usually an element of truth to such arguments. We may lose our balance
at first and veer from writing no tests to writing too many. The quality of our tests might be low. That’s okay. It’s part
of the learning experience. It helps if we realize that by not writing any unit tests, we’re already at one extreme. We may
go to the opposite extreme before finding our balance.&lt;/p&gt;

&lt;p&gt;As much as this practice has helped me, I still have a great deal to learn about unit testing.&lt;/p&gt;

&lt;p&gt;Unit testing is also like a gateway drug that leads to all sorts of improved practices. In this example we had to move code
out of a Windows Form into its own class so that we could test it. That’s a good habit. Making it possible to test the code 
improved the design of the code. That pattern repeats. Over time we’re likely to find that arranging our code so that we
can write tests for it significantly improves the design of our code in other ways.&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;Was the premise of this whole post just a trick to introduce unit tests? Yes and no. I often read Stack Overflow questions
that would be much easier to understand if they included unit tests to describe the expected results. Sometimes I demonstrate
the idea by including unit tests in the answer, but explaining how to write tests would be way outside the scope of the
original question.&lt;/p&gt;

&lt;p&gt;At the same time, I’m convinced that most developers who don’t write unit tests would benefit from learning to write them.
As I hope I’ve demonstrated, they change the way we write our code, making it easier to isolate and solve our own problems.
We all get stuck and need help. I look things up on Stack Overflow all the time. But this change increases our ability to
push through problems on our own, increasing both our productivity and our confidence.&lt;/p&gt;
</description>
        <pubDate>Mon, 02 Sep 2019 00:00:00 -0400</pubDate>
        <link>http://scotthannen.org/blog/2019/09/02/improve-stack-overflow-questions-unit-tests.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2019/09/02/improve-stack-overflow-questions-unit-tests.html</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>Untestable Code Knows No Mercy</title>
        <description>&lt;p&gt;What is untestable code?&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;It has no unit tests.&lt;/li&gt;
  &lt;li&gt;Writing unit tests for it would be difficult or impossible without modifying the code.&lt;/li&gt;
  &lt;li&gt;Common attributes include global state, tight coupling, and long methods that do lots of things.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Testable code, on the other hand, tends to consist of smaller classes and methods with well-defined purposes. It avoids use of global state and uses a reasonable amount of abstraction to avoid tight coupling between components.&lt;/p&gt;

&lt;p&gt;Neither is meant to be a comprehensive definition. They’re just enough so that I can throw around the terms &lt;em&gt;testable code&lt;/em&gt; and &lt;em&gt;untestable code&lt;/em&gt; for the rest of this post.&lt;/p&gt;

&lt;p&gt;Untestable code is a cause that produces known effects. Those effects include:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;More defects&lt;/li&gt;
  &lt;li&gt;Modifications are harder and riskier&lt;/li&gt;
  &lt;li&gt;End users wait longer for new features and bug fixes&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Conversely, testable code results in the reduction of all three.&lt;/p&gt;

&lt;p&gt;I hope that this is exciting, good news for at least a few people. The problems I’ve just summarized aren’t inevitable. They are effects that come from causes, and we can control those causes.&lt;/p&gt;

&lt;p&gt;Why the emphasis on cause and effect? Because sometimes we understand them but somehow think that they won’t apply in certain cases. We know what results from untestable code but act as if we don’t.&lt;/p&gt;

&lt;p&gt;I’ve addressed one such case &lt;a href=&quot;http://scotthannen.org/blog/2018/04/03/tame-your-dependency-injection-registration.html&quot;&gt;in this blog post&lt;/a&gt;. Sometimes we use IoC containers to make our code more testable, and then we write hundreds or more lines of untestable code to configure the containers. Eventually we find it difficult to understand the code that composes the rest of our application. How does this happen? Because somehow we imagine that our dependency registration code is the exception to all the rules we normally set for ourselves, so we put it in a few massive methods and we don’t write tests for it. Then it gives us trouble because that’s what large methods without tests do.&lt;/p&gt;

&lt;p&gt;SQL stored procedures are another problem area for untestable code. Have you ever observed that teams can be careful and meticulous in C# but then go crazy in SQL? It doesn’t help that the language inherently favors optimization over all other concerns. We think in terms of what we want to do with individual records but then we have to code it using set-based operations. We express behaviors in inner and outer joins and make critical decisions with inline functions that appear in unexpected places. This makes it much harder to read complex code and understand what it does and why.&lt;/p&gt;

&lt;p&gt;We can’t avoid global state in SQL because tables &lt;em&gt;are&lt;/em&gt; global state. It’s hard to avoid tight coupling when we’re forced to repeat lists of columns so that adding a column or changing a data type in one table can lead to cascading changes in any statement that touches it.&lt;/p&gt;

&lt;p&gt;There are &lt;a href=&quot;https://tsqlt.org/&quot;&gt;testing frameworks&lt;/a&gt; that address some of these concerns, and it’s possible to break large procedures into smaller ones that pass data using table variables. I’ve yet to see a team use either approach. I’m convinced that testable SQL is possible. We just don’t think about it that way.&lt;/p&gt;

&lt;p&gt;I’m highlighting SQL stored procedures as an example because of the rampant abuse, but I’m thinking of any case in which we feel that for some exceptional reason we must or should write large amounts of complex, untestable, untested code. JavaScript is another. I wrote a ton of it before learning how to write unit tests for it, and I’ve seen massive amounts of application-critical JavaScript without a single test. (Doesn’t a language without type safety need &lt;em&gt;more&lt;/em&gt; tests, not fewer?)&lt;/p&gt;

&lt;p&gt;Given that cause, there is only one reason to imagine that we will escape the harmful effects: Perhaps our code will show us mercy.&lt;/p&gt;

&lt;p&gt;We don’t say it or think of it that way, but isn’t that what we’re counting on? Perhaps our 600 line stored procedure will exhibit compassion, realizing that we had no choice but to write it that way, and kindly exempt us from the consequences. The thoughtful inner monologue of our code could go something like this:&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;It is not your fault. You could not have made me smaller, more readable, or given me unit tests, because I am SQL. It would be unfair for me to give you all the same grief and pain that comparable code would give you under any other circumstances. Therefore I shall show you mercy. I shall have no defects. I am incomprehensible, but I shall be the one piece of software that  no one will ever need to understand or modify.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;It sounds irrational, but doesn’t it sum up exactly what we’re hoping will happen? Aren’t we just pretending that cause and effect will give us a pass?&lt;/p&gt;

&lt;p&gt;The consequences for writing monolithic “units” of untestable code are exactly the same whether it’s SQL, C#, JavaScript, or any other language. To believe otherwise is like raising a grizzly bear cub and thinking that it won’t maul us to death just like a wild one. The bear doesn’t know whether it’s wild or not. It just acts according to its nature. Our code doesn’t know why it’s hundreds or thousands of lines long, untested and untestable, and it doesn’t care. It will grieve us and vex us six ways from Sunday. Everything we fear most will happen, and then some.&lt;/p&gt;

&lt;p&gt;We can either find a way to make it manageable or make an informed choice to accept the risks, but we can’t expect our code to show us mercy.&lt;/p&gt;
</description>
        <pubDate>Tue, 22 Jan 2019 00:00:00 -0500</pubDate>
        <link>http://scotthannen.org/blog/2019/01/22/untestable-code-knows-no-mercy.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2019/01/22/untestable-code-knows-no-mercy.html</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>Alternatives To Abstract Factories Part I - Lifetime Management</title>
        <description>&lt;p&gt;Wow, that’s got to be the most exciting title for a blog post, ever. It’s all about the minutiae.&lt;/p&gt;

&lt;p&gt;What do you see when you look at this class that depends on two interfaces which are injected into its constructor?&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DoesSomething&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IThingItNeeds&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_thingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IOtherThingItNeedsFactory&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_otherThingFactory&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoesSomething&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;IThingItNeeds&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; 
        &lt;span class=&quot;n&quot;&gt;IOtherThingItNeedsFactory&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;otherThingFactory&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;_thingItNeeds&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;_otherThingFactory&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;otherThingFactory&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoIt&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;_thingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;CallSomeMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;                                  &lt;span class=&quot;c1&quot;&gt;// Uses one dependency...&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;IOtherThing&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;otherThing&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_otherThingFactory&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;CreateOtherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;  &lt;span class=&quot;c1&quot;&gt;// Gets the other from the&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;otherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;CallOtherMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;                                    &lt;span class=&quot;c1&quot;&gt;// factory and uses it.&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Why is one dependency is “directly” injected while the other for the other we inject an abstract factory and request the dependency from the factory?&lt;/p&gt;

&lt;p&gt;If you’ve seen classes like the above and created them, as I have, you might guess that the two dependencies have different lifetimes. For the first one a single instance is used and injected into other class instances over and over. But for the second one we need to ensure that a new instance is created each time &lt;code class=&quot;highlighter-rouge&quot;&gt;DoIt()&lt;/code&gt; is called, so we use the factory to create a new instance.&lt;/p&gt;

&lt;h3 id=&quot;the-problems-with-abstract-factories-for-lifetime-management&quot;&gt;The Problems With Abstract Factories For Lifetime Management&lt;/h3&gt;

&lt;p&gt;What’s wrong with this? The problem is that it causes the class to know way too much about its dependencies. And what it knows could be wrong anyway.&lt;/p&gt;

&lt;p&gt;First, because from the viewpoint of &lt;code class=&quot;highlighter-rouge&quot;&gt;DoesSomething&lt;/code&gt;, &lt;code class=&quot;highlighter-rouge&quot;&gt;IOtherThing&lt;/code&gt; is an abstraction that it depends on. 
The only thing &lt;code class=&quot;highlighter-rouge&quot;&gt;DoesSomething&lt;/code&gt; should know is &lt;code class=&quot;highlighter-rouge&quot;&gt;IOtherThing&lt;/code&gt; has a method it needs to call. 
Now it knows more than that: It knows that &lt;code class=&quot;highlighter-rouge&quot;&gt;IOtherThing&lt;/code&gt; must be transient - that is, it must have a shorter lifetime. 
The point of dependency injection is so that a class only sees the abstraction it depends on without knowing anything about the implementation. 
Why should it know or care whether the implementation is supposed to be transient?&lt;/p&gt;

&lt;p&gt;Second, this doesn’t even make sense because the abstract factory is also an abstraction. 
The class shouldn’t know how that factory provides an instance of the dependency. 
How does the class know that the instance of the dependency returned by the factory is a new, transient instance?
It doesn’t. Maybe the abstract factory is returning the same instance of the dependency over and over. There’s a big assumption here about the implementation 
details of that abstract factory, and it could be wrong.&lt;/p&gt;

&lt;p&gt;Third, what if the class didn’t orginally depend on the factory but then I introduce it to manage the lifetime of the dependency? 
That means that I’m modifying a class because of details of the implementation of an abstraction it depends on. 
The abstraction was supposed to keep my class decoupled from the implementation, and now I’ve defeated that purpose.&lt;/p&gt;

&lt;p&gt;So in this case, unless we make assumptions about how the factory works, we’ve haven’t change much by introducing the factory except adding some complication.
We were receiving the dependency by injection, and it may or may not be transient. Now we’re getting it from the factory, and what we get from the factory may or may not be transient.&lt;/p&gt;

&lt;h3 id=&quot;use-transient-dependencies&quot;&gt;Use Transient Dependencies&lt;/h3&gt;

&lt;p&gt;The place to manage the lifetime of dependencies isn’t in the class that depends on them but in the composition root - likely an IoC container - which is where we specify how dependencies are created and how long they exist.&lt;/p&gt;

&lt;p&gt;For instance, if I’m using an &lt;code class=&quot;highlighter-rouge&quot;&gt;ServiceCollection&lt;/code&gt; - the default IoC container for ASP.NET Core applications, also available in the Microsoft.Extensions.DependencyInjection NuGet package, and I register the above dependencies like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;n&quot;&gt;IServiceCollection&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ServiceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddSingleton&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;NeedsDependencies&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddSingleton&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IThingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ThingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddSingleton&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IOtherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ShortLivedOtherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;What happens? &lt;code class=&quot;highlighter-rouge&quot;&gt;AddSingleton&lt;/code&gt; means that the first time &lt;code class=&quot;highlighter-rouge&quot;&gt;NeedsDependencies&lt;/code&gt; is resolved, the other two dependencies are also resolved and injected into it, and then the container re-uses them forever, returning the same instances. If I need a new instance of &lt;code class=&quot;highlighter-rouge&quot;&gt;ShortLivedOtherThing&lt;/code&gt;, too bad. I’m not going to get one.&lt;/p&gt;

&lt;p&gt;If I change it to this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;n&quot;&gt;IServiceCollection&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ServiceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddTransient&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;NeedsDependencies&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddSingleton&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IThingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ThingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddTransient&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IOtherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ShortLivedOtherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now every time I resolve &lt;code class=&quot;highlighter-rouge&quot;&gt;NeedsDependencies&lt;/code&gt;, the container will provide a new instance. 
It will reuse &lt;code class=&quot;highlighter-rouge&quot;&gt;ThingItNeeds&lt;/code&gt; because we know it’s okay to reuse that. But it will provide a new instance of &lt;code class=&quot;highlighter-rouge&quot;&gt;ShortLivedOtherThing&lt;/code&gt; each time.
That’s what &lt;em&gt;transient&lt;/em&gt; means.&lt;/p&gt;

&lt;p&gt;(What if I register a class as a singleton and its dependency as transient? That doesn’t do any good, because if the class instance lives forever then its dependencies live forever, too.)&lt;/p&gt;

&lt;p&gt;Should we worry excessively about making dependencies transient? Will our application suffer because we’re creating class instance and over? &lt;em&gt;Probably&lt;/em&gt; not.&lt;/p&gt;

&lt;p&gt;Creating a new instance each time we need one isn’t as efficient as reusing an instance, but more often than not the difference is minute. 
Consider a web application. During the processing of each and every request, how many class instances are created and then go out of scope in the framework code that we aren’t even aware of? 
How much middleware code is invoked? How many objects have their properties read to render views as HTML? 
There’s a lot going on. I’m not saying that it never matters, but odds are that creating a few more classes when they’re needed will have no discernible impact whatsoever. 
What does have an impact? The bugs introduced by incorrectly using a singleton.&lt;/p&gt;

&lt;h3 id=&quot;use-scoped-dependencies&quot;&gt;Use Scoped Dependencies&lt;/h3&gt;

&lt;p&gt;In an ASP.NET Core application (and in some other scenarios) we might do this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;n&quot;&gt;IServiceCollection&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ServiceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddScoped&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;NeedsDependencies&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddSingleton&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IThingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ThingItNeeds&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;span class=&quot;n&quot;&gt;serviceCollection&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AddScoped&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IOtherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ShortLivedOtherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;In ASP.NET Core, &lt;code class=&quot;highlighter-rouge&quot;&gt;NeedsDependencies&lt;/code&gt; is neither a singleton nor transient. 
If an instance is resolved during the processing of a web request, it will then be reused every time another instance is resolved during that same web request. 
When it is created, its dependency - &lt;code class=&quot;highlighter-rouge&quot;&gt;ShortLivedOtherThing&lt;/code&gt; is created too. 
(It could be transient. Either way it will get created once every time &lt;code class=&quot;highlighter-rouge&quot;&gt;NeedsDependencies&lt;/code&gt; is created, once per request.)
That’s useful if a class retrieves data specific to the user making the request. We don’t want to retrieve the data over and over, but we want to be sure the same data isn’t used when handling another user’s request.&lt;/p&gt;

&lt;p&gt;(A few years ago before ASP.NET Core we had to add all sorts of weird boilerplate code to ASP.NET MVC to use a container with per-request scoped dependencies. This is way better.)&lt;/p&gt;

&lt;h3 id=&quot;fix-the-dependency-so-it-doesnt-need-to-be-transient&quot;&gt;Fix the Dependency So It Doesn’t Need to Be Transient&lt;/h3&gt;

&lt;p&gt;Why does a particular class need to be transient? Perhaps because it’s not thread safe or maintains some user or request-specific state. If so, can we fix it so that we &lt;em&gt;can&lt;/em&gt; reuse it?&lt;/p&gt;

&lt;p&gt;Much of the time we can create classes so that invoking their methods doesn’t modify their state. 
A stateless class doesn’t have private fields and properties that are modified when executing methods, so thread safety and reuse aren’t an issue. 
As a habit I try to write all classes that way unless they exist specifically to contain data that changes.&lt;/p&gt;

&lt;p&gt;Recently I ran into a scenario where use of a third-party library kept a class from being thread safe. 
In this case I wasn’t using an IoC container at all (and couldn’t), so reworking it to make some dependencies transitive would have been a hassle.&lt;/p&gt;

&lt;p&gt;In this case the issue was easily fixed by making one member static and using a &lt;a href=&quot;https://docs.microsoft.com/en-us/dotnet/api/system.threadstaticattribute&quot;&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;ThreadStatic&lt;/code&gt; attribute&lt;/a&gt;. 
That’s something I rarely use, but it made more sense to modify the code where the problem was instead of changing everything else to work around it.&lt;/p&gt;

&lt;hr /&gt;
&lt;p&gt;The preferred use of an abstract factory is when we need the implementation of a dependency to vary according to some runtime value. 
For example we might have a class representing a sales order, and we might need to select an implementation of sales tax logic according to the state or region where it will ship.&lt;/p&gt;

&lt;p&gt;Even in a scenario where an abstract factory makes sense, what if we didn’t initially use one and now we need one? 
Must we modify existing classes to depend on an abstract factory? Maybe, but there are alternatives. 
I was going to discuss them in this post, but I’ll leave it for the next one. What comes to your mind? Maybe we’ll converge on some of the same answers.&lt;/p&gt;
</description>
        <pubDate>Mon, 14 Jan 2019 00:00:00 -0500</pubDate>
        <link>http://scotthannen.org/blog/2019/01/14/abstract-factory-alternatives-lifetime-management.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2019/01/14/abstract-factory-alternatives-lifetime-management.html</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>The Interface Segregation Principle Applied in C#/.NET</title>
        <description>&lt;p&gt;TL;DR:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;The Interface Segregation Principle says that a client class should not depend on &lt;em&gt;part&lt;/em&gt; of an interface.&lt;/li&gt;
  &lt;li&gt;Giant interfaces with lots of methods are undesirable, but that’s not the point of the ISP.&lt;/li&gt;
  &lt;li&gt;If a class implements an interface and some of its methods throw a &lt;code class=&quot;highlighter-rouge&quot;&gt;NotImplementedException&lt;/code&gt;, that’s bad, but has nothing to do with the ISP.&lt;/li&gt;
  &lt;li&gt;One way to apply the ISP is to write interfaces for dependencies from the perspective of the clients that depend on them so that there are no extra methods.&lt;/li&gt;
&lt;/ul&gt;

&lt;hr /&gt;

&lt;p&gt;The common definition of the Interface Segregation Principle (ISP) is:&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;No client should be forced to depend on methods it does not use.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This predates the .NET Framework, so how can we apply it to .NET code?&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;The “client” is a class that depends on another class or interface.&lt;/li&gt;
  &lt;li&gt;The word “interface” doesn’t refer specifically to the &lt;code class=&quot;highlighter-rouge&quot;&gt;interface&lt;/code&gt; keyword. A class could depend on the public members of another class. 
 But we often write our “client” classes to depend on interfaces defined with the &lt;code class=&quot;highlighter-rouge&quot;&gt;interface&lt;/code&gt; keyword.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So, while this post (and many others) apply the principle to interfaces declared with the &lt;code class=&quot;highlighter-rouge&quot;&gt;interface&lt;/code&gt; keyword, the principle is not limited to that.&lt;/p&gt;

&lt;p&gt;The word “depend” can be a little confusing in this context. How can we depend on a method but not use it? What this actually means is that we shouldn’t depend 
on an interface which contains methods we don’t use.&lt;/p&gt;

&lt;h3 id=&quot;a-very-simple-example&quot;&gt;A Very Simple Example&lt;/h3&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;IDoesStuff&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoSomething&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoSomethingElse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoesEvenMore&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ClientThatDependsOnInterface&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IDoesStuff&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_dependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
 
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ClientThatDependsOnInterface&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDoesStuff&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;_dependsOnThis&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;     
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ClientMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;_dependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DoSomethingElse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;p&gt;In this example &lt;code class=&quot;highlighter-rouge&quot;&gt;ClientThatDependsOnInterface&lt;/code&gt; depends on &lt;code class=&quot;highlighter-rouge&quot;&gt;IDoesStuff&lt;/code&gt; but does not use two of its three methods. That doesn’t mean that we 
should change &lt;code class=&quot;highlighter-rouge&quot;&gt;ClientThatDependsOnInterface&lt;/code&gt; so that it uses all three methods. Rather, it should just depend on a different interface that only 
has the method it needs.&lt;/p&gt;

&lt;h3 id=&quot;what-it-isnt&quot;&gt;What It Isn’t&lt;/h3&gt;

&lt;p&gt;I’ve read a few posts about the Interface Segregation Principle that seem to be more about Single Responsibility and Liskov Substitution.&lt;/p&gt;

&lt;p&gt;Some point out that our interfaces should be small, having fewer methods. That’s true, but that relates more to the Single Responsibility Principle. 
If our interface has 23 methods and a class depends on all 23 of them then we have some serious code smells, but the client is &lt;em&gt;not&lt;/em&gt; forced to depend on methods 
it does not use. Both the interface implementation and the class that depend on it probably have too many responsibilities.&lt;/p&gt;

&lt;p&gt;Others point out that if our interfaces have too many methods we might find ourselves creating classes that implement the interface but throw a &lt;code class=&quot;highlighter-rouge&quot;&gt;NotImplementedException&lt;/code&gt; 
for certain methods that we haven’t implemented. There’s an ISP violation because a class that depends on the interface &lt;em&gt;can’t&lt;/em&gt; depend on all of its methods. 
If it did, it would throw a &lt;code class=&quot;highlighter-rouge&quot;&gt;NotImplementedException&lt;/code&gt;. But it’s still possible (and far more common) to violate the ISP &lt;em&gt;without&lt;/em&gt; throwing a &lt;code class=&quot;highlighter-rouge&quot;&gt;NotImplementedException&lt;/code&gt;, 
so it’s still not quite on target for illustrating the ISP. Throwing that exception is more of a Liskov Substitution problem. The ISP is about depending on an interface with methods we don’t need, 
not creating classes that fail to fully implement an interface.&lt;/p&gt;

&lt;p&gt;As a side note, I sometimes feel a little pretentious throwing about the names of these principles, like it’s supposed to sound smart or put me in league with the big 
minds who formulated them. That’s not my intent. If it is, I don’t think it’s working. I refer to them because, in my opinion, they’re just really good principles. 
They weren’t invented out of thin air. They were the results of many years of experience and analysis. Then, in my own experience, I find that many issues in the code 
I work with are traceable to violations of these principles. That makes them good guidelines to follow. No one says that we must rigidly obey them without exception, 
but we should understand that the accumulation of such exceptions is what makes our code a mess.&lt;/p&gt;

&lt;h3 id=&quot;what-it-is&quot;&gt;What It Is&lt;/h3&gt;

&lt;p&gt;To quote &lt;a href=&quot;https://drive.google.com/file/d/0BwhCYaYDn8EgOTViYjJhYzMtMzYxMC00MzFjLWJjMzYtOGJiMDc5N2JkYmJi/view&quot;&gt;Uncle Bob’s article in which he defines the principle&lt;/a&gt;:&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;…when a client depends upon a class that contains interfaces that the client does not use, but that other clients do use, then that client will be
affected by the changes that those other clients force upon the class.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Suppose we have an interface with three methods. Then we have three classes that depend on the interface, each depending on a different method. The three classes, 
while unrelated to each other, are in a way coupled to each other. If we change one method to account for the needs of the one class that depends on it, we’re still 
changing the interface used by two other classes that don’t need to change. Then changes to the implementation of the interface are more likely to impact classes that 
depend on the other two methods.&lt;/p&gt;

&lt;p&gt;In effect, all classes that depend on the interface become coupled to each other:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;One class requires a change to the interface to support its own needs.&lt;/li&gt;
  &lt;li&gt;The change to the interface forces a change to the class which implements it.&lt;/li&gt;
  &lt;li&gt;The change to the class potentially impacts other clients of the interface.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The article does refer to “fat” interfaces, but it’s not about the number of methods:&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;Classes that have “fat” interfaces are classes whose interfaces are not cohesive. In other words, the interfaces of the class can be broken up into groups 
of member functions. Each group serves a different set of clients. Thus some clients use one group of member functions, and other clients use the other groups.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;As mentioned in the outset, this isn’t just about interfaces. It applies when different clients use different methods of a single class. We could apply the principle to our interfaces 
and disregard it in our classes if a dozen classes depend on a dozen interfaces but then one class implements all twelve interfaces. The reason why I apply this more to interfaces is 
because the Single Responsibility Principle independently guards against classes that do too many unrelated things.&lt;/p&gt;

&lt;p&gt;Chances are that if we violate it in our interfaces we’ll violate in our classes too. I ran an NDepend analysis of one codebase and found a large class implemented by a large interface. 
Two sets of methods were used by two sets of clients. NDepend flagged it as not &lt;em&gt;cohesive&lt;/em&gt; and recommended breaking it up. How could it tell? Because 
because two sets of methods used two distinct sets of dependencies and member variables with no overlap. Just as described above, 
the class was actually two unrelated classes that ended up as one when it could be cleanly separated into two classes implementing two interfaces. That’s
what I had to do when we needed a completely different implementation for roughly half the methods in the class. It required changes to lots of classes 
I wouldn’t have had to touch if they didn’t all depend on one giant interface.&lt;/p&gt;

&lt;p&gt;Why do we do that? At some point someone needed new functionality not related to any existing class, and chose to add it into an existing class anyway
instead of creating a new one. It’s not like we pay some extra licensing fee every time we use the &lt;code class=&quot;highlighter-rouge&quot;&gt;class&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;interface&lt;/code&gt; keywords.&lt;/p&gt;

&lt;h3 id=&quot;how-to-created-segregated-interfaces&quot;&gt;How To Created Segregated Interfaces&lt;/h3&gt;

&lt;p&gt;Even though big interfaces are a potential problem, the ISP isn’t about the size of interfaces. It’s about whether classes use the members of 
the interfaces on which they depend. Remember the example of the violation? The problem wasn’t that the class needed to use the whole interface. It was that 
the interface needed to be limited to what the class needed. Except for a few broad, general-purpose interfaces like loggers, that’s only possible if 
the interface was written from the perspective of the class that needs to depend on it.&lt;/p&gt;

&lt;p&gt;To summarize, this is how we can apply the Interface Segregation Principle in C#:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Define interfaces from the perspective of the classes that depend on them.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Don’t just take an existing interface that looks similar to the one your class needs and modify it or add methods to it. Determine 
what your class needs to depend on, and describe it with an interface.&lt;/p&gt;

&lt;p&gt;Suppose your class needs to validate a sales order to make sure it doesn’t contain errors. There might be some giant, vaguely-named interface like 
&lt;code class=&quot;highlighter-rouge&quot;&gt;IOrderService&lt;/code&gt; with three dozen methods. Don’t add another. Maybe that interface already contains the method you need. Consider not using that interface anyway.&lt;/p&gt;

&lt;p&gt;Instead, just define the interface your class needs:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;IOrderValidator&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ValidateOrder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Order&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;order&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;If there’s no implementation then you can create a new single-responsibility class to implement it. If there is then you can adapt the existing 
implementation to your interface or refactor part of it into a separate class. This way you either prevent unnecessary coupling or at least avoid making it worse.&lt;/p&gt;

&lt;p&gt;I’ve found that this approach helps me to work on one class at a time, not getting wrapped up in how the dependencies will be implemented. 
This class needs its orders validated, so it depends on &lt;code class=&quot;highlighter-rouge&quot;&gt;IOrderValidator&lt;/code&gt;. I don’t care about the implementation right now. I can work on that&lt;br /&gt;
next, later, or never. By “never” I mean that another developer can implement that interface. Working on one class at a time keeps me moving along.&lt;/p&gt;

&lt;p&gt;Sometimes I also see StackOverflow questions where developers are trying to figure out complex generic types and inheritance that don’t make any 
sense and waste a lot of time. I’ve &lt;a href=&quot;http://scotthannen.org/blog/2018/04/05/the-generic-rabbit-hole-of-madness.html&quot;&gt;done it myself over and over&lt;/a&gt;. 
This is a little off-topic from the ISP, but working this way can also steer us out of that rut. Instead of creating complex classes and then figuring 
out how we’re going to use them, we work the other way - starting with the interface we need to implement and implementing it. That moves us 
toward writing the code we need instead of solving weird, pointless problems we thought up for no reason.&lt;/p&gt;

&lt;h3 id=&quot;delegates-are-segregated-interfaces&quot;&gt;Delegates Are Segregated Interfaces&lt;/h3&gt;
&lt;p&gt;This has &lt;a href=&quot;http://scotthannen.org/blog/2018/03/18/depending-on-functions-instead-of-interfaces.html&quot;&gt;captured my interest lately&lt;/a&gt;. You’d think I bought stock in delegates and want the price to go up. But in a nutshell, delegates are 
interfaces for a single method, which makes them about as segregated as possible.&lt;/p&gt;

&lt;p&gt;If I define and depend on this delegate:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;delegate&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;OrderValidationFunction&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Order&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;order&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;…then I’m not going to depend on a method I don’t need.&lt;/p&gt;

&lt;p&gt;Another nice side effect is not having single-method interfaces with weird, redundant names like &lt;code class=&quot;highlighter-rouge&quot;&gt;IOrderValidator&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;ValidateOrder&lt;/code&gt;. 
&lt;code class=&quot;highlighter-rouge&quot;&gt;IOrderValidator&lt;/code&gt; just means “interface with a &lt;code class=&quot;highlighter-rouge&quot;&gt;ValidateOrder&lt;/code&gt; method.” It gets worse if it’s a method to retrieve some data. If the method 
is &lt;code class=&quot;highlighter-rouge&quot;&gt;GetOrderValidationRules&lt;/code&gt; then what do you call the interface? &lt;code class=&quot;highlighter-rouge&quot;&gt;OrderValidationRulesProvider&lt;/code&gt;? If I’m saving and retrieving data then 
perhaps that’s a repository. But if I’m just “getting” something then I probably don’t need a whole new interface.&lt;/p&gt;

&lt;h3 id=&quot;segregated-interfaces-make-unit-testing-easier&quot;&gt;Segregated Interfaces Make Unit Testing Easier&lt;/h3&gt;
&lt;p&gt;Have you ever had to unit test a class that depends on an interface with 40 methods but uses six of them, perhaps one in this method, two in 
this method, and so on? You have to read through various methods to figure out which interface members to mock for which tests. In some cases 
developers just give up and create a giant test setup that mocks everything. It works, but now the tests are incomprehensible and unmaintainable.&lt;/p&gt;

&lt;p&gt;Mocking an interface with a handful of methods is easy. Mocking a delegate is even easier.&lt;/p&gt;

&lt;p&gt;All of this is somewhat related to the Single Responsibility Principle. To me, SRP violations are where the headaches really pile up. The ISP helps 
us avoid the backwards pressure to add responsibilities to existing classes. Like other SOLID principles, it doesn’t prevent us from writing bad code. 
It influences us toward writing better code.&lt;/p&gt;

&lt;p&gt;I haven’t enabled comments on this site, but you can comment &lt;a href=&quot;https://dev.to/scotthannen/-the-interface-segregation-principle-applied-in-net-2edd&quot;&gt;here&lt;/a&gt;.&lt;/p&gt;

</description>
        <pubDate>Tue, 01 Jan 2019 00:00:00 -0500</pubDate>
        <link>http://scotthannen.org/blog/2019/01/01/interface-segregation-principle-applied.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2019/01/01/interface-segregation-principle-applied.html</guid>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>String Interpolation Functions vs. string.Format Constants</title>
        <description>&lt;p&gt;Have you ever done this, perhaps to construct a URL or something similar? I have:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;SomethingFormat&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;I need to interpolate {0}, {1}, and {2}&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GetInterpolatedString&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Format&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomethingFormat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;If we isolated the format string as a constant, that suggests that&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;we used it in multiple places and didn’t want to duplicate it&lt;/li&gt;
  &lt;li&gt;we isolated it for the sake of readability&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;How do we use string constants this way when using string interpolation instead of &lt;code class=&quot;highlighter-rouge&quot;&gt;string.Format&lt;/code&gt;?&lt;/p&gt;

&lt;p&gt;The short answer is that we don’t, because we can’t. And maybe it wasn’t the best approach anyway.&lt;/p&gt;

&lt;p&gt;This won’t compile because the value isn’t a constant:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;SomethingFormat&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;$&quot;I need to interpolate &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;value1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;value2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, and &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;value3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This won’t compile because, well, it just doesn’t make any sense:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;SomethingFormat&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;$&quot;I need to interpolate &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;value1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;value2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, and &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;value3&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The underlying problem is that what we’re attempting to create is not a constant at all, but a function - in this case a function that takes three arguments and returns a &lt;code class=&quot;highlighter-rouge&quot;&gt;string&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The “pattern” illustrated at the outset worked, but was seriously flawed. Why? Because we can do this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;SomethingFormat&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;&quot;I need to interpolate {0}, {1}, and {2} ... and {3}!&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GetInterpolatedString&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Format&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomethingFormat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value0&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value1&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;value2&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;…and it compiles but gives a runtime error because our constant expects four arguments but we’re supplying three. We though we were being clever (okay, I did) by storing the &lt;code class=&quot;highlighter-rouge&quot;&gt;string&lt;/code&gt; as a constant, but its disconnection from the function that uses it makes it fragile. Sure, I could write a unit test, but string interpolation is better because in addition to being easier to read and write, it gives us compiler errors instead of runtime errors when it’s wrong.&lt;/p&gt;

&lt;p&gt;It also becomes harder to understand if the constant is used in many places, which means that we won’t see the constant when we’re
modifying methods that use it and vice versa.&lt;/p&gt;

&lt;p&gt;Again, what we’re really trying to accomplish is not a constant, but a function.&lt;/p&gt;

&lt;p&gt;One way to accomplish that is to replace our constant with a function, perhaps like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;FormatSomething&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;foo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bar&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;date&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;s&quot;&gt;$&quot;I need to interpolate &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;foo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bar&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, and &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;date&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;That’s way better, but there’s still a problem. What if this function isn’t limited in use to one class or method, and I change it? 
Yes, I’ll get a compiler error, and that’s good, but the compiler error will arguably be in the &lt;em&gt;wrong place&lt;/em&gt;. 
This function is a bit like a class that implements an interface. It exists to serve a particular purpose for its consumers. 
If I change it, perhaps by adding or removing arguments, the compiler error will indicate that its consumers are calling it with the wrong arguments. 
But that’s not really the case. I’ve actually broken the function so that it no longer fulfills the requirements of its consumers.&lt;/p&gt;

&lt;p&gt;What I really want is a compiler error on the function, indicating that its signature is wrong, just like the one I get when
a class implements an interface but doesn’t have the correct methods or signatures.&lt;/p&gt;

&lt;p&gt;How can we specify that a method, not a class, implements an expected signature? With a delegate:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;delegate&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;FormatSomethingFunction&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;foo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bar&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;date&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;The implementation would look like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;FormatSomethingFunction&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;FormatSomething&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;foo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bar&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;date&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; 
    &lt;span class=&quot;s&quot;&gt;$&quot;I need to interpolate &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;foo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bar&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, and &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;date&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Just as a class implements an interface, the method is explicitly required to conform to the delegate’s signature.&lt;/p&gt;

&lt;p&gt;As I side note, I recently realized that for years, when I need to create an abstraction to supply a method to a class, 
I almost always created an interface and a class implementation, even though all I needed was a single method. To be honest,
I never even considered using delegates, even though they exist for exactly that purpose - creating abstractions for methods. 
And, to my surprise, I found that many times using a more specific tool &lt;a href=&quot;http://scotthannen.org/blog/2018/03/18/depending-on-functions-instead-of-interfaces.html&quot;&gt;leads to unexpected benefits&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Why not this?&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;k&quot;&gt;static&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Func&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;DateTime&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;FormatSomething&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;foo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;bar&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;date&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; 
    &lt;span class=&quot;s&quot;&gt;$&quot;I need to interpolate &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;foo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;bar&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;, and &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;date&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;If we just use a method signature instead of a delegate then the function’s intended use is not as clear. 
We could have functions for entirely unrelated purposes that have the exact same signatures. 
Using a delegate and naming it (clearly) enables to communicate not just its signature but its purpose.&lt;/p&gt;

&lt;p&gt;The initial problem almost seems too small to be called a problem. But what we’ve accomplished is:&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;We’ve leveraged strong typing so that runtime errors are replaced with compiler errors. There’s no compile-time relationship between a format string and its arguments. String interpolation improves on that, so we’re taking advantage of it.&lt;/li&gt;
  &lt;li&gt;We’re declaring the intent of our code as explicitly as possible so that future developers can easily understand what they’re about to modify. (I’d say, “modify or debug”, but the previous point makes debugging less likely.)&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;It’s only a tiny bit more readable and easier to understand than a &lt;code class=&quot;highlighter-rouge&quot;&gt;string.Format&lt;/code&gt; constant, so readability isn’t the big benefit. 
The more likely savings are the time someone doesn’t spend figuring out why the change they made broke something.&lt;/p&gt;
</description>
        <pubDate>Sat, 29 Dec 2018 04:20:58 -0500</pubDate>
        <link>http://scotthannen.org/blog/2018/12/29/string-interpolation-functions-vs-format-constants.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2018/12/29/string-interpolation-functions-vs-format-constants.html</guid>
        
        <category>.net,</category>
        
        <category>string</category>
        
        <category>interpolation,</category>
        
        <category>string.format,</category>
        
        <category>constants</category>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>The Liberation of Pure DI (plus a bonus rant about MEF, which is not an IoC container)</title>
        <description>&lt;p&gt;It’s important to know the distinction between dependency injection and using a dependency injection/IoC container. 
Dependency injection is writing classes so that they &lt;em&gt;receive&lt;/em&gt; dependencies instead of creating them or referencing static classes. 
A container helps you to create instances of those dependencies.&lt;/p&gt;

&lt;p&gt;To illustrate (forgive me, I really need to learn how to be brief and just mention a concept without explaining it):&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;MyClassThatNeedsDependency&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IThingINeed&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_thing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;MyClassThatNeedsDependency&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IThingINeed&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_thing&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// dependency injection - good!&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoSomething&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_thing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;MakeMagicHappen&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;someOtherThing&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;SomeOtherThingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// creates an instance of a concrete &lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;someOtherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;MakeOtherMagicHappen&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;          &lt;span class=&quot;c1&quot;&gt;// implementation - bad&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;IThingINeed&lt;/code&gt; is injected. The class expects an instance supplied to its constructor. Because the class &lt;em&gt;receives&lt;/em&gt; an &lt;code class=&quot;highlighter-rouge&quot;&gt;IThingINeed&lt;/code&gt; instead of creating an implementation, it is completely decoupled from any implementation of &lt;code class=&quot;highlighter-rouge&quot;&gt;IThingINeed&lt;/code&gt;. That’s good. When we write unit tests for this class we can mock &lt;code class=&quot;highlighter-rouge&quot;&gt;IThingINeed&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Then it creates an instance of &lt;code class=&quot;highlighter-rouge&quot;&gt;SomeOtherThingINeed&lt;/code&gt;. That’s potentially bad. Because it does that, this class is tightly coupled to that class. We can’t use or test &lt;code class=&quot;highlighter-rouge&quot;&gt;MyClassThatNeedsDependency&lt;/code&gt; without also using or testing &lt;code class=&quot;highlighter-rouge&quot;&gt;SomeOtherThingINeed&lt;/code&gt;. It’s also harder to change &lt;code class=&quot;highlighter-rouge&quot;&gt;SomeOtherThingINeed&lt;/code&gt;. What if we want to add constructor arguments? That means every class that creates an instance of &lt;code class=&quot;highlighter-rouge&quot;&gt;SomeOtherThingINeed&lt;/code&gt; must be changed to supply those arguments. Those classes will need to know where to get the values for those arguments. The tight coupling becomes even tighter and our code slowly becomes harder to maintain.&lt;/p&gt;

&lt;p&gt;That’s dependency injection. We receive dependencies instead of creating them, which frees each class to do its own thing without having to worry about how its dependencies do their things.&lt;/p&gt;

&lt;p&gt;An IoC container is a tool that helps us to create instances of classes that employ dependency injection. For example, suppose one class depends on &lt;code class=&quot;highlighter-rouge&quot;&gt;ISomething&lt;/code&gt;, but the implementation of &lt;code class=&quot;highlighter-rouge&quot;&gt;ISomething&lt;/code&gt; is a class that has three more dependencies. And some of those dependencies have dependencies, and so on. The result is that each individual class is simpler in isolation (exactly what we want) but creating an instance of a class is now more complex. A constructor call might look something like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;n&quot;&gt;IHouse&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;house&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;FloorPlan23House&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
		&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ElectricalSystem&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
			&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GeModel3000WiringPanel&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(),&lt;/span&gt; 
			&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;SolarPowerSource&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;acmeSolarPanelArray&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;New&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Sun&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()),&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;MassiveBattery&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;())),&lt;/span&gt; 
		&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Kitchen&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;MarbleCounterTop&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;HomeDepotSink&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()....&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This could become incomprehensible if you’re working with a large number of classes. An IoC container like Windsor, Autofac, Unity, or Ninject makes it more manageable. You can write code that looks like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;container&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;WindsorContainer&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;container&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Register&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt; 
        &lt;span class=&quot;n&quot;&gt;Component&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;For&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IHouse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Floorplan23House&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(),&lt;/span&gt; 
        &lt;span class=&quot;n&quot;&gt;Component&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;For&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IPowerSupply&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;SolarArray&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(),&lt;/span&gt; 
        &lt;span class=&quot;n&quot;&gt;Component&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;For&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ISolarPanel&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Model3000SolarPanel&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(),&lt;/span&gt; 
        &lt;span class=&quot;n&quot;&gt;Component&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;For&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IBattery&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;MassiveBattery&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(),&lt;/span&gt;
        &lt;span class=&quot;c1&quot;&gt;// lots more&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;IHouse&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;house&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;container&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Resolve&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IHouse&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;As long as you’ve specified which concrete class or instance to use for each type required in a constructor, it calls all the constructors to create new objects, passes them to other constructors, and so on until it has created the “top-level” class you need. If there’s a type you haven’t “registered” it throws a helpful exception that says, “I’m trying to create a class that needs &lt;code class=&quot;highlighter-rouge&quot;&gt;ISomething&lt;/code&gt;, but you haven’t told me what the implementation is.” What’s nice is that you can work with each class within its own context without having to think about details of other classes you don’t care about in that moment. (You can also organize all of this setup code so that it’s easier to manage, and write tests so you don’t get runtime errors. It’s nice if exceptions are helpful, but they’re 100 times more helpful if you catch them in unit tests.)&lt;/p&gt;

&lt;h3 id=&quot;enter-mef-which-is-not-an-ioc-container&quot;&gt;Enter MEF, Which Is Not an IoC Container&lt;/h3&gt;
&lt;p&gt;This brings me to Microsoft’s Managed Extensibility Framework, or MEF. I survived many happy years without it before I found myself working in an environment where it was the only dependency injection container allowed. (If you are familiar with MEF and that statement makes no sense, don’t worry - I’ve caught up with you by the end of this story.) I found this out after writing all of my configuration using Windsor. Fortunately none of my code was coupled in any way to Windsor, so I only needed to change my DI configuration, not my “real” code that did real stuff.&lt;/p&gt;

&lt;p&gt;I’m going to be honest and up front about this: I didn’t try extremely hard to figure out how to use MEF like a “normal” dependency injection container so I could write code like in the example above. I gave myself 30 minutes to find it. I’ve worked with a number of IoC containers and although I lean toward Windsor, I like to try others when writing blog posts or answering StackOverflow questions. They’re like Chinese buffets - each is different, but if you’ve been to one you’ll recognize what you see at another. (That’s one of my favorite things about Chinese buffets.) Trust me, 30 minutes is reasonable. Try it. Give yourself 30 minutes to find instructions for using Autofac as an IoC container. You will only need about 30 seconds (because Autofac is an IoC container.)&lt;/p&gt;

&lt;p&gt;In 30 minutes I found tons of pages about how to use MEF, but none explaining how to use it as a simple IoC container. I tried the &lt;a href=&quot;https://docs.microsoft.com/en-us/dotnet/framework/mef/&quot;&gt;official documentation&lt;/a&gt; where I found stuff that looked like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Import&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;typeof&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ICalculator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ICalculator&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;calculator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Export&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;typeof&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ICalculator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;MySimpleCalculator&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ICalculator&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;What… the… actual… Never, ever will I put these attributes on anything. Perhaps there is a parallel universe in which an evil version of myself with a beard and/or eyepatch would put an attribute on a class that implements &lt;code class=&quot;highlighter-rouge&quot;&gt;ICalculator&lt;/code&gt; specifying that, yes, it really does implement &lt;code class=&quot;highlighter-rouge&quot;&gt;ICalculator&lt;/code&gt;, so that some weird voodoo elsewhere can assign a class instance to a public &lt;em&gt;field&lt;/em&gt;… wait, this isn’t even constructor injection. It’s &lt;em&gt;property&lt;/em&gt; injection! Here are my internal members, publicly exposed and blowing in the wind so that MEF &lt;em&gt;or anything else&lt;/em&gt; can set them, and I’ll write my code to behave as if this has happened at some undetermined point in the lifetime of the object! I understand that there are scenarios for this, but given that constructor injection is never even &lt;em&gt;mentioned&lt;/em&gt; in this documentation, why would anyone consider MEF as their first choice for implementing it? I’m starting to think that MEF isn’t the problem.&lt;/p&gt;

&lt;p&gt;Further down:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Export&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;typeof&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IOperation&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))]&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ExportMetadata&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;Symbol&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;sc&quot;&gt;'+'&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Add&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IOperation&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Operate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;left&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;right&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;left&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;right&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Stop, I can’t take it anymore. I’m prepared to accept that this is profoundly ignorant on my part, but I don’t even want to know what &lt;code class=&quot;highlighter-rouge&quot;&gt;[ExportMetadata(&quot;Symbol&quot;, '+')]&lt;/code&gt; means or what I might have to do elsewhere for it to make sense. I certainly wouldn’t inflict it on the developer who comes after me.&lt;/p&gt;

&lt;p&gt;By the way, guess what the compiler does if you place &lt;code class=&quot;highlighter-rouge&quot;&gt;[Export(typeof(IOperation))]&lt;/code&gt; on a class that doesn’t implement &lt;code class=&quot;highlighter-rouge&quot;&gt;IOperation&lt;/code&gt;? If you guessed nothing, that it’s just a way to say that a class implements an interface when it doesn’t so that you can get a runtime error instead of a compiler error, you are a winner.&lt;/p&gt;

&lt;p&gt;I’m being a little hard on MEF right now, but here a few points in its defense:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;The &lt;a href=&quot;https://docs.microsoft.com/en-us/dotnet/framework/mef/&quot;&gt;documentation I referenced&lt;/a&gt; does not include the words “dependency injection” or “inversion of control.” I don’t think that’s a mistake.&lt;/li&gt;
  &lt;li&gt;As mentioned, the code samples do not resemble anything one would do with any popular dependency injection container (all of which resemble each other.)&lt;/li&gt;
  &lt;li&gt;Microsoft provides a “normal” container for implementing constructor injection. It’s called &lt;a href=&quot;https://github.com/unitycontainer/unity&quot;&gt;Unity&lt;/a&gt;. And &lt;a href=&quot;https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-2.2&quot;&gt;another one&lt;/a&gt; which is the default for ASP.NET core, but you can use it in any type of project. Both of them are explicitly described as tools for implementing dependency injection. I don’t think Microsoft is confused.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Could those clues perhaps indicate that MEF makes a lousy IoC container because &lt;em&gt;it isn’t one&lt;/em&gt; and that the real problem is someone thinking not only that it is an IoC container, but that it should be preferred above all others?&lt;/p&gt;

&lt;p&gt;I tried to shed some light on this confusion by looking at how MEF is currently used in the code, and found stuff like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;n&quot;&gt;RegistrationBuilder&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;registrations&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;RegistrationBuilder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;registrations&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ForTypesMatching&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;r&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;r&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;EndsWith&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;Foo&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;SetCreationPolicy&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CreationPolicy&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;NonShared&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ExportInterfaces&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Export&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;registrations&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ForTypesMatching&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;r&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;r&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Name&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;EndsWith&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;Blarg&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;SetCreationPolicy&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;CreationPolicy&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;NonShared&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ExportInterfaces&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Export&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;catalog&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Catalogs&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Add&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;AssemblyCatalog&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;typeof&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;FooBlarg&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;).&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Assembly&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;registrations&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;));&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Let’s break down some of the intriguing questions this raises:&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;If you’re wondering whether we’re looking for classes with names ending in &lt;code class=&quot;highlighter-rouge&quot;&gt;Foo&lt;/code&gt; to implement interfaces which also have names ending in &lt;code class=&quot;highlighter-rouge&quot;&gt;Foo&lt;/code&gt;, so am I. I’m about 53% certain that’s correct.&lt;/li&gt;
  &lt;li&gt;How many class implementations in the assembly we’re searching end with &lt;code class=&quot;highlighter-rouge&quot;&gt;Foo&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;Blarg&lt;/code&gt;? The answer is two and one, respectively.&lt;/li&gt;
  &lt;li&gt;How do you find out which interfaces and classes this configures? You &lt;em&gt;search the text of your code&lt;/em&gt; for &lt;code class=&quot;highlighter-rouge&quot;&gt;Foo&lt;/code&gt; and &lt;code class=&quot;highlighter-rouge&quot;&gt;Blarg&lt;/code&gt;.&lt;/li&gt;
  &lt;li&gt;We already know which interfaces and implementations we want to use (because they are in a class in the same project), so why don’t we at least use their full names instead making developers search for classes that end with a suffix and upon finding them, hope that they have correctly guessed what this code is doing? Perhaps because we saw it in a tutorial and it looked cool?&lt;/li&gt;
  &lt;li&gt;Can you right-click on a class definition to see where it’s used? No, because the class is only instantiated after discovering the type by part of its name.&lt;/li&gt;
  &lt;li&gt;Did I mention that these types are not discovered in a dynamically loaded assembly (the sort of scenario for which MEF exists), but rather exist in the exact same project as the code that “discovers” them (which contains fewer than ten classes, including the one that searches for the other ones?) I didn’t need to, because you probably observed that the above code contains explicit instructions to search for types with names ending in &lt;code class=&quot;highlighter-rouge&quot;&gt;Blarg&lt;/code&gt; &lt;em&gt;only in the assembly containing type &lt;code class=&quot;highlighter-rouge&quot;&gt;FooBlarg&lt;/code&gt;&lt;/em&gt;, the very type this code is meant to “discover.”&lt;/li&gt;
  &lt;li&gt;Is this like writing code to search for your coffee mug by starting from the current location of your coffee mug and then searching for all coffee mugs that occupy the same physical space? You’re on fire.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Searching an assembly for interfaces and implementations is a perfectly sane approach if you haven’t explicitly referenced the assembly (which assumes that the types aren’t in same project as the DI setup code) and don’t know what types you want to use. (Even in that scenario I wouldn’t search for them by name, because magic strings.) MEF exists for that scenario. It’s called a &lt;em&gt;plugin architecture&lt;/em&gt;. Using a plugin architecture to compose several known classes in a single project is not bad code. It is evil code.&lt;/p&gt;

&lt;p&gt;So despite my initial reaction, MEF is not the problem. It’s just not meant to be an IoC container. Perhaps &lt;a href=&quot;https://blogs.msmvps.com/peterritchie/2010/02/24/mef-is-not-an-ioc-container-but-mef-uses-ioc/&quot;&gt;this blog post by a Microsoft MVP&lt;/a&gt; entitled “MEF is not An IoC container; but MEF uses IoC” is also a hint. Another is that Googling “.net dependency injection containers” returns numerous lists containing popular libraries like Autofac, Windsor, Ninject, SimpleInjector, and Unity, followed by several others I’ve never heard of before, but not one of which mentions MEF, because &lt;em&gt;MEF is not an IoC container.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;If you need to select an IoC container as a standard for everyone to use and are considering MEF, Newtonsoft.JSON, EPPlus, or anything else which is not a dependency injection container, please use &lt;a href=&quot;https://www.randomlists.com/list-randomizer?items=Spring.NET%0AStructureMap%0ACastle%20Windsor%0AAutofac%0AUnity%0ANinject%0ADryLoc%0ALinFu%0APicoContainer.NET%0AS2Container.Net&amp;amp;qty=1&amp;amp;dup=false&quot;&gt;this tool I have configured&lt;/a&gt; which will help you select something more suitable than MEF.&lt;/p&gt;

&lt;p&gt;And if I’m dead wrong and MEF is meant for general use as an IoC container in common scenarios where we don’t need to discover types and don’t want to plaster our code with redundant attributes, please email me as quickly as possible before something happens to you and that knowledge disappears forever.&lt;/p&gt;

&lt;h3 id=&quot;saved-by-pure-di&quot;&gt;Saved By Pure DI&lt;/h3&gt;
&lt;p&gt;How would I replace Windsor with MEF (which is not an IoC container?) How would I configure named dependencies and abstract factories?&lt;/p&gt;

&lt;p&gt;I realized a few things:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;I was only working with about a dozen types, and of those, the consuming application only needed to interact with a single interface.&lt;/li&gt;
  &lt;li&gt;My classes were stateless, so I didn’t need to worry about using a container to manage object lifetimes.&lt;/li&gt;
  &lt;li&gt;The implementations of my abstract factories looked more complicated than what they needed to be. They weren’t bad, but they would take about three minutes to explain to someone unfamiliar with Windsor, as opposed to the rest of the configuration which someone who had never seen Windsor could understand the moment they saw it, at which point they would immediately understand 80% of how to use Windsor or any other container. I like to make things easy for people, but I also start off assuming that they are as smart and capable as I am. If I know something they don’t, maybe they know three other things I don’t. But I’ve digressed. My abstract factories were unnecessarily complicated.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I tend to use an IoC container out of habit because even with a smaller number of classes I prefer it to calling nested constructors. I also thought that in this case using Windsor for a simple configuration would provide a useful example. But if the only IoC container I can use isn’t an IoC container at all, then perhaps the better choice is no container at all, A.K.A. Pure DI. (It’s also called “Poor Man’s DI,” which implies that it’s always undesirable, that IoC containers aren’t free open-source software, and that all developers are men.)&lt;/p&gt;

&lt;p&gt;Remember, dependency injection isn’t using a container. It’s how we write our classes. The classes themselves don’t know whether they’re being created using a container or by calling their constructors the “normal” way. If they do need the container to function then we’ve done something wrong. Poor Man’s DI means that having created classes that rely on dependency injection, we create them the old-fashioned way, without a container.&lt;/p&gt;

&lt;p&gt;The result was different from what I’m used to, but all things considered it wasn’t end-of-the-world horrible either. To briefly summarize (and obsfucate) the application receives binary data in a byte array along with a string that indicates what sort of data it has received. It uses the string to determine which implementation of &lt;code class=&quot;highlighter-rouge&quot;&gt;IFoo&lt;/code&gt; should be created to process the data. (That’s where the abstract factory came in.) Here’s the factory implementation which replaces what I had done with Windsor:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;FooFactory&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Dictionary&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_foos&lt;/span&gt;
            &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Dictionary&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;StringComparer&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;OrdinalIgnoreCase&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;FooFactory&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;c1&quot;&gt;// shared&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;fooWidget&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;FooWidget&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;WidgetProvider&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;WidgetBuilder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(),&lt;/span&gt;
                    &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[]&lt;/span&gt;
                    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
                        &lt;span class=&quot;n&quot;&gt;TypeConversions&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AdjustIncompatibleTypes&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;//injecting delegates&lt;/span&gt;
                        &lt;span class=&quot;n&quot;&gt;TypeConversions&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;AdjustInvalidStrings&lt;/span&gt;     &lt;span class=&quot;c1&quot;&gt;//instead of interfaces&lt;/span&gt;
                    &lt;span class=&quot;p&quot;&gt;}));&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;fooMapper&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;FooMapper&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;BlargFormatter&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(),&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;PaulaBeanFormatter&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;());&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dataValidator&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;SpecializedFormatDataValidator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;

            &lt;span class=&quot;c1&quot;&gt;// Red (the same Foo is used for two data types)&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;blueSpecializedFormatReader&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;BlueSpecializedFormatReader&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dataValidator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;redFoo&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;RedFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;blueSpecializedFormatReader&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;fooWidget&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; 
                &lt;span class=&quot;n&quot;&gt;fooMapper&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;FooDirectories&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;GetDirectory&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_foos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Add&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;FooDataTypes&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RedFooOne&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;redFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_foos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Add&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;FooDataTypes&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RedFooTwo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;redFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;

            &lt;span class=&quot;c1&quot;&gt;// Blue&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;blueFooReader&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;SpecializedFormatReader&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dataValidator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;blueFoo&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;BlueFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;FooTypeSelector&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(),&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;FooDirectories&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;GetDirectory&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;blueFooReader&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;fooWidget&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;fooMapper&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_foos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Add&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;FooDataTypes&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;BlueFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;blueFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;

            &lt;span class=&quot;c1&quot;&gt;// Green&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;greenFoo&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GreenFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;fooWidget&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;fooMapper&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_foos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Add&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;FooDataTypes&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;GreenFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt;
                &lt;span class=&quot;n&quot;&gt;greenFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IFoo&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;GetFoo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;string&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dataType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;if&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;_foos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;ContainsKey&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dataType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;))&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_foos&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dataType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;];&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;throw&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ArgumentException&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;$&quot;No foo is specified for data type &lt;/span&gt;&lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;dataType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;As you can see, I’m creating the various implementations of &lt;code class=&quot;highlighter-rouge&quot;&gt;IFoo&lt;/code&gt; and putting them in a &lt;code class=&quot;highlighter-rouge&quot;&gt;Dictionary&amp;lt;string, IFoo&amp;gt;&lt;/code&gt; so I can call &lt;code class=&quot;highlighter-rouge&quot;&gt;GetFoo&lt;/code&gt; to retrieve the implementation I need at runtime.&lt;/p&gt;

&lt;p&gt;To emphasize, this isn’t my first choice. These nested constructor calls look like an example to demonstrate why we use an IoC container instead of doing this. Someone could reasonably be puzzled and wonder why I didn’t. On the other hand:&lt;/p&gt;
&lt;ul&gt;
  &lt;li&gt;While Windsor or Autofac aren’t hard to understand, reading this doesn’t require anyone to learn anything new. (Composing this with an IoC container so that people could see it and learn something new would be arguably better, but you can’t win them all.)&lt;/li&gt;
  &lt;li&gt;The longest method isn’t that long. If it gets any longer I can easily break it up into smaller methods.&lt;/li&gt;
  &lt;li&gt;I ended up eliminating some slightly overcomplicated abstract factory code and combining my class composition with the factory that produces instances of &lt;code class=&quot;highlighter-rouge&quot;&gt;IFoo&lt;/code&gt;, which meant less code overall.&lt;/li&gt;
  &lt;li&gt;It’s easy to catch missing components in a DI registrations with tests, but now I get instant compiler errors if I miss a constructor argument.&lt;/li&gt;
  &lt;li&gt;If I need to include some other dependency that isn’t created within this factory, I can inject it into the factory, and then into the classes that need it.&lt;/li&gt;
  &lt;li&gt;Both my production code and my integration tests used my Windsor factory to create test subjects. Now they use this factory. I didn’t have to change a thing.&lt;/li&gt;
  &lt;li&gt;I didn’t violate all that is natural and decent by writing evil, fragile code that searches my interfaces and classes to “find” types I already know about.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It wouldn’t take much for this approach to become problematic. For example, what if I needed scopes or to create more than just implementations of &lt;code class=&quot;highlighter-rouge&quot;&gt;IFoo&lt;/code&gt;? I wouldn’t want to make the above code bigger and more complex or have several such “factory” classes. What if I needed to create unrelated class instances that shared certain dependencies? An IoC container makes that easier by creating a dependency once and reusing it wherever it’s needed. But now I’ve proven that my code is decoupled from whatever method I use to compose class instances, so I can change it back again as needed. Someone could even bend time and space to use MEF if they wanted to.&lt;/p&gt;

&lt;p&gt;Still, I had fallen into a comfortable rut of always doing things the same way, so it was oddly liberating to realize that my pure DI version was in some ways simpler and better than my Windsor version. It’s nice to take something away and see that you can live without it.&lt;/p&gt;
</description>
        <pubDate>Sun, 16 Dec 2018 04:20:58 -0500</pubDate>
        <link>http://scotthannen.org/blog/2018/12/16/liberation-of-pure-di-mef-is-not-ioc.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2018/12/16/liberation-of-pure-di-mef-is-not-ioc.html</guid>
        
        <category>dependency</category>
        
        <category>injection,</category>
        
        <category>mef,</category>
        
        <category>ioc,</category>
        
        <category>pure</category>
        
        <category>di</category>
        
        
        <category>blog</category>
        
      </item>
    
      <item>
        <title>How I Learned to Stop Worrying and Love the Service Locator</title>
        <description>&lt;p&gt;Service locators are an anti-pattern. They are what we used before we learned about dependency injection. If you already know what a service locator is and why it’s harmful (it’s unethical to explain one without the other) then skip past this first heading.&lt;/p&gt;

&lt;h3 id=&quot;why-service-locators-are-evil&quot;&gt;Why Service Locators are Evil&lt;/h3&gt;

&lt;p&gt;To briefly illustrate what a service locator is and why it’s bad, here’s a “good” class with an injected abstract dependency:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ClassWithADependency&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IDoesSomethingINeed&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_somethingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ClassWithADependency&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDoesSomethingINeed&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;somethingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_somethingINeed&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;somethingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;It’s easy to tell what the class depends on. It depends on &lt;code class=&quot;highlighter-rouge&quot;&gt;IDoesSomethingINeed&lt;/code&gt;. The class is easy to test. We can use a mock or test double as the dependency.&lt;/p&gt;

&lt;p&gt;A service locator is a class that we ask to provide an instance of some dependency for us. It could be an instantiated class or a static class. We might call it like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ClassWithADependency&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Blarg&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;somethingINeed&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ServiceLocator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;GetService&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDoesSomethingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;somethingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DoIt&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;It seems convenient. Our logic for creating class instances is hidden away inside of &lt;code class=&quot;highlighter-rouge&quot;&gt;ServiceLocator&lt;/code&gt;. But there are a few big problems:&lt;/p&gt;

&lt;p&gt;First, it’s no longer easy to tell what any class depends on. If I’m injecting dependencies in the constructor it’s easy to tell if my class is getting out of control when it has five, six, or a dozen dependencies. The service locator allows us to hide a dependency on absolutely anything in any method. I can do this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;SomeMethodDeepWithinMyClass&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;whatIsThis&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ServiceLocator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;GetService&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;SomethingTotallyUnrelatedToWhatThisClassShouldDo&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt; 
        &lt;span class=&quot;n&quot;&gt;whatIsThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DoWhoKnowsWhat&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;This makes it far more convenient to complicate and couple code by adding random dependencies all over the place. The service locator is like a &lt;a href=&quot;https://en.wikipedia.org/wiki/Broken_windows_theory&quot;&gt;broken window&lt;/a&gt;. Once one developer does it, the rest join in.&lt;/p&gt;

&lt;p&gt;Second, a class littered with calls to a service locator is difficult to test. If the service locator is a static class then within a unit test you have to configure that static class to return mocks or test doubles, which is more complex than just injecting the mock where it’s needed. Or, if the service locator is itself injected as a dependency, then we have to create a mock that returns more mocks, like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;somethingINeedMock&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDoesSomethingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;somethingINeedMock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Setup&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;GetSomeValue&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()).&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Returns&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;theValue&quot;&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;serviceLocatorMock&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IServiceLocator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
    &lt;span class=&quot;n&quot;&gt;serviceLocatorMock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Setup&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;x&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;x&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Resolve&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDoesSomethingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;()).&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Returns&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;somethingINeedMock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Object&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;It’s not catastrophic at first but it gets out of control fast. I’ve seen cases where developers just give up because they can’t keep track of what dependencies a class gets from the service locator, so they use setup methods that create service locator mocks that return mocks of everything, whether an individual test needs it or not. At that point it’s nearly impossible to tell what you’re actually testing.&lt;/p&gt;

&lt;p&gt;(You may have noticed that a call to a service locator looks a lot like a call to resolve something from a dependency injection container. In fact, if we were to call the container directly from most classes, then that would be using the container as a service locator.)&lt;/p&gt;

&lt;h3 id=&quot;when-we-need-a-service-locator&quot;&gt;When We Need a Service Locator&lt;/h3&gt;

&lt;p&gt;In order to properly use dependency injection, we need to control how classes are created at the composition root. ASP.NET Core controllers are an example. They are the classes created to handle incoming requests, and at application startup we can configure them to expect injection of certain dependencies. If those dependencies have their own dependencies, we inject those too. It’s depedency injection all the way down. There’s no need to for a controller to directly resolve something from &lt;code class=&quot;highlighter-rouge&quot;&gt;ServiceProvider&lt;/code&gt; (.NET Core’s dependency injection container), using it like a service locator.&lt;/p&gt;

&lt;p&gt;Sometimes properly configuring dependency injection just isn’t an option. What if we’re working in an old WebForms app? WebForms was recently updated to support dependency injection, but it may be too late if you’re working in an old app.&lt;/p&gt;

&lt;p&gt;Or, what if you need to work on an existing class and the composition root is hopelessly mangled beyond comprehension? Suppose the class you need to modify looks like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ClassINeedToModify&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ItInheritsFromThis&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ClassINeedToModify&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;DependsOnThis&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; 
            &lt;span class=&quot;n&quot;&gt;AndThis&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;otherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;,&lt;/span&gt; 
            &lt;span class=&quot;n&quot;&gt;KitchenSink&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;kitchenSink&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt; 
            &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;base&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;kitchenSink&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;thing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;DoSomethingEvil&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;otherThing&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;And, by the way, &lt;code class=&quot;highlighter-rouge&quot;&gt;ItInheritsFromThis&lt;/code&gt; is a giant god class that you can’t modify because half the application depends on it. And it’s all created by calling constructors using values from even more static classes with no dependency injection container in sight.&lt;/p&gt;

&lt;p&gt;Now you’re out of luck. You want to add new functionality using small, sanely designed, testable classes that employ dependency injection, but the sorry state of the application’s composition root makes it impossible to properly inject your new dependencies into the existing class.&lt;/p&gt;

&lt;p&gt;What do we do? Give up and pile onto the mess? Here are a few options.&lt;/p&gt;

&lt;h3 id=&quot;dependency-injection-with-defaults&quot;&gt;Dependency Injection With Defaults&lt;/h3&gt;

&lt;p&gt;This might get us where we need to be:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ClassINeedToAddToTheMess&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IDependsOnThis&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_dependency&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ClassINeedToAddToTheMess&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDependsOnThis&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dependency&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;null&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_dependency&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;dependency&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;??&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now we can instantiate a new instance of &lt;code class=&quot;highlighter-rouge&quot;&gt;ClassINeedToAddToTheMess&lt;/code&gt; and it will create its own default dependenies, but we can test the class using mocks.&lt;/p&gt;

&lt;p&gt;This suffices in some cases where we don’t have a lot of nested dependencies and don’t need to do anything complicated.&lt;/p&gt;

&lt;p&gt;But what if we need to construct more complex dependencies using named components and abstract factories - the sort of thing that a dependency injection container facilitates?&lt;/p&gt;

&lt;h3 id=&quot;create-your-own-composition-root-and-expose-it-with-a-service-locator&quot;&gt;Create Your Own Composition Root and Expose It With a Service Locator&lt;/h3&gt;

&lt;p&gt;Yes, i’m recommending that you expose yourself to scorn, ridicule, and self-loathing by deliberately and knowingly implementing a recognized anti-pattern. Maybe you’ll feel better if you add a comment like this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;c1&quot;&gt;// I’m so sorry that I had to implement a service locator. There was no other way. Forgive me!&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;You might feel even better if you write this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;cm&quot;&gt;/* Yes, this is a service locator. I’m not happy about it. But it wasn’t my idea to mangle 
     * the composition root so thoroughly that it’s impossible to properly inject anything into 
     * this third-level inherited god class, which by the way is also an anti-pattern. 
     */&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;A happier way to think about it is that you’re creating a new composition root from which to resolve your classes.&lt;/p&gt;

&lt;p&gt;How do we do it? The same way we would if were going to correctly configure and use a dependency injection container. We can start by creating a class that configures the container. &lt;a href=&quot;/blog/2018/04/03/tame-your-dependency-injection-registration.html&quot;&gt;This post&lt;/a&gt; is largely devoted to that topic.&lt;/p&gt;

&lt;p&gt;For an example, using &lt;a href=&quot;https://autofac.org/&quot;&gt;Autofac&lt;/a&gt;:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ClassINeedToAddAutofacModule&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Module&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;protected&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;override&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Load&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ContainerBuilder&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;builder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;builder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RegisterType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ClassINeedToAddToTheMess&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;().&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;As&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IClassINeedToAddToTheMess&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;builder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RegisterType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;().&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;As&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Notice that it’s specific. We’re creating a single dependency for our unfortunate god class, so we’re limiting this to configuring that one dependency and its dependencies. As a bonus, this is reusable if the application ever gets refactored so that we can use a dependency injection container the way we’d like to.&lt;/p&gt;

&lt;p&gt;What if we need to register a dependency on something created by the god class? For example, the god class writes log data using a &lt;a href=&quot;https://docs.microsoft.com/en-us/dotnet/api/microsoft.applicationinsights.telemetryclient?view=azure-dotnet&quot;&gt;&lt;code class=&quot;highlighter-rouge&quot;&gt;TelemetryClient&lt;/code&gt;&lt;/a&gt; it creates, but we don’t want our new classes coupled to &lt;code class=&quot;highlighter-rouge&quot;&gt;TelemetryClient&lt;/code&gt;. We can work with that.&lt;/p&gt;

&lt;p&gt;First, we create the abstraction that we do want to depend on:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;interface&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ILogger&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;LogException&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Exception&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ex&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Then we create an implementation that depends on &lt;code class=&quot;highlighter-rouge&quot;&gt;TelemetryClient&lt;/code&gt;:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;TelemetryClientLogger&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ILogger&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;TelemetryClient&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_telemetryClient&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;TelemetryClientLogger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TelemetryClient&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;telemetryClient&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_telemetryClient&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;telemetryClient&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;LogException&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Exception&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ex&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_telemetryClient&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;TrackException&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ex&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Then we modify our module so that it depends on an &lt;code class=&quot;highlighter-rouge&quot;&gt;ILogger&lt;/code&gt;.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;ClassINeedToAddAutofacModule&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;:&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Module&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;ILogger&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_logger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoesSomethingINeedAutofacModule&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ILogger&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;logger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_logger&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;logger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;protected&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;override&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Load&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ContainerBuilder&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;builder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;builder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RegisterType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ClassINeedToAddToTheMess&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;().&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;As&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IClassINeedToAddToTheMess&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;builder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;RegisterType&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;DependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;().&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;As&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDependsOnThis&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;builder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Register&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;c&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_logger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;).&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;As&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ILogger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Now the classes created within our composition root can depend on the abstraction.&lt;/p&gt;

&lt;h3 id=&quot;inserting-our-service-locator&quot;&gt;Inserting Our Service Locator&lt;/h3&gt;

&lt;p&gt;This is the slightly distasteful part. Our service locator can be an instantiated class or a static class. It doesn’t really matter because either way it won’t be testable within the context of our god class. Remember, we’re not creating that problem. The idea is to inject dependencies instead of instantiating them, but the fact that we can’t is the reason why we’re going this route. The existing code might not be testable. We’re just doing our best to ensure that the &lt;em&gt;new&lt;/em&gt; classes we integrate with it are composed and testable.&lt;/p&gt;

&lt;p&gt;Here is the service locator class. I considered calling it a “factory” because it sounds better, but let’s just call it what it is.&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;DoesSomethingINeedLocator&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;readonly&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IContainer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_container&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;;&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoesSomethingINeedLocator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ILogger&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;logger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;)&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;containerBuilder&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ContainerBuilder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;containerBuilder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;RegisterModule&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ClassINeedToAddAutofacModule&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;logger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;));&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;_container&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;containerBuilder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Build&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;

        &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;IDoesSomethingINeed&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;Locate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;_container&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Resolve&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IDoesSomethingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;To make this a little less icky, the service locator explicitly returns only one type of dependency. There is no &lt;code class=&quot;highlighter-rouge&quot;&gt;Get&amp;lt;TAnything&amp;gt;()&lt;/code&gt; function.&lt;/p&gt;

&lt;p&gt;Now the god class, which was already creating and using its own &lt;code class=&quot;highlighter-rouge&quot;&gt;TelemetryClient&lt;/code&gt;, can call this:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thingINeedLocator&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;DoesSomethingINeedLocator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;_telemetryClientItAlreadyCreated&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;);&lt;/span&gt;
    &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thingINeed&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;thingINeedLocator&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Locate&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;Because we’re creating a class instance - calling &lt;code class=&quot;highlighter-rouge&quot;&gt;new&lt;/code&gt; to instantiate a new object - we can’t mock this dependency, so the god class is less testable. The trade-off is that the classes it returns - all of the new stuff - use dependency injection, are testable, and don’t have any reference to the container.&lt;/p&gt;

&lt;p&gt;We want our composition root with all its references to the container to be at application startup, far away from the business end of application. Since we can’t, we’ve planted a new composition root where we need it and done our best to keep it tidy.&lt;/p&gt;

&lt;h3 id=&quot;its-testable&quot;&gt;It’s Testable&lt;/h3&gt;

&lt;p&gt;When we compose classes using a dependency injection container, we get a runtime error if we missed registering a dependency. We don’t need to run the application and wait for an exception to see if we’ve missed anything. We can write a unit test:&lt;/p&gt;

&lt;div class=&quot;language-csharp highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &lt;span class=&quot;p&quot;&gt;[&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;TestMethod&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;]&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;AutofacModuleResolvesThingINeed&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;()&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;logger&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;Mock&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;ILogger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
        &lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;containerBuilder&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ContainerBuilder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;();&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;containerBuilder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;RegisterModule&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;ClassINeedToAddAutofacModule&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;logger&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Object&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;));&lt;/span&gt;
        &lt;span class=&quot;k&quot;&gt;using&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;kt&quot;&gt;var&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;container&lt;/span&gt; &lt;span class=&quot;p&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;containerBuilder&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;nf&quot;&gt;Build&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;())&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;{&lt;/span&gt;
            &lt;span class=&quot;n&quot;&gt;container&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;Resolve&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;lt;&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;IClassINeedToAddToTheMess&lt;/span&gt;&lt;span class=&quot;p&quot;&gt;&amp;gt;();&lt;/span&gt;
        &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
    &lt;span class=&quot;p&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h3 id=&quot;is-it-worth-it&quot;&gt;Is It Worth It?&lt;/h3&gt;

&lt;p&gt;If the new classes you need to create are complex and contain a lot of nested dependencies, then yes, it is.&lt;/p&gt;

&lt;p&gt;This approach is satisfying because it draws a line between the legacy code I’m working in and the new code I’m writing. The legacy classes don’t allow me to inject dependencies, but my new ones do. The service locator is the bridge between them. That lets me work the way I’m used to, creating small, testable classes that I can compose using a dependency injection container.&lt;/p&gt;

</description>
        <pubDate>Tue, 27 Nov 2018 04:20:58 -0500</pubDate>
        <link>http://scotthannen.org/blog/2018/11/27/stop-worrying-love-service-locator.html</link>
        <guid isPermaLink="true">http://scotthannen.org/blog/2018/11/27/stop-worrying-love-service-locator.html</guid>
        
        
        <category>blog</category>
        
      </item>
    
  </channel>
</rss>