Import v2 code.

Author: tyranid

EditSection/App.config

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <configuration>
     <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1"/>
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8.1"/>
     </startup>
 </configuration>

EditSection/CorruptSectionForm.Designer.cs

@@ -17,90 +17,81 @@
 using System.Text;
 using System.Windows.Forms;
 
-namespace EditSection
-{
-    partial class CorruptSectionForm : Form
-    {        
-        ICorruptSection _corrupt_section;
+namespace EditSection;
 
-        public CorruptSectionForm()
+partial class CorruptSectionForm : Form
+{        
+    public CorruptSectionForm()
+    {
+        InitializeComponent();
+        foreach (object value in Enum.GetValues(typeof(CorruptSectionOperation)))
         {
-            InitializeComponent();
-            foreach (object value in Enum.GetValues(typeof(CorruptSectionOperation)))
-            {
-                comboBoxRandomOperation.Items.Add(value);
-                comboBoxFixedOperation.Items.Add(value);
-                comboBoxStringOperation.Items.Add(value);
-            }
-
-            comboBoxRandomOperation.SelectedIndex = 0;
-            comboBoxFixedOperation.SelectedIndex = 0;
-            comboBoxStringOperation.SelectedIndex = 0;
+            comboBoxRandomOperation.Items.Add(value);
+            comboBoxFixedOperation.Items.Add(value);
+            comboBoxStringOperation.Items.Add(value);
         }
 
-        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]
-        internal ICorruptSection CorruptSectionObject
-        {
-            get
-            {
-                return _corrupt_section;
-            }
-        }
+        comboBoxRandomOperation.SelectedIndex = 0;
+        comboBoxFixedOperation.SelectedIndex = 0;
+        comboBoxStringOperation.SelectedIndex = 0;
+    }
 
-        private void radioRandom_CheckedChanged(object sender, System.EventArgs e)
-        {
-            groupBoxRandomCorruption.Enabled = radioRandom.Checked;
+    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]
+    internal ICorruptSection? CorruptSectionObject { get; private set; }
 
-        }
+    private void radioRandom_CheckedChanged(object sender, System.EventArgs e)
+    {
+        groupBoxRandomCorruption.Enabled = radioRandom.Checked;
 
-        private void radioFixed_CheckedChanged(object sender, EventArgs e)
-        {
-            groupBoxFixedCorruption.Enabled = radioFixed.Checked;
-        }
+    }
 
-        private void radioString_CheckedChanged(object sender, EventArgs e)
-        {
-            groupBoxStringCorruption.Enabled = radioString.Checked;
-        }
+    private void radioFixed_CheckedChanged(object sender, EventArgs e)
+    {
+        groupBoxFixedCorruption.Enabled = radioFixed.Checked;
+    }
 
-        private void btnOK_Click(object sender, EventArgs e)
-        {
-            bool succes = false;
+    private void radioString_CheckedChanged(object sender, EventArgs e)
+    {
+        groupBoxStringCorruption.Enabled = radioString.Checked;
+    }
 
-            if (radioRandom.Checked)
-            {
-                if (numericMinimum.Value > numericMaximum.Value)
-                {
-                    MessageBox.Show(this, "Minimum value must be less than or equal to maximum", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
-                }
-                else
-                {
-                    _corrupt_section = new CorruptSectionRandomValue((byte)numericMinimum.Value,
-                        (byte)numericMaximum.Value, (CorruptSectionOperation)comboBoxRandomOperation.SelectedItem);
-                    succes = true;
-                }
-            }
-            else if (radioFixed.Checked)
+    private void btnOK_Click(object sender, EventArgs e)
+    {
+        bool succes = false;
+
+        if (radioRandom.Checked)
+        {
+            if (numericMinimum.Value > numericMaximum.Value)
             {
-                byte[] data = new byte[1];
-                data[0] = (byte)numericFixedValue.Value;
-                _corrupt_section = new CorruptSectionFixedValue(data,
-                    (CorruptSectionOperation)comboBoxFixedOperation.SelectedItem);
-                succes = true;
+                MessageBox.Show(this, "Minimum value must be less than or equal to maximum", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
             }
-            else if (radioString.Checked)
+            else
             {
-                byte[] data = Encoding.UTF8.GetBytes(textBoxString.Text);
-                _corrupt_section = new CorruptSectionFixedValue(data,
-                    (CorruptSectionOperation)comboBoxStringOperation.SelectedItem);
+                CorruptSectionObject = new CorruptSectionRandomValue((byte)numericMinimum.Value,
+                    (byte)numericMaximum.Value, (CorruptSectionOperation)comboBoxRandomOperation.SelectedItem);
                 succes = true;
             }
-            
-            if(succes)
-            {
-                DialogResult = DialogResult.OK;
-                Close();
-            }
+        }
+        else if (radioFixed.Checked)
+        {
+            byte[] data = new byte[1];
+            data[0] = (byte)numericFixedValue.Value;
+            CorruptSectionObject = new CorruptSectionFixedValue(data,
+                (CorruptSectionOperation)comboBoxFixedOperation.SelectedItem);
+            succes = true;
+        }
+        else if (radioString.Checked)
+        {
+            byte[] data = Encoding.UTF8.GetBytes(textBoxString.Text);
+            CorruptSectionObject = new CorruptSectionFixedValue(data,
+                (CorruptSectionOperation)comboBoxStringOperation.SelectedItem);
+            succes = true;
+        }
+        
+        if(succes)
+        {
+            DialogResult = DialogResult.OK;
+            Close();
         }
     }
 }

EditSection/CorruptSectionForm.cs

@@ -12,130 +12,128 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 
-using Be.Windows.Forms;
 using System;
 
-namespace EditSection
+namespace EditSection;
+
+enum CorruptSectionOperation
 {
-    enum CorruptSectionOperation
-    {
-        Overwrite,
-        And,
-        Or,
-        Xor
-    }
+    Overwrite,
+    And,
+    Or,
+    Xor
+}
 
-    abstract class CorruptSectionBase : ICorruptSection
+abstract class CorruptSectionBase : ICorruptSection
+{
+    internal static byte ApplyOperationToByte(byte left, byte right, CorruptSectionOperation op)
     {
-        internal static byte ApplyOperationToByte(byte left, byte right, CorruptSectionOperation op)
+        switch (op)
         {
-            switch (op)
-            {
-                case CorruptSectionOperation.Xor:
-                    return (byte)(left ^ right);
-                case CorruptSectionOperation.And:
-                    return (byte)(left & right);
-                case CorruptSectionOperation.Or:
-                    return (byte)(left | right);
-                default:
-                    return right;
-            }
+            case CorruptSectionOperation.Xor:
+                return (byte)(left ^ right);
+            case CorruptSectionOperation.And:
+                return (byte)(left & right);
+            case CorruptSectionOperation.Or:
+                return (byte)(left | right);
+            default:
+                return right;
         }
+    }
 
-        internal static void ApplyOperationToArray(byte[] array, Func<byte> generator, CorruptSectionOperation op)
+    internal static void ApplyOperationToArray(byte[] array, Func<byte> generator, CorruptSectionOperation op)
+    {
+        for (int i = 0; i < array.Length; ++i)
         {
-            for (int i = 0; i < array.Length; ++i)
-            {
-                array[i] = ApplyOperationToByte(array[i], generator(), op);
-            }
+            array[i] = ApplyOperationToByte(array[i], generator(), op);
         }
+    }
 
-        private readonly CorruptSectionOperation _op;
-        private const int CHUNK_LENGTH = 64 * 1024;
+    private readonly CorruptSectionOperation _op;
+    private const int CHUNK_LENGTH = 64 * 1024;
 
-        protected CorruptSectionBase(CorruptSectionOperation op)
-        {
-            _op = op;
-        }
+    protected CorruptSectionBase(CorruptSectionOperation op)
+    {
+        _op = op;
+    }
 
-        protected abstract Func<byte> GetGenerator();
+    protected abstract Func<byte> GetGenerator();
 
-        public void Corrupt(NativeMappedFileByteProvider prov, long start, long end)
+    public void Corrupt(NativeMappedFileByteProvider prov, long start, long end)
+    {
+        try
         {
-            try
+            prov.DisableByteWritten(true);
+            long total_length = end - start;
+            long chunks = total_length / CHUNK_LENGTH;
+            long remaining = total_length % CHUNK_LENGTH;
+            var generator = GetGenerator();
+            byte[] temp_chunk = new byte[CHUNK_LENGTH];
+
+            for (long chunk = 0; chunk < chunks; ++chunk)
             {
-                prov.DisableByteWritten(true);
-                long total_length = end - start;
-                long chunks = total_length / CHUNK_LENGTH;
-                long remaining = total_length % CHUNK_LENGTH;
-                var generator = GetGenerator();
-                byte[] temp_chunk = new byte[CHUNK_LENGTH];
-
-                for (long chunk = 0; chunk < chunks; ++chunk)
-                {
-                    long ofs = start + (chunk * CHUNK_LENGTH);
-                    // No point reading chunk if we're just going to overwrite it.
-                    byte[] data = _op == CorruptSectionOperation.Overwrite ? temp_chunk : prov.ReadBytes(ofs, CHUNK_LENGTH);
-                    ApplyOperationToArray(data, generator, _op);
-                    prov.WriteBytes(ofs, data);
-                }
-
-                if (remaining > 0)
-                {
-                    long ofs = start + (chunks * CHUNK_LENGTH);
-                    byte[] data = _op == CorruptSectionOperation.Overwrite ? temp_chunk : prov.ReadBytes(ofs, (int)remaining);
-                    ApplyOperationToArray(data, generator, _op);
-                    prov.WriteBytes(ofs, data);
-                }
+                long ofs = start + (chunk * CHUNK_LENGTH);
+                // No point reading chunk if we're just going to overwrite it.
+                byte[] data = _op == CorruptSectionOperation.Overwrite ? temp_chunk : prov.ReadBytes(ofs, CHUNK_LENGTH);
+                ApplyOperationToArray(data, generator, _op);
+                prov.WriteBytes(ofs, data);
             }
-            finally
+
+            if (remaining > 0)
             {
-                prov.DisableByteWritten(false);
+                long ofs = start + (chunks * CHUNK_LENGTH);
+                byte[] data = _op == CorruptSectionOperation.Overwrite ? temp_chunk : prov.ReadBytes(ofs, (int)remaining);
+                ApplyOperationToArray(data, generator, _op);
+                prov.WriteBytes(ofs, data);
             }
         }
+        finally
+        {
+            prov.DisableByteWritten(false);
+        }
     }
+}
 
-    class CorruptSectionFixedValue : CorruptSectionBase
+class CorruptSectionFixedValue : CorruptSectionBase
+{
+    private readonly byte[] _data;
+    public CorruptSectionFixedValue(byte[] data, CorruptSectionOperation op) : base(op)
     {
-        private readonly byte[] _data;
-        public CorruptSectionFixedValue(byte[] data, CorruptSectionOperation op) : base(op)
+        if (data.Length < 1)
         {
-            if (data.Length < 1)
-            {
-                throw new ArgumentException("Data array must contain at least one byte");
-            }
-
-            _data = (byte[])data.Clone();
+            throw new ArgumentException("Data array must contain at least one byte");
         }
 
-        protected override Func<byte> GetGenerator()
-        {
-            int data_pos = 0;
-            return () =>
-            {
-                byte ret = _data[data_pos++];
-                data_pos %= _data.Length;
-                return ret;
-            };
-        }
+        _data = (byte[])data.Clone();
     }
 
-    class CorruptSectionRandomValue : CorruptSectionBase
+    protected override Func<byte> GetGenerator()
     {
-        private readonly Random _rand;
-        private readonly int _low_byte;
-        private readonly int _high_byte;
-        
-        public CorruptSectionRandomValue(byte low_byte, byte high_byte, CorruptSectionOperation op) : base(op)
+        int data_pos = 0;
+        return () =>
         {
-            _rand = new Random();
-            _low_byte = low_byte;
-            _high_byte = high_byte + 1;
-        }
+            byte ret = _data[data_pos++];
+            data_pos %= _data.Length;
+            return ret;
+        };
+    }
+}
 
-        protected override Func<byte> GetGenerator()
-        {
-            return () => (byte)_rand.Next(_low_byte, _high_byte);
-        }
+class CorruptSectionRandomValue : CorruptSectionBase
+{
+    private readonly Random _rand;
+    private readonly int _low_byte;
+    private readonly int _high_byte;
+    
+    public CorruptSectionRandomValue(byte low_byte, byte high_byte, CorruptSectionOperation op) : base(op)
+    {
+        _rand = new Random();
+        _low_byte = low_byte;
+        _high_byte = high_byte + 1;
+    }
+
+    protected override Func<byte> GetGenerator()
+    {
+        return () => (byte)_rand.Next(_low_byte, _high_byte);
     }
 }