diff --git a/Editor/ConfigurablePassPolicy.cs b/Editor/ConfigurablePassPolicy.cs
index 6f8bbcc..6d0fc7e 100644
--- a/Editor/ConfigurablePassPolicy.cs
+++ b/Editor/ConfigurablePassPolicy.cs
@@ -189,9 +189,9 @@ namespace Obfuz
             ObfuscationPassType passType = ObfuscationPassType.None;
             foreach (var passName in obfuscationPassTypesStr.Split('|'))
             {
-                if (Enum.TryParse(typeof(ObfuscationPassType), passName, out var pass))
+                if (Enum.TryParse< ObfuscationPassType>(passName, out var pass))
                 {
-                    passType |= (ObfuscationPassType)pass;
+                    passType |= pass;
                 }
                 else
                 {
diff --git a/Editor/EncryptionVM/VirtualMachineCodeGenerator.cs b/Editor/EncryptionVM/VirtualMachineCodeGenerator.cs
index ecf826a..b05f000 100644
--- a/Editor/EncryptionVM/VirtualMachineCodeGenerator.cs
+++ b/Editor/EncryptionVM/VirtualMachineCodeGenerator.cs
@@ -77,7 +77,7 @@ namespace Obfuz.EncryptionVM
             {");
             foreach (var opCode in _vm.opCodes)
             {
-                lines.Add(@$"            case {opCode.code}:
+                lines.Add($@"            case {opCode.code}:
             {{
                 // {opCode.function.GetType().Name}");
                 AppendEncryptCode(lines, opCode.function);
@@ -101,7 +101,7 @@ namespace Obfuz.EncryptionVM
             {");
             foreach (var opCode in _vm.opCodes)
             {
-                lines.Add(@$"            case {opCode.code}:
+                lines.Add($@"            case {opCode.code}:
             {{
                 // {opCode.function.GetType().Name}");
                 AppendDecryptCode(lines, opCode.function);
@@ -132,7 +132,7 @@ namespace Obfuz.EncryptionVM
 {
     public class GeneratedEncryptionVirtualMachine : Obfuz.EncryptorBase
     {");
-            lines.Add(@$"
+            lines.Add($@"
         private const int kOpCodeBits = {_opCodeBits};
 
         private const int kOpCodeCount = {_opCodeCount};
diff --git a/Editor/ObfusPasses/ConstEncrypt/ConfigurableEncryptPolicy.cs b/Editor/ObfusPasses/ConstEncrypt/ConfigurableEncryptPolicy.cs
index 3fb6230..3b3445c 100644
--- a/Editor/ObfusPasses/ConstEncrypt/ConfigurableEncryptPolicy.cs
+++ b/Editor/ObfusPasses/ConstEncrypt/ConfigurableEncryptPolicy.cs
@@ -213,22 +213,22 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
             {
                 case "int":
                 {
-                    notEncryptInts.AddRange(value.Split(",").Select(s => int.Parse(s.Trim())));
+                    notEncryptInts.AddRange(value.Split(',').Select(s => int.Parse(s.Trim())));
                     break;
                 }
                 case "long":
                 {
-                    notEncryptLongs.AddRange(value.Split(",").Select(s => long.Parse(s.Trim())));
+                    notEncryptLongs.AddRange(value.Split(',').Select(s => long.Parse(s.Trim())));
                     break;
                 }
                 case "string":
                 {
-                    notEncryptStrings.AddRange(value.Split(",").Select(s => s.Trim()));
+                    notEncryptStrings.AddRange(value.Split(',').Select(s => s.Trim()));
                     break;
                 }
                 case "int-range":
                 {
-                    var parts = value.Split(",");
+                    var parts = value.Split(',');
                     if (parts.Length != 2)
                     {
                         throw new Exception($"Invalid xml file, int-range {value} is invalid");
@@ -238,7 +238,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                 }
                 case "long-range":
                 {
-                    var parts = value.Split(",");
+                    var parts = value.Split(',');
                     if (parts.Length != 2)
                     {
                         throw new Exception($"Invalid xml file, long-range {value} is invalid");
@@ -248,7 +248,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                 }
                 case "float-range":
                 {
-                    var parts = value.Split(",");
+                    var parts = value.Split(',');
                     if (parts.Length != 2)
                     {
                         throw new Exception($"Invalid xml file, float-range {value} is invalid");
@@ -258,7 +258,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                 }
                 case "double-range":
                 {
-                    var parts = value.Split(",");
+                    var parts = value.Split(',');
                     if (parts.Length != 2)
                     {
                         throw new Exception($"Invalid xml file, double-range {value} is invalid");
@@ -268,7 +268,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                 }
                 case "string-length-range":
                 {
-                    var parts = value.Split(",");
+                    var parts = value.Split(',');
                     if (parts.Length != 2)
                     {
                         throw new Exception($"Invalid xml file, string-length-range {value} is invalid");
@@ -278,7 +278,7 @@ namespace Obfuz.ObfusPasses.ConstEncrypt
                 }
                 case "array-length-range":
                 {
-                    var parts = value.Split(",");
+                    var parts = value.Split(',');
                     if (parts.Length != 2)
                     {
                         throw new Exception($"Invalid xml file, array-length-range {value} is invalid");
diff --git a/Editor/ObfusPasses/SymbolObfus/Policies/ConfigurableRenamePolicy.cs b/Editor/ObfusPasses/SymbolObfus/Policies/ConfigurableRenamePolicy.cs
index 2b2f2d6..101f0db 100644
--- a/Editor/ObfusPasses/SymbolObfus/Policies/ConfigurableRenamePolicy.cs
+++ b/Editor/ObfusPasses/SymbolObfus/Policies/ConfigurableRenamePolicy.cs
@@ -711,7 +711,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus.Policies
 
         public ConfigurableRenamePolicy(List<string> obfuscationAssemblyNames, List<string> xmlFiles)
         {
-            this._obfuscationAssemblyNames = obfuscationAssemblyNames.ToHashSet();
+            _obfuscationAssemblyNames = new HashSet<string>(obfuscationAssemblyNames);
             LoadXmls(xmlFiles);
         }
 
diff --git a/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs b/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
index cbe5139..4f4f3d5 100644
--- a/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
+++ b/Editor/ObfusPasses/SymbolObfus/SymbolRename.cs
@@ -69,7 +69,7 @@ namespace Obfuz.ObfusPasses.SymbolObfus
             _assemblyCache = ctx.assemblyCache;
             _toObfuscatedModules = ctx.toObfuscatedModules;
             _obfuscatedAndNotObfuscatedModules = ctx.obfuscatedAndNotObfuscatedModules;
-            _toObfuscatedModuleSet = ctx.toObfuscatedModules.ToHashSet();
+            _toObfuscatedModuleSet = new HashSet<ModuleDef>(ctx.toObfuscatedModules);
             var obfuscateRuleConfig = new ConfigurableRenamePolicy(ctx.toObfuscatedAssemblyNames, _obfuscationRuleFiles);
             _renamePolicy = new CacheRenamePolicy(new CombineRenamePolicy(new SupportPassPolicy(ctx.passPolicy), new SystemRenamePolicy(), new UnityRenamePolicy(), obfuscateRuleConfig));
             BuildCustomAttributeArguments();
diff --git a/Editor/Obfuscator.cs b/Editor/Obfuscator.cs
index c6dc917..6399433 100644
--- a/Editor/Obfuscator.cs
+++ b/Editor/Obfuscator.cs
@@ -1,5 +1,4 @@
 using dnlib.DotNet;
-using dnlib.Protection;
 using Obfuz.Data;
 using Obfuz.Emit;
 using Obfuz.EncryptionVM;
@@ -14,7 +13,6 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using UnityEngine;
-using static UnityEditor.ObjectChangeEventStream;
 
 namespace Obfuz
 {
diff --git a/Editor/Unity/ObfuscationProcess.cs b/Editor/Unity/ObfuscationProcess.cs
index 2441aba..80e2db9 100644
--- a/Editor/Unity/ObfuscationProcess.cs
+++ b/Editor/Unity/ObfuscationProcess.cs
@@ -27,7 +27,11 @@ namespace Obfuz.Unity
 
         public void OnPostBuildPlayerScriptDLLs(BuildReport report)
         {
+#if UNITY_2019
+            RunObfuscate(report.files);
+#else
             RunObfuscate(report.GetFiles());
+#endif
         }
 
         private static void BackupOriginalDlls(string srcDir, string dstDir, HashSet<string> dllNames)
@@ -57,7 +61,7 @@ namespace Obfuz.Unity
             Debug.Log("Obfuscation begin...");
             var buildTarget = EditorUserBuildSettings.activeBuildTarget;
 
-            var obfuscationRelativeAssemblyNames = settings.assemblySettings.GetObfuscationRelativeAssemblyNames().ToHashSet();
+            var obfuscationRelativeAssemblyNames = new HashSet<string>(settings.assemblySettings.GetObfuscationRelativeAssemblyNames());
             string stagingAreaTempManagedDllDir = Path.GetDirectoryName(files.First(file => file.path.EndsWith(".dll")).path);
             string backupPlayerScriptAssembliesPath = settings.GetOriginalAssemblyBackupDir(buildTarget);
             BackupOriginalDlls(stagingAreaTempManagedDllDir, backupPlayerScriptAssembliesPath, obfuscationRelativeAssemblyNames);
@@ -117,4 +121,4 @@ namespace Obfuz.Unity
         }
     }
 #endif
-}
+        }
diff --git a/Editor/Unity/ObfuzMenu.cs b/Editor/Unity/ObfuzMenu.cs
index d00ce53..4a09e6c 100644
--- a/Editor/Unity/ObfuzMenu.cs
+++ b/Editor/Unity/ObfuzMenu.cs
@@ -4,7 +4,6 @@ using Obfuz.Utils;
 using System.IO;
 using UnityEditor;
 using UnityEngine;
-using static UnityEditor.ObjectChangeEventStream;
 using FileUtil = Obfuz.Utils.FileUtil;
 
 namespace Obfuz.Unity
diff --git a/Editor/Utils/KeyGenerator.cs b/Editor/Utils/KeyGenerator.cs
index f6bfccc..31aa40c 100644
--- a/Editor/Utils/KeyGenerator.cs
+++ b/Editor/Utils/KeyGenerator.cs
@@ -13,22 +13,24 @@ namespace Obfuz.Utils
         public static byte[] GenerateKey(string initialString, int keyLength)
         {
             byte[] initialBytes = Encoding.UTF8.GetBytes(initialString);
-            using var sha512 = SHA512.Create();
-            byte[] hash = sha512.ComputeHash(initialBytes);
-            byte[] key = new byte[keyLength];
-            int bytesCopied = 0;
-            while (bytesCopied < key.Length)
+            using (var sha512 = SHA512.Create())
             {
-                if (bytesCopied > 0)
+                byte[] hash = sha512.ComputeHash(initialBytes);
+                byte[] key = new byte[keyLength];
+                int bytesCopied = 0;
+                while (bytesCopied < key.Length)
                 {
-                    // 再次哈希之前的哈希值以生成更多数据
-                    hash = sha512.ComputeHash(hash);
+                    if (bytesCopied > 0)
+                    {
+                        // 再次哈希之前的哈希值以生成更多数据
+                        hash = sha512.ComputeHash(hash);
+                    }
+                    int bytesToCopy = Math.Min(hash.Length, key.Length - bytesCopied);
+                    Buffer.BlockCopy(hash, 0, key, bytesCopied, bytesToCopy);
+                    bytesCopied += bytesToCopy;
                 }
-                int bytesToCopy = Math.Min(hash.Length, key.Length - bytesCopied);
-                Buffer.BlockCopy(hash, 0, key, bytesCopied, bytesToCopy);
-                bytesCopied += bytesToCopy;
+                return key;
             }
-            return key;
         }
 
         public static int[] ConvertToIntKey(byte[] key)
diff --git a/Runtime/ConstUtility.cs b/Runtime/ConstUtility.cs
index 643d3d8..467cc2b 100644
--- a/Runtime/ConstUtility.cs
+++ b/Runtime/ConstUtility.cs
@@ -55,24 +55,28 @@ namespace Obfuz
             Buffer.BlockCopy(data, offset, array, 0, length);
         }
 
-        public static int CastFloatAsInt(float value)
+        public static unsafe int CastFloatAsInt(float value)
         {
-            return UnsafeUtility.As<float, int>(ref value);
+            int* intValue = (int*)&value;
+            return *intValue;
         }
 
-        public static float CastIntAsFloat(int value)
+        public static unsafe float CastIntAsFloat(int value)
         {
-            return UnsafeUtility.As<int, float>(ref value);
+            float* floatValue = (float*)&value;
+            return *floatValue;
         }
 
-        public static long CastDoubleAsLong(double value)
+        public static unsafe long CastDoubleAsLong(double value)
         {
-            return UnsafeUtility.As<double, long>(ref value);
+            long* longValue = (long*)&value;
+            return *longValue;
         }
 
-        public static double CastLongAsDouble(long value)
+        public static unsafe double CastLongAsDouble(long value)
         {
-            return UnsafeUtility.As<long, double>(ref value);
+            double* doubleValue = (double*)&value;
+            return *doubleValue;
         }
     }
 }
diff --git a/Runtime/EncryptorBase.cs b/Runtime/EncryptorBase.cs
index 1f70d29..007e4b9 100644
--- a/Runtime/EncryptorBase.cs
+++ b/Runtime/EncryptorBase.cs
@@ -40,49 +40,49 @@ namespace Obfuz
             return ((long)decryptedHigh << 32) | (uint)decryptedLow;
         }
 
-        public virtual float Encrypt(float value, int opts, int salt)
+        public virtual unsafe float Encrypt(float value, int opts, int salt)
         {
             if (float.IsNaN(value) || float.IsInfinity(value))
             {
                 return value;
             }
-            ref int intValue = ref UnsafeUtility.As<float, int>(ref value);
+            ref int intValue = ref *(int*)&value;
             int xorValue = ((1 << 23) - 1) & Decrypt(0xABCD, opts, salt);
             intValue ^= xorValue;
             return value;
         }
 
-        public virtual float Decrypt(float value, int opts, int salt)
+        public virtual unsafe float Decrypt(float value, int opts, int salt)
         {
             if (float.IsNaN(value) || float.IsInfinity(value))
             {
                 return value;
             }
-            ref int intValue = ref UnsafeUtility.As<float, int>(ref value);
+            ref int intValue = ref *(int*)&value;
             int xorValue = ((1 << 23) - 1) & Decrypt(0xABCD, opts, salt);
             intValue ^= xorValue;
             return value;
         }
 
-        public virtual double Encrypt(double value, int opts, int salt)
+        public virtual unsafe double Encrypt(double value, int opts, int salt)
         {
             if (double.IsNaN(value) || double.IsInfinity(value))
             {
                 return value;
             }
-            ref long longValue = ref UnsafeUtility.As<double, long>(ref value);
+            ref long longValue = ref *(long*)&value;
             long xorValue = ((1L << 52) - 1) & Decrypt(0xAABBCCDDL, opts, salt);
             longValue ^= xorValue;
             return value;
         }
 
-        public virtual double Decrypt(double value, int opts, int salt)
+        public virtual unsafe double Decrypt(double value, int opts, int salt)
         {
             if (double.IsNaN(value) || double.IsInfinity(value))
             {
                 return value;
             }
-            ref long longValue = ref UnsafeUtility.As<double, long>(ref value);
+            ref long longValue = ref *(long*)&value;
             long xorValue = ((1L << 52) - 1) & Decrypt(0xAABBCCDDL, opts, salt);
             longValue ^= xorValue;
             return value;
diff --git a/Runtime/IEncryptor.cs b/Runtime/IEncryptor.cs
index 8190230..0d8fdaa 100644
--- a/Runtime/IEncryptor.cs
+++ b/Runtime/IEncryptor.cs
@@ -24,9 +24,9 @@ namespace Obfuz
         double Decrypt(double value, int opts, int salt);
 
         byte[] Encrypt(byte[] value, int offset, int length, int opts, int salt);
-        public byte[] Decrypt(byte[] value, int offset, int byteLength, int ops, int salt);
+        byte[] Decrypt(byte[] value, int offset, int byteLength, int ops, int salt);
 
-        public byte[] Encrypt(string value, int ops, int salt);
-        public string DecryptString(byte[] value, int offset, int stringBytesLength, int ops, int salt);
+        byte[] Encrypt(string value, int ops, int salt);
+        string DecryptString(byte[] value, int offset, int stringBytesLength, int ops, int salt);
     }
 }