diff --git a/DICOM [Unit Tests]/DICOM [Unit Tests].csproj b/DICOM [Unit Tests]/DICOM [Unit Tests].csproj
index 71e33273e..51dbb5942 100644
--- a/DICOM [Unit Tests]/DICOM [Unit Tests].csproj	
+++ b/DICOM [Unit Tests]/DICOM [Unit Tests].csproj	
@@ -71,6 +71,7 @@
     <Compile Include="DicomElementTest.cs" />
     <Compile Include="DicomEncodingTest.cs" />
     <Compile Include="DicomFileTest.cs" />
+    <Compile Include="DicomOtherByteTest.cs" />
     <Compile Include="DicomPersonNameTest.cs" />
     <Compile Include="DicomTagTest.cs" />
     <Compile Include="DicomUIDTest.cs" />
diff --git a/DICOM [Unit Tests]/DicomDatasetTest.cs b/DICOM [Unit Tests]/DicomDatasetTest.cs
index 82435b922..2ecb927b6 100644
--- a/DICOM [Unit Tests]/DicomDatasetTest.cs	
+++ b/DICOM [Unit Tests]/DicomDatasetTest.cs	
@@ -16,55 +16,61 @@ public class DicomDatasetTest
         [Fact]
         public void Add_OtherDoubleElement_Succeeds()
         {
+            var tag = DicomTag.DoubleFloatPixelData;
             var dataset = new DicomDataset();
-            dataset.Add(DicomTag.DoubleFloatPixelData, 3.45);
-            Assert.IsType(typeof(DicomOtherDouble), dataset.First());
+            dataset.Add(tag, 3.45);
+            Assert.IsType<DicomOtherDouble>(dataset.First(item => item.Tag.Equals(tag)));
         }
 
         [Fact]
         public void Add_OtherDoubleElementWithMultipleDoubles_Succeeds()
         {
+            var tag = DicomTag.DoubleFloatPixelData;
             var dataset = new DicomDataset();
-            dataset.Add(DicomTag.DoubleFloatPixelData, 3.45, 6.78, 9.01);
-            Assert.IsType(typeof(DicomOtherDouble), dataset.First());
-            Assert.Equal(3, dataset.Get<double[]>(DicomTag.DoubleFloatPixelData).Length);
+            dataset.Add(tag, 3.45, 6.78, 9.01);
+            Assert.IsType<DicomOtherDouble>(dataset.First(item => item.Tag.Equals(tag)));
+            Assert.Equal(3, dataset.Get<double[]>(tag).Length);
         }
 
         [Fact]
         public void Add_UnlimitedCharactersElement_Succeeds()
         {
+            var tag = DicomTag.LongCodeValue;
             var dataset = new DicomDataset();
-            dataset.Add(DicomTag.LongCodeValue, "abc");
-            Assert.IsType(typeof(DicomUnlimitedCharacters), dataset.First());
-            Assert.Equal("abc", dataset.Get<string>(DicomTag.LongCodeValue));
+            dataset.Add(tag, "abc");
+            Assert.IsType<DicomUnlimitedCharacters>(dataset.First(item => item.Tag.Equals(tag)));
+            Assert.Equal("abc", dataset.Get<string>(tag));
         }
 
         [Fact]
         public void Add_UnlimitedCharactersElementWithMultipleStrings_Succeeds()
         {
+            var tag = DicomTag.LongCodeValue;
             var dataset = new DicomDataset();
-            dataset.Add(DicomTag.LongCodeValue, "a", "b", "c");
-            Assert.IsType(typeof(DicomUnlimitedCharacters), dataset.First());
-            Assert.Equal("c", dataset.Get<string>(DicomTag.LongCodeValue, 2));
+            dataset.Add(tag, "a", "b", "c");
+            Assert.IsType<DicomUnlimitedCharacters>(dataset.First(item => item.Tag.Equals(tag)));
+            Assert.Equal("c", dataset.Get<string>(tag, 2));
         }
 
         [Fact]
         public void Add_UniversalResourceElement_Succeeds()
         {
+            var tag = DicomTag.URNCodeValue;
             var dataset = new DicomDataset();
-            dataset.Add(DicomTag.URNCodeValue, "abc");
-            Assert.IsType(typeof(DicomUniversalResource), dataset.First());
-            Assert.Equal("abc", dataset.Get<string>(DicomTag.URNCodeValue));
+            dataset.Add(tag, "abc");
+            Assert.IsType<DicomUniversalResource>(dataset.First(item => item.Tag.Equals(tag)));
+            Assert.Equal("abc", dataset.Get<string>(tag));
         }
 
         [Fact]
         public void Add_UniversalResourceElementWithMultipleStrings_OnlyFirstValueIsUsed()
         {
+            var tag = DicomTag.URNCodeValue;
             var dataset = new DicomDataset();
-            dataset.Add(DicomTag.URNCodeValue, "a", "b", "c");
-            Assert.IsType(typeof(DicomUniversalResource), dataset.First());
+            dataset.Add(tag, "a", "b", "c");
+            Assert.IsType<DicomUniversalResource>(dataset.First(item => item.Tag.Equals(tag)));
 
-            var data = dataset.Get<string[]>(DicomTag.URNCodeValue);
+            var data = dataset.Get<string[]>(tag);
             Assert.Equal(1, data.Length);
             Assert.Equal("a", data.First());
         }
