Difference between IOptionsMonitor vs. IOptionsSnapshot : <p>According to <a href="https://stackoverflow.com/a/46570073/1987788">this answer</a>, <code>IOptionsMonitor</code> is registered in DI container as <strong>singleton</strong> and is capable of detecting changes through <code>OnChange</code> event subscription. It has a <code>CurrentValue</code> property.</p>

<p>In the other hand, <code>IOptionsSnapshot</code> is registered as <strong>scoped</strong> and also have a change detection capability by reading the last options for each request, but it doesn't have the <code>OnChange</code> event. It has a <code>Value</code> property.</p>

<p>Using both injected into a view for instance gives us the exactly same behavior:</p>

<pre><code>using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Options;
using UsingOptionsSample.Models;
using UsingOptionsSample.Services;

namespace UsingOptionsSample.Pages
{
    public class MyOptions
    {
        public MyOptions()
        {
            // Set default value.
            Option1 = "value1_from_ctor";
        }

        public string Option1 { get; set; }
        public int Option2 { get; set; } = 5;
    }

    public class OptionsTestModel : PageModel
    {
        private readonly MyOptions _snapshotOptions;
        private readonly MyOptions _monitorOptions;

        public OptionsTestModel(
            IOptionsMonitor&lt;MyOptions&gt; monitorOptionsAcessor, 
            IOptionsSnapshot&lt;MyOptions&gt; snapshotOptionsAccessor)
        {
            _snapshotOptions = snapshotOptionsAccessor.Value;
            _monitorOptions = monitorOptionsAcessor.CurrentValue;
        }

        public string SnapshotOptions { get; private set; }
        public string MonitorOptions { get; private set; }

        public void OnGetAsync()
        {
             //Snapshot options
            var snapshotOption1 = _snapshotOptions.Option1;
            var snapshotOption2 = _snapshotOptions.Option2;
            SnapshotOptions =
                $"snapshot option1 = {snapshotOption1}, " +
                $"snapshot option2 = {snapshotOption2}";

            //Monitor options
            var monitorOption1 = _monitorOptions.Option1;
            var monitorOption2 = _monitorOptions.Option2;
            MonitorOptions =
                $"monitor option1 = {monitorOption1}, " +
                $"monitor option2 = {monitorOption2}";
        }
    }
}
</code></pre>

<p>So, what's the point of having these two interfaces/implementation if they look like the same thing, just with different life times? The code is <a href="https://github.com/aspnet/Docs/tree/master/aspnetcore/fundamentals/configuration/options/sample" rel="noreferrer">based on this sample</a>, which surprisinly doesn't include an <code>IOptionsMonitor</code> usage sample.</p>

<p>Why one have a "Value" property and other have "CurrentValue" if both gets the "current value" of an option?</p>

<p>Why/when should I use <code>IOptionsSnapshot</code> instead of <code>IOptionsMonitor</code>?</p>

<p>I don't think I got it straight, I must be missing some very important aspect regarding these dependencies injection.</p>
