Demo of an OptionalDependency helper class which should prevent modifying an optional dependency (see Property Injection pattern) in the middle of a class's lifetime.

OptionalDependency.cs

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

sealed class OptionalDependency<T> where T : class
{
    private OptionalDependency() { }

    private OptionalDependency(T defaultDependency)
    {
        if (defaultDependency == null)
        {
            throw new ArgumentNullException("defaultDependency");
        }
        _value = defaultDependency;
        _accessed = false;
    }

    public static implicit operator OptionalDependency<T>(T t)
    {
        return new OptionalDependency<T>(t);
    }

    private bool _accessed;
    private T _value;
    public T Value
    {
        get
        {
            _accessed = true;
            return _value;
        }

        set
        {
            if (_accessed)
            {
                throw new NotSupportedException("Dependency has already been accessed and cannot be changed.");
            }

            if (value == null)
            {
                throw new ArgumentNullException();
            }

            _value = value;
        }
    }
}

class SomeClass
{
    private readonly OptionalDependency<ISomeInterface> _dependency;
    public ISomeInterface Dependency
    {
        get { return _dependency.Value; }
        set { _dependency.Value = value; }
    }

    public SomeClass()
    {
        _dependency = new DefaultImplementation();
    }
}

interface ISomeInterface
{
    bool Operation();
}

class DefaultImplementation : ISomeInterface
{
    public bool Operation()
    {
        return true;
    }
}

class OtherImplementation : ISomeInterface
{
    public bool Operation()
    {
        return false;
    }
}

[TestClass]
public class OptionalDependencyTests
{
    [TestMethod]
    public void CanSetUsingPropertyInitializerBar()
    {
        var b = new SomeClass { Dependency = new OtherImplementation() };
        b.Dependency = new OtherImplementation();

        Assert.IsFalse(b.Dependency.Operation());

        try
        {
            b.Dependency = new DefaultImplementation();
            Assert.Fail("Shold have thrown exception");
        }
        catch (NotSupportedException)
        {
        }
    }
}