Accessing privates

accessor.cs

using FluentAssertions;
using System;
using System.Reflection;
using Xunit;

namespace cookbook.Reflection
{
    public class TestAccessor
    {
        private object _instance;
        private Type _type;

        public TestAccessor(object instance)
        {
            _instance = instance;
            _type = instance.GetType();
        }

        public T GetField<T>(string name)
        {
            FieldInfo info = _type.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
            return (T)info.GetValue(_instance);
        }

        public void SetField<T>(string name, T value)
        {
            FieldInfo info = _type.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
            info.SetValue(_instance, value);
        }
    }

    public class MyClass
    {
        private int _value;
        private Version _version;
    }

    public class MyClassTestAccessor : TestAccessor
    {
        public MyClassTestAccessor(MyClass instance)
            : base(instance) { }

        public int Value
        {
            get => GetField<int>("_value");
            set => SetField("_value", value);
        }

        public Version Version
        {
            get => GetField<Version>("_version");
            set => SetField("_version", value);
        }
    }

    public static partial class Accessors
    {
        public static MyClassTestAccessor TestAccessor(this MyClass myClass)
            => new MyClassTestAccessor(myClass);

        public static TestAccessor TestAccessor(this object instance)
            => new TestAccessor(instance);
    }

    public class AccessorTests
    {
        [Fact]
        public void AccessInt()
        {
            MyClass myClass = new MyClass();
            MyClassTestAccessor accessor = new MyClassTestAccessor(myClass);
            accessor.Value.Should().Be(0);
            accessor.Value = 4;
            accessor.Value.Should().Be(4);
        }

        [Fact]
        public void AccessIntViaExtension()
        {
            MyClass myClass = new MyClass();
            myClass.TestAccessor().Value.Should().Be(0);
            myClass.TestAccessor().Value = 4;
            myClass.TestAccessor().Value.Should().Be(4);
        }

        [Fact]
        public void NoWrapperWritten()
        {
            Version version = new Version(4, 1);
            version.TestAccessor().GetField<int>("_Major").Should().Be(4);
        }
    }
}