diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/BinaryUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/BinaryUtils.java
index 9568c4b..84e4e97 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/binary/BinaryUtils.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/BinaryUtils.java
@@ -1715,7 +1715,7 @@
     private static Object[] doReadBinaryEnumArray(BinaryInputStream in, BinaryContext ctx) {
         int len = in.readInt();
 
-        Object[] arr = (Object[])Array.newInstance(BinaryObject.class, len);
+        Object[] arr = (Object[])Array.newInstance(BinaryEnumObjectImpl.class, len);
 
         for (int i = 0; i < len; i++) {
             byte flag = in.readByte();
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializer.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializer.java
index 9e6411f..439e65c 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializer.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializer.java
@@ -19,10 +19,9 @@
 
 import java.util.Collection;
 import java.util.IdentityHashMap;
-import java.util.LinkedHashMap;
 import java.util.Map;
 import org.apache.ignite.binary.BinaryObject;
-import org.apache.ignite.internal.binary.BinaryMetadata;
+import org.apache.ignite.internal.binary.BinaryEnumObjectImpl;
 import org.apache.ignite.internal.binary.BinaryObjectExImpl;
 import org.apache.ignite.internal.binary.BinaryUtils;
 import org.apache.ignite.internal.binary.BinaryWriterExImpl;
@@ -111,22 +110,24 @@
             return;
         }
 
+        if (val instanceof BinaryEnumObjectImpl) {
+            BinaryEnumObjectImpl obj = (BinaryEnumObjectImpl)val;
+
+            writer.writeByte(GridBinaryMarshaller.ENUM);
+            writer.writeInt(obj.typeId());
+
+            if (obj.typeId() == GridBinaryMarshaller.UNREGISTERED_TYPE_ID)
+                writer.doWriteString(obj.className());
+
+            writer.writeInt(obj.enumOrdinal());
+
+            return;
+        }
+
         if (IgniteUtils.isEnum(val.getClass())) {
             String clsName = ((Enum)val).getDeclaringClass().getName();
 
             int typeId = writer.context().typeId(clsName);
-            String typeName = writer.context().userTypeName(clsName);
-
-            Object[] enumVals = val.getClass().getEnumConstants();
-
-            Map<String, Integer> enumMap = new LinkedHashMap<>(enumVals.length);
-
-            for (Object enumVal : enumVals)
-                enumMap.put(((Enum)enumVal).name(), ((Enum)enumVal).ordinal());
-
-            BinaryMetadata meta = new BinaryMetadata(typeId, typeName, null, null, null, true, enumMap);
-
-            writer.context().updateMetadata(typeId, meta, writer.failIfUnregistered());
 
             // Need register class for marshaller to be able to deserialize enum value.
             writer.context().registerClass(((Enum)val).getDeclaringClass(), true, false);
@@ -179,17 +180,21 @@
         }
 
         if (val instanceof Object[]) {
-            int compTypeId = writer.context().typeId(((Object[])val).getClass().getComponentType().getName());
+            Class<?> compCls = ((Object[])val).getClass().getComponentType();
 
-            if (val instanceof BinaryBuilderEnum[]) {
+            int compTypeId = writer.context().typeId(compCls.getName());
+
+            if (BinaryEnumObjectImpl.class.isAssignableFrom(compCls) || val instanceof BinaryBuilderEnum[]) {
                 writeArray(writer, GridBinaryMarshaller.ENUM_ARR, (Object[])val, compTypeId);
 
                 return;
             }
 
-            if (((Object[])val).getClass().getComponentType().isEnum()) {
+            if (compCls.isEnum()) {
                 Enum[] enumArr = (Enum[])val;
 
+                writer.context().registerClass(compCls, true, false);
+
                 writer.writeByte(GridBinaryMarshaller.ENUM_ARR);
                 writer.writeInt(compTypeId);
                 writer.writeInt(enumArr.length);
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java
index 45a13c0..48c3fce 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java
@@ -402,12 +402,13 @@
         // Detect Enum and Enum array type.
         else if (newVal instanceof BinaryEnumObjectImpl)
             newFldTypeId = GridBinaryMarshaller.ENUM;
-        else if (newVal.getClass().isArray() && newVal.getClass().getComponentType() == BinaryObject.class) {
-            BinaryObject[] arr = (BinaryObject[])newVal;
 
-            newFldTypeId = arr.length > 0 && arr[0] instanceof BinaryEnumObjectImpl ?
-                GridBinaryMarshaller.ENUM_ARR : GridBinaryMarshaller.OBJ_ARR;
-        }
+        else if (newVal.getClass().isArray() && BinaryEnumObjectImpl.class.isAssignableFrom(newVal.getClass().getComponentType()))
+            newFldTypeId = GridBinaryMarshaller.ENUM_ARR;
+
+        else if (newVal.getClass().isArray() && BinaryObject.class.isAssignableFrom(newVal.getClass().getComponentType()))
+            newFldTypeId = GridBinaryMarshaller.OBJ_ARR;
+
         else
             newFldTypeId = BinaryUtils.typeByClass(newVal.getClass());
 
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryObjectBuilderAdditionalSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryObjectBuilderAdditionalSelfTest.java
index b24d9d6..2877a64 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryObjectBuilderAdditionalSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/BinaryObjectBuilderAdditionalSelfTest.java
@@ -1500,6 +1500,14 @@
             processor.binaryContext().userTypeName(typeName));
     }
 
+    /** */
+    private void clearBinaryMeta() {
+        BinaryContext binCtx = ((CacheObjectBinaryProcessorImpl)((IgniteBinaryImpl)binaries()).processor()).binaryContext();
+
+        binCtx.unregisterBinarySchemas();
+        binCtx.unregisterUserTypeDescriptors();
+    }
+
     /**
      * Check that correct type is stored in binary object.
      */
@@ -1618,28 +1626,102 @@
 
     /**
      * Checks correct serialization/deserialization of enums in builder.
-     *
-     * @throws Exception If failed.
      */
     @Test
-    public void testEnum() throws Exception {
-        BinaryObjectBuilder builder = newWrapper("TestType");
+    public void testEnum() {
+        try {
+            BinaryObjectBuilder builder = newWrapper(TestClsWithEnum.class.getName());
 
-        final TestEnum exp = TestEnum.A;
-        final TestEnum[] expArr = {TestEnum.A, TestEnum.B};
+            TestEnum[] expArr = {TestEnum.A, TestEnum.B};
 
-        BinaryObject enumObj = builder.setField("testEnum", exp).setField("testEnumArr", expArr).build();
+            BinaryObject enumObj = builder
+                .setField("testEnumA", TestEnum.A)
+                .setField("testEnumB", TestEnum.B)
+                .setField("testEnumArr", expArr)
+                .build();
 
-        assertEquals(exp, ((BinaryObject)enumObj.field("testEnum")).deserialize());
-        Assert.assertArrayEquals(expArr, (Object[])deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+            Assert.assertSame(TestEnum.A, ((BinaryObject)enumObj.field("testEnumA")).deserialize());
+            Assert.assertSame(TestEnum.B, ((BinaryObject)enumObj.field("testEnumB")).deserialize());
+            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
 
-        builder = newWrapper(enumObj.type().typeName());
+            Assert.assertSame(TestEnum.A, ((TestClsWithEnum)enumObj.deserialize()).testEnumA);
+            Assert.assertSame(TestEnum.B, ((TestClsWithEnum)enumObj.deserialize()).testEnumB);
+            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
 
-        enumObj = builder.setField("testEnum", (Object)enumObj.field("testEnum"))
-            .setField("testEnumArr", (Object)enumObj.field("testEnumArr")).build();
+            builder = newWrapper(enumObj.type().typeName());
 
-        assertEquals(exp, ((BinaryObject)enumObj.field("testEnum")).deserialize());
-        Assert.assertArrayEquals(expArr, (Object[])deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+            enumObj = builder
+                .setField("testEnumA", (Object)enumObj.field("testEnumA"))
+                .setField("testEnumB", (Object)enumObj.field("testEnumB"))
+                .setField("testEnumArr", (Object)enumObj.field("testEnumArr"))
+                .build();
+
+            Assert.assertSame(TestEnum.A, ((BinaryObject)enumObj.field("testEnumA")).deserialize());
+            Assert.assertSame(TestEnum.B, ((BinaryObject)enumObj.field("testEnumB")).deserialize());
+            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+
+            Assert.assertSame(TestEnum.A, ((TestClsWithEnum)enumObj.deserialize()).testEnumA);
+            Assert.assertSame(TestEnum.B, ((TestClsWithEnum)enumObj.deserialize()).testEnumB);
+            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
+
+            builder = newWrapper(enumObj.type().typeName());
+
+            expArr = new TestEnum[0];
+
+            enumObj = builder.setField("testEnumArr", expArr).build();
+
+            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
+
+            enumObj = builder.setField("testEnumArr", (Object)enumObj.field("testEnumArr")).build();
+
+            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
+        }
+        finally {
+            clearBinaryMeta();
+        }
+    }
+
+    /** */
+    @Test
+    public void testEnum2() {
+        try {
+            BinaryObjectBuilder builder = newWrapper(TestClsWithEnum.class.getName());
+
+            Object[] expArr = new TestEnum[0];
+
+            BinaryObject enumObj = builder.setField("testEnumArr", expArr).build();
+
+            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
+
+            builder = newWrapper(enumObj.type().typeName());
+
+            enumObj = builder.setField("testEnumArr", (Object)enumObj.field("testEnumArr")).build();
+
+            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
+
+            expArr = new TestEnum[] {TestEnum.A, TestEnum.B};
+
+            builder = newWrapper(enumObj.type().typeName());
+
+            enumObj = builder.setField("testEnumArr", expArr).build();
+
+            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
+
+            builder = newWrapper(enumObj.type().typeName());
+
+            enumObj = builder.setField("testEnumArr", (Object)enumObj.field("testEnumArr")).build();
+
+            Assert.assertArrayEquals(expArr, deserializeEnumBinaryArray(enumObj.field("testEnumArr")));
+            Assert.assertArrayEquals(expArr, ((TestClsWithEnum)enumObj.deserialize()).testEnumArr);
+        }
+        finally {
+            clearBinaryMeta();
+        }
     }
 
     /**
@@ -1759,12 +1841,39 @@
         }
     }
 
+    /** Test class with enum and array of enums. */
+    public static class TestClsWithEnum {
+        /** */
+        private final TestEnum testEnumA;
+
+        /** */
+        private final TestEnum testEnumB;
+
+        /** */
+        private final TestEnum[] testEnumArr;
+
+        /** */
+        public TestClsWithEnum(TestEnum testEnumA, TestEnum testEnumB, TestEnum[] testEnumArr) {
+            this.testEnumA = testEnumA;
+            this.testEnumB = testEnumB;
+            this.testEnumArr = testEnumArr;
+        }
+    }
+
     /**
      *
      */
     private enum TestEnum {
         /** */
-        A,
+        A {
+            /**
+             * An empty function is needed so that {@link TestEnum#A}
+             * becomes a subclass.
+             */
+            public void foo() {
+
+            }
+        },
 
         /** */
         B
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/binary/BinarySimpleNameTestPropertySelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/binary/BinarySimpleNameTestPropertySelfTest.java
index 7e1709e..22a5d24 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/binary/BinarySimpleNameTestPropertySelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/binary/BinarySimpleNameTestPropertySelfTest.java
@@ -65,8 +65,7 @@
             checkProperty("TestClass");
         }
         finally {
-            if (useSimpleNameBackup != null)
-                GridTestProperties.setProperty(BINARY_MARSHALLER_USE_SIMPLE_NAME_MAPPER, "true");
+            GridTestProperties.setProperty(BINARY_MARSHALLER_USE_SIMPLE_NAME_MAPPER, useSimpleNameBackup);
         }
     }