Исправление сборки под C# 14

EvilBeaver · EvilBeaver · commit da01dd3dd66f · 2026-06-27T22:38:41.000+03:00
diff --git a/src/OneScript.StandardLibrary/Binary/BinaryDataBuffer.cs b/src/OneScript.StandardLibrary/Binary/BinaryDataBuffer.cs
@@ -355,7 +355,7 @@ public void WriteBitwiseXor(int position, BinaryDataBuffer bytes, int number = 0
         [ContextMethod("Перевернуть", "Reverse")]
         public BinaryDataBuffer Reverse()
         {
-            var bytes = Bytes.Reverse().ToArray();
+            var bytes = Enumerable.Reverse(Bytes).ToArray();
             return new BinaryDataBuffer(bytes, ByteOrder);
         }
 
diff --git a/src/OneScript.StandardLibrary/Binary/EndianBitConverter.cs b/src/OneScript.StandardLibrary/Binary/EndianBitConverter.cs
@@ -51,11 +51,11 @@ public byte[] GetBytes(bool value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -73,11 +73,11 @@ public byte[] GetBytes(char value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -96,11 +96,11 @@ public byte[] GetBytes(double value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -119,11 +119,11 @@ public byte[] GetBytes(float value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -141,11 +141,11 @@ public byte[] GetBytes(int value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -163,11 +163,11 @@ public byte[] GetBytes(long value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -185,11 +185,11 @@ public byte[] GetBytes(short value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -207,11 +207,11 @@ public byte[] GetBytes(uint value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -229,11 +229,11 @@ public byte[] GetBytes(ulong value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -251,11 +251,11 @@ public byte[] GetBytes(ushort value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.GetBytes(value);
+                return BitConverter.GetBytes(value);
             }
             else
             {
-                return System.BitConverter.GetBytes(value).Reverse().ToArray();
+                return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();
             }
         }
         ///
@@ -377,7 +377,7 @@ public int ToInt16(byte[] value, int startIndex)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToInt16(value, startIndex);
+                return BitConverter.ToInt16(value, startIndex);
             }
             else
             {
@@ -415,7 +415,7 @@ public int ToInt32(byte[] value, int startIndex)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToInt32(value, startIndex);
+                return BitConverter.ToInt32(value, startIndex);
             }
             else
             {
@@ -453,7 +453,7 @@ public long ToInt64(byte[] value, int startIndex)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToInt64(value, startIndex);
+                return BitConverter.ToInt64(value, startIndex);
             }
             else
             {
@@ -500,11 +500,11 @@ public float ToSingle(byte[] value, int startIndex)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToSingle(value, startIndex);
+                return BitConverter.ToSingle(value, startIndex);
             }
             else
             {
-                return System.BitConverter.ToSingle(value.Reverse().ToArray(), value.Length - sizeof(Single) - startIndex);
+                return BitConverter.ToSingle(Enumerable.Reverse(value).ToArray(), value.Length - sizeof(Single) - startIndex);
             }
         }
         ///
@@ -528,11 +528,11 @@ public string ToString(byte[] value)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToString(value);
+                return BitConverter.ToString(value);
             }
             else
             {
-                return System.BitConverter.ToString(value.Reverse().ToArray());
+                return BitConverter.ToString(Enumerable.Reverse(value).ToArray());
             }
         }
         ///
@@ -563,11 +563,11 @@ public string ToString(byte[] value, int startIndex)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToString(value, startIndex);
+                return BitConverter.ToString(value, startIndex);
             }
             else
             {
-                return System.BitConverter.ToString(value.Reverse().ToArray(), startIndex);
+                return BitConverter.ToString(Enumerable.Reverse(value).ToArray(), startIndex);
             }
         }
         ///
@@ -607,11 +607,11 @@ public string ToString(byte[] value, int startIndex, int length)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToString(value, startIndex, length);
+                return BitConverter.ToString(value, startIndex, length);
             }
             else
             {
-                return System.BitConverter.ToString(value.Reverse().ToArray(), startIndex, length);
+                return BitConverter.ToString(Enumerable.Reverse(value).ToArray(), startIndex, length);
             }
         }
         ///
@@ -643,11 +643,11 @@ public ushort ToUInt16(byte[] value, int startIndex)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToUInt16(value, startIndex);
+                return BitConverter.ToUInt16(value, startIndex);
             }
             else
             {
-                return System.BitConverter.ToUInt16(value.Reverse().ToArray(), value.Length - sizeof(UInt16) - startIndex);
+                return BitConverter.ToUInt16(Enumerable.Reverse(value).ToArray(), value.Length - sizeof(UInt16) - startIndex);
             }
         }
         ///
