Latch object and some related behavior

Latch.cs

namespace System
{
    public class Latch
    {
        public static explicit operator Latch(bool isSet)
        {
            return new Latch(isSet);
        }

        public static implicit operator bool(Latch latch)
        {
            return latch._isSet;
        }

        private bool _isSet;

        public Latch(bool isSet = false)
        {
            _isSet = isSet;
        }

        public void Set()
        {
            _isSet = true;
        }

        public void Clear()
        {
            _isSet = false;
        }

        public override string ToString()
        {
            return _isSet.ToString();
        }

        public IDisposable SetTemporarily()
        {
            Set();
            return new DisposableAction(Clear);
        }
    }
}

SomeGuardingActor.cs

public class SomeGuardingActor
{
    private readonly Latch _open = new Latch();

    // This structure is a common usage of the Latch, a gaurd clause and
    // a matching Set. It would be nice to have a safer syntax, like
    // 
    // using(_open.GaurdThenSet()) { ... }
    // 
    public void Open()
    {
        if(_open)
            return;

        // ... open ...
        _open.Set();
    }

    public void Close()
    {
        if(!_open)
            return;

        // ... close ...
        _open.Clear();
    }
}

SomeTemporaryActor.cs

public class SomeTemporaryActor.cs
{
    private readonly Latch _editable = new Latch();

    private void OnSomeValueModified(object sender, EventArgs e)
    {
        if(!_editable)
            return;

        // ... track changes ...
    }

    public void Modify(string value)
    {
        using(_editable.SetTemporarily())
        {
            SomeValue = value;
        }
    }
}