Read-once variable - R1V, ROV, ... - in C#

With only a bit of twitches you can get a much more flexible design:

public class ReadValueOnlyXTimesThingy<T>
{
    private T _value;

    public R1V(int maxNumberOfReads, T value)
    {
        if(maxNumberOfReads <= 0) throw new ArgumentOutOfRangeException("maxNumberOfReads must be a positive value");
        ReadsLeft = maxNumberOfReads;
        _value = value;
    }

    public int ReadsLeft {get; private set;}

    public T Value 
    {
        get
        {
            if(ReadsLeft <= 0)
            {
                _value = default(T);
            }
            ReadsLeft--;
            return _value;
        } 
    }
}

And the usage:

var selfDestructingMessage = new ReadValueOnlyXTimesThingy<string>(3, "this message will self destruct after 3 reads.");

// some code here

var theMessage = selfDestructingMessage.Value;

Notes:

1. This allows as many reads as set in it's constructor.
2. In case T is a value type, it's default will return a value - 0 for numbers, false for bool and so on. This might not be a desirable outcome once the value have been read the allowed number of times, since it's default value might be indistinguishable from the previous value (think of initializing this class with 1, false - you'll always get false back. One way to handle this is to restrict the T to reference types only, another is to change the property return type to a tuple of bool, T - or perhaps throw an exception - Though that would probably be the last thing I would recommend - as this kind of thing is what Eric Lippert would call a vexing exception, and as usual, he knows what he is writing about.

Hey Bruce,

Here is my variant:

public class R1V<Type>{
        private readonly Type _value;

        R1V(Type value){
            _value = value;
        }

        Type Get(){
            try{
                return _value;
            }
            finally{
                _value = null;
            }
        }
    }

A little late to the party, but here's my implementation using implicit conversion to and from the ReadLimit class.

class ReadLimit<T>
{
    private T _value;
    private readonly T _default;
    private int _maxReads;

    public ReadLimit(T value, int maxReads = 1, T defaultValue = default(T))
    {
        _value = value;
        _default = defaultValue;
        _maxReads = maxReads;
    }

    public int Reads { get; private set; }

    public T Value => Reads++ == _maxReads ? (_value = _default) : _value;

    public override string ToString() => Value?.ToString();

    public static implicit operator T(ReadLimit<T> limit) => limit.Value;

    public static implicit operator ReadLimit<T>(T value) => new ReadLimit<T>(value);
}

Thanks to everyone who contributed.

As I was fiddling with this, I thought, "hey why not just"

        public T Value
        {
            get
            {
                var _returning = _value;
                _value = default(T);
                return _returning;
            }
        }

Well, that's fine until you do this

            var r1vc = new R1V<Klasse>(new Klasse() { klasse = "Hello, Class" });
            Console.WriteLine(r1vc.Value.klasse);
            Console.WriteLine(r1vc.Value.klasse);

after having defined the class Klasse as

    public class Klasse
    {
        public string klasse { get; set; }
    }

The first WriteLine gives "Hello, Class" but the second one throw an error, namely {"Object reference not set to an instance of an object."} when evaluating var _returning = _value; so one must have atry{}finally{} in the property declaration.

LATER

In fact, even

            try{
                return _value;
            }
            finally{
                _value = null;
            }

doesn't cut it in the Klasse version.

LATER AGAIN

Actually, it does cut it. So perhaps the first one is okay too. The problem is in the second Console.WriteLine(r1vc.Value.klasse); because the second r1vc.Value returns null. So getting klasse of null is an error. Soooooo ... I need to do something like

            Console.WriteLine(r1vc.Value == null ? "" : r1vc.Value.klasse);

I use System.Threading.Channels for this. Read this if you want a super detailed introduction to channels in general. For your specific problem, I simply make a bounded channel with a capacity of 1.

var channel = Channel.CreateBounded<int>(1);

I love that the designers made the decision to have a separate ChannelReader<T> and ChannelWriter<T>. You can simply pass channel.Reader to your consumer and channel.Writer to your producer (if you desire that separation). This will give you what you want. You can call channel.Reader.TryRead. If it succeeds, it will be removed from the channel. Otherwise, it just informs you there was no value to take.

if (channel.Reader.TryRead(out var value))
{
    // Use the value.
}

Channels can be further customized by way of BoundedChannelOptions. For instance, you can specify BoundedChannelFullMode, which determines the desired outcome if you attempt to write to the channel when it's already full.