@@ -72,15 +78,16 @@ public void Add_UniversalResourceElementWithMultipleStrings_OnlyFirstValueIsUsed
         [Fact]
         public void Add_PersonName_MultipleNames_YieldsMultipleValues()
         {
+            var tag = DicomTag.PerformingPhysicianName;
             var dataset = new DicomDataset();
             dataset.Add(
-                DicomTag.PerformingPhysicianName,
+                tag,
                 "Gustafsson^Anders^L",
                 "Yates^Ian",
                 "Desouky^Hesham",
                 "Horn^Chris");
 
-            var data = dataset.Get<string[]>(DicomTag.PerformingPhysicianName);
+            var data = dataset.Get<string[]>(tag);
             Assert.Equal(4, data.Length);
             Assert.Equal("Desouky^Hesham", data[2]);
         }
@@ -92,7 +99,7 @@ public void Add_MultiVMStringTags_YieldsMultipleValues(DicomTag tag, string[] va
             var dataset = new DicomDataset();
             dataset.Add(tag, values);
 
-            Assert.IsType(expectedType, dataset.First());
+            Assert.IsType(expectedType, dataset.First(item => item.Tag.Equals(tag)));
 
             var data = dataset.Get<string[]>(tag);
             Assert.Equal(values.Length, data.Length);
diff --git a/DICOM [Unit Tests]/DicomOtherByteTest.cs b/DICOM [Unit Tests]/DicomOtherByteTest.cs
new file mode 100644
index 000000000..2f5558f13
--- /dev/null
+++ b/DICOM [Unit Tests]/DicomOtherByteTest.cs	
@@ -0,0 +1,105 @@
+// Copyright (c) 2012-2015 fo-dicom contributors.
+// Licensed under the Microsoft Public License (MS-PL).
+
+namespace Dicom
+{
+    using System;
+    using System.Linq;
+
+    using Xunit;
+
+    public class DicomOtherByteTest
+    {
+        #region Unit tests
+
+        [Fact]
+        public void Get_Short_ReturnsCorrectValue()
+        {
+            Get_SingleItem_ReturnsCorrectValue(63, (short)0x7f7e);
+        }
+
+        [Fact]
+        public void Get_ShortArray_ReturnsCorrectValue()
+        {
+            Get_Array_ReturnsCorrectValue(31, (short)0x3f3e, 128);
+        }
+
+        [Fact]
+        public void Get_UShort_ReturnsCorrectValue()
+        {
+            Get_SingleItem_ReturnsCorrectValue(63, (ushort)0x7f7e);
+        }
+
+        [Fact]
+        public void Get_UShortArray_ReturnsCorrectValue()
+        {
+            Get_Array_ReturnsCorrectValue(31, (ushort)0x3f3e, 128);
+        }
+
+        [Fact]
+        public void Get_Byte_ReturnsCorrectValue()
+        {
+            Get_SingleItem_ReturnsCorrectValue(63, (byte)0x3f);
+        }
+
+        [Fact]
+        public void Get_ByteArray_ReturnsCorrectValue()
+        {
+            Get_Array_ReturnsCorrectValue(31, (byte)0x1f, 256);
+        }
+
+        [Fact]
+        public void Get_UInt_ReturnsCorrectValue()
+        {
+            Get_SingleItem_ReturnsCorrectValue(63, (uint)0xfffefdfc);
+        }
+
+        [Fact]
+        public void Get_UIntArray_ReturnsCorrectValue()
+        {
+            Get_Array_ReturnsCorrectValue(31, (uint)0x7f7e7d7c, 64);
+        }
+
+        [Fact]
+        public void Get_Double_ReturnsCorrectValue()
+        {
+            var doubles = new double[1];
+            Buffer.BlockCopy(new byte[] { 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f }, 0, doubles, 0, 8);
+            Get_SingleItem_ReturnsCorrectValue(7, doubles[0]);
+        }
+
+        [Fact]
+        public void Get_DoubleArray_ReturnsCorrectValue()
+        {
+            var doubles = new double[1];
+            Buffer.BlockCopy(new byte[] { 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f }, 0, doubles, 0, 8);
+            Get_Array_ReturnsCorrectValue(15, doubles[0], 32);
+        }
+
+        #endregion
+
+        #region Helper methods
+
+        public static void Get_SingleItem_ReturnsCorrectValue<T>(int index, T expected)
+        {
+            var element = new DicomOtherByte(
+                DicomTag.PixelData,
+                Enumerable.Range(0, 256).Select(i => (byte)i).ToArray());
+            var actual = element.Get<T>(index);
+            Assert.Equal(expected, actual);
+        }
+
+        public static void Get_Array_ReturnsCorrectValue<T>(int index, T expected, int expectedLength)
+        {
+            var element = new DicomOtherByte(
+                DicomTag.PixelData,
+                Enumerable.Range(0, 256).Select(i => (byte)i).ToArray());
+            var actual = element.Get<T[]>();
+
+            Assert.Equal(expectedLength, actual.Length);
+            Assert.Equal(expected, actual[index]);
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/DICOM/DicomElement.cs b/DICOM/DicomElement.cs
index 5247f306a..c229ac75b 100644
--- a/DICOM/DicomElement.cs
+++ b/DICOM/DicomElement.cs
@@ -445,7 +445,7 @@ public IEnumerable<DicomTag> Values
                 if (_values == null)
                 {
                     var values = new List<DicomTag>();
-                    var parts = ByteBufferEnumerator<ushort>.Create(Buffer).ToArray();
+                    var parts = ByteConverter.ToArray<ushort>(Buffer);
                     for (int i = 0; i < parts.Length; i += 2)
                     {
                         var group = parts[i + 0];
@@ -965,29 +965,29 @@ public override T Get<T>(int item = -1)
         {
             if (!typeof(T).IsArray && item == -1) item = 0;
 
-            if (typeof(T) == typeof(short)) return (T)(object)ByteBufferEnumerator<short>.Create(Buffer).ToArray().GetValue(item);
+            if (typeof(T) == typeof(short)) return (T)(object)ByteConverter.Get<short>(Buffer, item);
 
-            if (typeof(T) == typeof(short[])) return (T)(object)ByteBufferEnumerator<short>.Create(Buffer).ToArray();
+            if (typeof(T) == typeof(short[])) return (T)(object)ByteConverter.ToArray<short>(Buffer);
 
-            if (typeof(T) == typeof(ushort)) return (T)(object)ByteBufferEnumerator<ushort>.Create(Buffer).ToArray().GetValue(item);
+            if (typeof(T) == typeof(ushort)) return (T)(object)ByteConverter.Get<ushort>(Buffer, item);
 
-            if (typeof(T) == typeof(ushort[])) return (T)(object)ByteBufferEnumerator<ushort>.Create(Buffer).ToArray();
+            if (typeof(T) == typeof(ushort[])) return (T)(object)ByteConverter.ToArray<ushort>(Buffer);
 
-            if (typeof(T) == typeof(int)) return (T)(object)ByteBufferEnumerator<int>.Create(Buffer).ToArray().GetValue(item);
+            if (typeof(T) == typeof(int)) return (T)(object)ByteConverter.Get<int>(Buffer, item);
 
-            if (typeof(T) == typeof(int[])) return (T)(object)ByteBufferEnumerator<int>.Create(Buffer).ToArray();
+            if (typeof(T) == typeof(int[])) return (T)(object)ByteConverter.ToArray<int>(Buffer);
 
-            if (typeof(T) == typeof(uint)) return (T)(object)ByteBufferEnumerator<uint>.Create(Buffer).ToArray().GetValue(item);
+            if (typeof(T) == typeof(uint)) return (T)(object)ByteConverter.Get<uint>(Buffer, item);
 
-            if (typeof(T) == typeof(uint[])) return (T)(object)ByteBufferEnumerator<uint>.Create(Buffer).ToArray();
+            if (typeof(T) == typeof(uint[])) return (T)(object)ByteConverter.ToArray<uint>(Buffer);
 
-            if (typeof(T) == typeof(float)) return (T)(object)ByteBufferEnumerator<float>.Create(Buffer).ToArray().GetValue(item);
+            if (typeof(T) == typeof(float)) return (T)(object)ByteConverter.Get<float>(Buffer, item);
 
-            if (typeof(T) == typeof(float[])) return (T)(object)ByteBufferEnumerator<float>.Create(Buffer).ToArray();
+            if (typeof(T) == typeof(float[])) return (T)(object)ByteConverter.ToArray<float>(Buffer);
 
-            if (typeof(T) == typeof(double)) return (T)(object)ByteBufferEnumerator<double>.Create(Buffer).ToArray().GetValue(item);
+            if (typeof(T) == typeof(double)) return (T)(object)ByteConverter.Get<double>(Buffer, item);
 
-            if (typeof(T) == typeof(double[])) return (T)(object)ByteBufferEnumerator<double>.Create(Buffer).ToArray();
+            if (typeof(T) == typeof(double[])) return (T)(object)ByteConverter.ToArray<double>(Buffer);
 
             return base.Get<T>(item);
         }
diff --git a/DICOM/Imaging/DicomOverlayData.cs b/DICOM/Imaging/DicomOverlayData.cs
index 870e3e21b..181068b94 100644
--- a/DICOM/Imaging/DicomOverlayData.cs
+++ b/DICOM/Imaging/DicomOverlayData.cs
@@ -399,7 +399,7 @@ private IByteBuffer Load()
 
                 if (pixels.BitsAllocated == 8)
                 {
-                    var data = ByteBufferEnumerator<byte>.Create(frame).ToArray();
+                    var data = IO.ByteConverter.ToArray<byte>(frame);
 
                     for (int y = oy; y < oh; y++)
                     {
@@ -416,7 +416,7 @@ private IByteBuffer Load()
                 else if (pixels.BitsAllocated == 16)
                 {
                     // we don't really care if the pixel data is signed or not
-                    var data = ByteBufferEnumerator<ushort>.Create(frame).ToArray();
+                    var data = IO.ByteConverter.ToArray<ushort>(frame);
 
                     for (int y = oy; y < oh; y++)
                     {