@@ -680,7 +680,7 @@ public uint ToUInt32(byte[] value, int startIndex)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToUInt32(value, startIndex);
+                return BitConverter.ToUInt32(value, startIndex);
             }
             else
             {
@@ -717,7 +717,7 @@ public ulong ToUInt64(byte[] value, int startIndex)
         {
             if (IsLittleEndian)
             {
-                return System.BitConverter.ToUInt64(value, startIndex);
+                return BitConverter.ToUInt64(value, startIndex);
             }
             else
             {
diff --git a/src/ScriptEngine/Machine/Contexts/COMWrapperContext.cs b/src/ScriptEngine/Machine/Contexts/COMWrapperContext.cs
@@ -39,7 +39,7 @@ protected COMWrapperContext(object instance)
 
         private static Type FindTypeByName(string typeName)
         {
-            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies().Reverse())
+            foreach (var assembly in Enumerable.Reverse(AppDomain.CurrentDomain.GetAssemblies()))
             {
                 var tt = assembly.GetType(typeName, throwOnError:false, ignoreCase:true);
                 if (tt != null)

Original file line number	Diff line number	Diff line change
`@@ -355,7 +355,7 @@ public void WriteBitwiseXor(int position, BinaryDataBuffer bytes, int number = 0`
`355`	`355`	`[ContextMethod("Перевернуть", "Reverse")]`
`356`	`356`	`public BinaryDataBuffer Reverse()`
`357`	`357`	`{`
`358`		`- var bytes = Bytes.Reverse().ToArray();`
	`358`	`+ var bytes = Enumerable.Reverse(Bytes).ToArray();`
`359`	`359`	`return new BinaryDataBuffer(bytes, ByteOrder);`
`360`	`360`	`}`
`361`	`361`
Original file line number	Diff line number	Diff line change
`@@ -51,11 +51,11 @@ public byte[] GetBytes(bool value)`
`51`	`51`	`{`
`52`	`52`	`if (IsLittleEndian)`
`53`	`53`	`{`
`54`		`- return System.BitConverter.GetBytes(value);`
	`54`	`+ return BitConverter.GetBytes(value);`
`55`	`55`	`}`
`56`	`56`	`else`
`57`	`57`	`{`
`58`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`58`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`///`
`@@ -73,11 +73,11 @@ public byte[] GetBytes(char value)`
`73`	`73`	`{`
`74`	`74`	`if (IsLittleEndian)`
`75`	`75`	`{`
`76`		`- return System.BitConverter.GetBytes(value);`
	`76`	`+ return BitConverter.GetBytes(value);`
`77`	`77`	`}`
`78`	`78`	`else`
`79`	`79`	`{`
`80`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`80`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`	`///`
`@@ -96,11 +96,11 @@ public byte[] GetBytes(double value)`
`96`	`96`	`{`
`97`	`97`	`if (IsLittleEndian)`
`98`	`98`	`{`
`99`		`- return System.BitConverter.GetBytes(value);`
	`99`	`+ return BitConverter.GetBytes(value);`
`100`	`100`	`}`
`101`	`101`	`else`
`102`	`102`	`{`
`103`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`103`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`	`///`
`@@ -119,11 +119,11 @@ public byte[] GetBytes(float value)`
`119`	`119`	`{`
`120`	`120`	`if (IsLittleEndian)`
`121`	`121`	`{`
`122`		`- return System.BitConverter.GetBytes(value);`
	`122`	`+ return BitConverter.GetBytes(value);`
`123`	`123`	`}`
`124`	`124`	`else`
`125`	`125`	`{`
`126`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`126`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`	`///`
`@@ -141,11 +141,11 @@ public byte[] GetBytes(int value)`
`141`	`141`	`{`
`142`	`142`	`if (IsLittleEndian)`
`143`	`143`	`{`
`144`		`- return System.BitConverter.GetBytes(value);`
	`144`	`+ return BitConverter.GetBytes(value);`
`145`	`145`	`}`
`146`	`146`	`else`
`147`	`147`	`{`
`148`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`148`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`	`///`
`@@ -163,11 +163,11 @@ public byte[] GetBytes(long value)`
`163`	`163`	`{`
`164`	`164`	`if (IsLittleEndian)`
`165`	`165`	`{`
`166`		`- return System.BitConverter.GetBytes(value);`
	`166`	`+ return BitConverter.GetBytes(value);`
`167`	`167`	`}`
`168`	`168`	`else`
`169`	`169`	`{`
`170`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`170`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`171`	`171`	`}`
`172`	`172`	`}`
`173`	`173`	`///`
`@@ -185,11 +185,11 @@ public byte[] GetBytes(short value)`
`185`	`185`	`{`
`186`	`186`	`if (IsLittleEndian)`
`187`	`187`	`{`
`188`		`- return System.BitConverter.GetBytes(value);`
	`188`	`+ return BitConverter.GetBytes(value);`
`189`	`189`	`}`
`190`	`190`	`else`
`191`	`191`	`{`
`192`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`192`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`	`///`
`@@ -207,11 +207,11 @@ public byte[] GetBytes(uint value)`
`207`	`207`	`{`
`208`	`208`	`if (IsLittleEndian)`
`209`	`209`	`{`
`210`		`- return System.BitConverter.GetBytes(value);`
	`210`	`+ return BitConverter.GetBytes(value);`
`211`	`211`	`}`
`212`	`212`	`else`
`213`	`213`	`{`
`214`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`214`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`215`	`215`	`}`
`216`	`216`	`}`
`217`	`217`	`///`
`@@ -229,11 +229,11 @@ public byte[] GetBytes(ulong value)`
`229`	`229`	`{`
`230`	`230`	`if (IsLittleEndian)`
`231`	`231`	`{`
`232`		`- return System.BitConverter.GetBytes(value);`
	`232`	`+ return BitConverter.GetBytes(value);`
`233`	`233`	`}`
`234`	`234`	`else`
`235`	`235`	`{`
`236`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`236`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`	`///`
`@@ -251,11 +251,11 @@ public byte[] GetBytes(ushort value)`
`251`	`251`	`{`
`252`	`252`	`if (IsLittleEndian)`
`253`	`253`	`{`
`254`		`- return System.BitConverter.GetBytes(value);`
	`254`	`+ return BitConverter.GetBytes(value);`
`255`	`255`	`}`
`256`	`256`	`else`
`257`	`257`	`{`
`258`		`- return System.BitConverter.GetBytes(value).Reverse().ToArray();`
	`258`	`+ return Enumerable.Reverse(BitConverter.GetBytes(value)).ToArray();`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`	`///`
`@@ -377,7 +377,7 @@ public int ToInt16(byte[] value, int startIndex)`
`377`	`377`	`{`
`378`	`378`	`if (IsLittleEndian)`
`379`	`379`	`{`
`380`		`- return System.BitConverter.ToInt16(value, startIndex);`
	`380`	`+ return BitConverter.ToInt16(value, startIndex);`
`381`	`381`	`}`
`382`	`382`	`else`
`383`	`383`	`{`
`@@ -415,7 +415,7 @@ public int ToInt32(byte[] value, int startIndex)`
`415`	`415`	`{`
`416`	`416`	`if (IsLittleEndian)`
`417`	`417`	`{`
`418`		`- return System.BitConverter.ToInt32(value, startIndex);`
	`418`	`+ return BitConverter.ToInt32(value, startIndex);`
`419`	`419`	`}`
`420`	`420`	`else`
`421`	`421`	`{`
`@@ -453,7 +453,7 @@ public long ToInt64(byte[] value, int startIndex)`
`453`	`453`	`{`
`454`	`454`	`if (IsLittleEndian)`
`455`	`455`	`{`
`456`		`- return System.BitConverter.ToInt64(value, startIndex);`
	`456`	`+ return BitConverter.ToInt64(value, startIndex);`
`457`	`457`	`}`
`458`	`458`	`else`
`459`	`459`	`{`
`@@ -500,11 +500,11 @@ public float ToSingle(byte[] value, int startIndex)`
`500`	`500`	`{`
`501`	`501`	`if (IsLittleEndian)`
`502`	`502`	`{`
`503`		`- return System.BitConverter.ToSingle(value, startIndex);`
	`503`	`+ return BitConverter.ToSingle(value, startIndex);`
`504`	`504`	`}`
`505`	`505`	`else`
`506`	`506`	`{`
`507`		`- return System.BitConverter.ToSingle(value.Reverse().ToArray(), value.Length - sizeof(Single) - startIndex);`
	`507`	`+ return BitConverter.ToSingle(Enumerable.Reverse(value).ToArray(), value.Length - sizeof(Single) - startIndex);`
`508`	`508`	`}`
`509`	`509`	`}`
`510`	`510`	`///`
`@@ -528,11 +528,11 @@ public string ToString(byte[] value)`
`528`	`528`	`{`
`529`	`529`	`if (IsLittleEndian)`
`530`	`530`	`{`
`531`		`- return System.BitConverter.ToString(value);`
	`531`	`+ return BitConverter.ToString(value);`
`532`	`532`	`}`
`533`	`533`	`else`
`534`	`534`	`{`
`535`		`- return System.BitConverter.ToString(value.Reverse().ToArray());`
	`535`	`+ return BitConverter.ToString(Enumerable.Reverse(value).ToArray());`
`536`	`536`	`}`
`537`	`537`	`}`
`538`	`538`	`///`
`@@ -563,11 +563,11 @@ public string ToString(byte[] value, int startIndex)`
`563`	`563`	`{`
`564`	`564`	`if (IsLittleEndian)`
`565`	`565`	`{`
`566`		`- return System.BitConverter.ToString(value, startIndex);`
	`566`	`+ return BitConverter.ToString(value, startIndex);`
`567`	`567`	`}`
`568`	`568`	`else`
`569`	`569`	`{`
`570`		`- return System.BitConverter.ToString(value.Reverse().ToArray(), startIndex);`
	`570`	`+ return BitConverter.ToString(Enumerable.Reverse(value).ToArray(), startIndex);`
`571`	`571`	`}`
`572`	`572`	`}`
`573`	`573`	`///`
`@@ -607,11 +607,11 @@ public string ToString(byte[] value, int startIndex, int length)`
`607`	`607`	`{`
`608`	`608`	`if (IsLittleEndian)`
`609`	`609`	`{`
`610`		`- return System.BitConverter.ToString(value, startIndex, length);`
	`610`	`+ return BitConverter.ToString(value, startIndex, length);`
`611`	`611`	`}`
`612`	`612`	`else`
`613`	`613`	`{`
`614`		`- return System.BitConverter.ToString(value.Reverse().ToArray(), startIndex, length);`
	`614`	`+ return BitConverter.ToString(Enumerable.Reverse(value).ToArray(), startIndex, length);`
`615`	`615`	`}`
`616`	`616`	`}`
`617`	`617`	`///`
`@@ -643,11 +643,11 @@ public ushort ToUInt16(byte[] value, int startIndex)`
`643`	`643`	`{`
`644`	`644`	`if (IsLittleEndian)`
`645`	`645`	`{`
`646`		`- return System.BitConverter.ToUInt16(value, startIndex);`
	`646`	`+ return BitConverter.ToUInt16(value, startIndex);`
`647`	`647`	`}`
`648`	`648`	`else`
`649`	`649`	`{`
`650`		`- return System.BitConverter.ToUInt16(value.Reverse().ToArray(), value.Length - sizeof(UInt16) - startIndex);`
	`650`	`+ return BitConverter.ToUInt16(Enumerable.Reverse(value).ToArray(), value.Length - sizeof(UInt16) - startIndex);`
`651`	`651`	`}`
`652`	`652`	`}`
`653`	`653`	`///`
`@@ -680,7 +680,7 @@ public uint ToUInt32(byte[] value, int startIndex)`
`680`	`680`	`{`
`681`	`681`	`if (IsLittleEndian)`
`682`	`682`	`{`
`683`		`- return System.BitConverter.ToUInt32(value, startIndex);`
	`683`	`+ return BitConverter.ToUInt32(value, startIndex);`
`684`	`684`	`}`
`685`	`685`	`else`
`686`	`686`	`{`
`@@ -717,7 +717,7 @@ public ulong ToUInt64(byte[] value, int startIndex)`
`717`	`717`	`{`
`718`	`718`	`if (IsLittleEndian)`
`719`	`719`	`{`
`720`		`- return System.BitConverter.ToUInt64(value, startIndex);`
	`720`	`+ return BitConverter.ToUInt64(value, startIndex);`
`721`	`721`	`}`
`722`	`722`	`else`
`723`	`723`	`{`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ protected COMWrapperContext(object instance)`
`39`	`39`
`40`	`40`	`private static Type FindTypeByName(string typeName)`
`41`	`41`	`{`
`42`		`- foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies().Reverse())`
	`42`	`+ foreach (var assembly in Enumerable.Reverse(AppDomain.CurrentDomain.GetAssemblies()))`
`43`	`43`	`{`
`44`	`44`	`var tt = assembly.GetType(typeName, throwOnError:false, ignoreCase:true);`
`45`	`45`	`if (tt != null)`