System.Resources.ResourceWriter.Write7BitEncodedInt C# (CSharp) Méthode

        private static void Write7BitEncodedInt(BinaryWriter store, int value)
        {
            Debug.Assert(store != null);
            // Write out an int 7 bits at a time.  The high bit of the byte,
            // when on, tells reader to continue reading more bytes.
            uint v = (uint)value;   // support negative numbers
            while (v >= 0x80)
            {
                store.Write((byte)(v | 0x80));
                v >>= 7;
            }
            store.Write((byte)v);
        }

        public void Generate()
        {
            if (this._resourceList == null)
            {
                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ResourceWriterSaved"));
            }
            BinaryWriter  binaryWriter1 = new BinaryWriter(this._output, Encoding.UTF8);
            List <string> types         = new List <string>();

            binaryWriter1.Write(ResourceManager.MagicNumber);
            binaryWriter1.Write(ResourceManager.HeaderVersionNumber);
            MemoryStream memoryStream1         = new MemoryStream(240);
            BinaryWriter binaryWriter2         = new BinaryWriter((Stream)memoryStream1);
            string       assemblyQualifiedName = MultitargetingHelpers.GetAssemblyQualifiedName(typeof(ResourceReader), this.typeConverter);

            binaryWriter2.Write(assemblyQualifiedName);
            string str = ResourceManager.ResSetTypeName;

            binaryWriter2.Write(str);
            binaryWriter2.Flush();
            binaryWriter1.Write((int)memoryStream1.Length);
            binaryWriter1.Write(memoryStream1.GetBuffer(), 0, (int)memoryStream1.Length);
            binaryWriter1.Write(2);
            int count = this._resourceList.Count;

            if (this._preserializedData != null)
            {
                count += this._preserializedData.Count;
            }
            binaryWriter1.Write(count);
            int[]         keys          = new int[count];
            int[]         items         = new int[count];
            int           index1        = 0;
            MemoryStream  memoryStream2 = new MemoryStream(count * 40);
            BinaryWriter  binaryWriter3 = new BinaryWriter((Stream)memoryStream2, Encoding.Unicode);
            Stream        output        = (Stream)null;
            PermissionSet permissionSet = new PermissionSet(PermissionState.None);

            permissionSet.AddPermission((IPermission) new EnvironmentPermission(PermissionState.Unrestricted));
            permissionSet.AddPermission((IPermission) new FileIOPermission(PermissionState.Unrestricted));
            try
            {
                permissionSet.Assert();
                string tempFileName = Path.GetTempFileName();
                int    num1         = 8448;
                File.SetAttributes(tempFileName, (FileAttributes)num1);
                int num2       = 3;
                int num3       = 3;
                int num4       = 1;
                int bufferSize = 4096;
                int num5       = 201326592;
                output = (Stream) new FileStream(tempFileName, (FileMode)num2, (FileAccess)num3, (FileShare)num4, bufferSize, (FileOptions)num5);
            }
            catch (UnauthorizedAccessException ex)
            {
                output = (Stream) new MemoryStream();
            }
            catch (IOException ex)
            {
                output = (Stream) new MemoryStream();
            }
            finally
            {
                PermissionSet.RevertAssert();
            }
            using (output)
            {
                BinaryWriter binaryWriter4 = new BinaryWriter(output, Encoding.UTF8);
                IFormatter   objFormatter  = (IFormatter) new BinaryFormatter((ISurrogateSelector)null, new StreamingContext(StreamingContextStates.File | StreamingContextStates.Persistence));
                SortedList   sortedList    = new SortedList((IDictionary)this._resourceList, (IComparer)FastResourceComparer.Default);
                if (this._preserializedData != null)
                {
                    foreach (KeyValuePair <string, ResourceWriter.PrecannedResource> keyValuePair in this._preserializedData)
                    {
                        sortedList.Add((object)keyValuePair.Key, (object)keyValuePair.Value);
                    }
                }
                IDictionaryEnumerator enumerator = sortedList.GetEnumerator();
                while (enumerator.MoveNext())
                {
                    keys[index1]    = FastResourceComparer.HashFunction((string)enumerator.Key);
                    items[index1++] = (int)binaryWriter3.Seek(0, SeekOrigin.Current);
                    binaryWriter3.Write((string)enumerator.Key);
                    binaryWriter3.Write((int)binaryWriter4.Seek(0, SeekOrigin.Current));
                    object           obj      = enumerator.Value;
                    ResourceTypeCode typeCode = this.FindTypeCode(obj, types);
                    ResourceWriter.Write7BitEncodedInt(binaryWriter4, (int)typeCode);
                    ResourceWriter.PrecannedResource precannedResource = obj as ResourceWriter.PrecannedResource;
                    if (precannedResource != null)
                    {
                        binaryWriter4.Write(precannedResource.Data);
                    }
                    else
                    {
                        this.WriteValue(typeCode, obj, binaryWriter4, objFormatter);
                    }
                }
                binaryWriter1.Write(types.Count);
                for (int index2 = 0; index2 < types.Count; ++index2)
                {
                    binaryWriter1.Write(types[index2]);
                }
                Array.Sort <int, int>(keys, items);
                binaryWriter1.Flush();
                int num1 = (int)binaryWriter1.BaseStream.Position & 7;
                if (num1 > 0)
                {
                    for (int index2 = 0; index2 < 8 - num1; ++index2)
                    {
                        binaryWriter1.Write("PAD"[index2 % 3]);
                    }
                }
                foreach (int num2 in keys)
                {
                    binaryWriter1.Write(num2);
                }
                foreach (int num2 in items)
                {
                    binaryWriter1.Write(num2);
                }
                binaryWriter1.Flush();
                binaryWriter3.Flush();
                binaryWriter4.Flush();
                int num3 = (int)(binaryWriter1.Seek(0, SeekOrigin.Current) + memoryStream2.Length) + 4;
                binaryWriter1.Write(num3);
                binaryWriter1.Write(memoryStream2.GetBuffer(), 0, (int)memoryStream2.Length);
                binaryWriter3.Close();
                output.Position = 0L;
                output.CopyTo(binaryWriter1.BaseStream);
                binaryWriter4.Close();
            }
            binaryWriter1.Flush();
            this._resourceList = (Dictionary <string, object>)null;
        }