System.IO.FileStreamEx.ReadSize C# (CSharp) Méthode

        public int ReadSize()
        {
            /* ID3 Size is like:
             * 0XXXXXXXb 0XXXXXXXb 0XXXXXXXb 0XXXXXXXb (b means binary)
             * the zero bytes must ignore, so we have 28 bits number = 0x1000 0000 (maximum)
             * it's equal to 256MB
             */
            int RInt;
            RInt = ReadByte() * 0x200000;
            RInt += ReadByte() * 0x4000;
            RInt += ReadByte() * 0x80;
            RInt += ReadByte();
            return RInt;
        }

        /// <summary>
        /// Save ID3 info to file
        /// </summary>
        /// <param name="Ver">minor version of ID3v2</param>
        /// <param name="Formula">Formula to renaming file</param>
        public void Save(int Ver, string Formula)
        {
            if (Ver < 3 || Ver > 4)
                throw (new ArgumentOutOfRangeException("Version of ID3 can be between 3-4"));

            string NewFilePath;
            if (Formula == "")
                NewFilePath = _FilePath;
            else
            {
                string DirName = Path.GetDirectoryName(_FilePath);
                NewFilePath = DirName + ((DirName.Length > 0) ? "\\" : "") +
                    this.FormulaFileName(Formula);
            }

            FileStreamEx Orgin = new FileStreamEx(_FilePath, FileMode.Open);
            FileStreamEx Temp = new FileStreamEx(NewFilePath + "~TEMP", FileMode.Create);

            int StartIndex = 0;
            if (Orgin.HaveID3v2())
            {
                Orgin.Seek(3, SeekOrigin.Current);
                StartIndex = Orgin.ReadSize();
            }

            if (!_HaveTag)
            {
                SaveRestOfFile(StartIndex, Orgin, Temp, 0);
                return;
            }
            // if Orginal file and current file both don't contain ID3
            // we don't need to do anything

            WriteID3Header(Temp, Ver);

            foreach (TextFrame TF in _TextFrames.Items)
            {
                if (!FramesInfo.IsCompatible(TF.FrameID, Ver))
                    continue;

                if (TF.IsAvailable)
                    TF.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (UserTextFrame UTF in _UserTextFrames.Items)
            {
                if (!FramesInfo.IsCompatible(UTF.FrameID, Ver))
                    continue;

                if (UTF.IsAvailable)
                    UTF.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (PrivateFrame PF in _PrivateFrames.Items)
            {
                if (!FramesInfo.IsCompatible(PF.FrameID, Ver))
                    continue;

                if (PF.IsAvailable)
                    PF.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (TextWithLanguageFrame TWLF in _TextWithLangFrames.Items)
            {
                if (!FramesInfo.IsCompatible(TWLF.FrameID, Ver))
                    continue;

                if (TWLF.IsAvailable)
                    TWLF.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (SynchronisedText ST in _SynchronisedTextFrames.Items)
            {
                if (!FramesInfo.IsCompatible(ST.FrameID, Ver))
                    continue;

                if (ST.IsAvailable)
                    ST.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (AttachedPictureFrame AP in _AttachedPictureFrames.Items)
            {
                if (!FramesInfo.IsCompatible(AP.FrameID, Ver))
                    continue;

                if (AP.IsAvailable)
                    AP.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (GeneralFileFrame GF in _EncapsulatedObjectFrames.Items)
            {
                if (!FramesInfo.IsCompatible(GF.FrameID, Ver))
                    continue;

                if (GF.IsAvailable)
                    GF.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (PopularimeterFrame PF in _PopularimeterFrames.Items)
            {
                if (!FramesInfo.IsCompatible(PF.FrameID, Ver))
                    continue;

                if (PF.IsAvailable)
                    PF.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (AudioEncryptionFrame AE in _AudioEncryptionFrames.Items)
            {
                if (!FramesInfo.IsCompatible(AE.FrameID, Ver))
                    continue;

                if (AE.IsAvailable)
                    AE.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (LinkFrame LF in _LinkFrames.Items)
            {
                if (!FramesInfo.IsCompatible(LF.FrameID, Ver))
                    continue;

                if (LF.IsAvailable)
                    LF.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (TermOfUseFrame TU in _TermOfUseFrames.Items)
            {
                if (!FramesInfo.IsCompatible(TU.FrameID, Ver))
                    continue;

                if (TU.IsAvailable)
                    TU.FrameStream(Ver).WriteTo(Temp);
            }
            foreach (DataWithSymbolFrame DS in _DataWithSymbolFrames.Items)
            {
                if (!FramesInfo.IsCompatible(DS.FrameID, Ver))
                    continue;

                if (DS.IsAvailable)
                    DS.FrameStream(Ver).WriteTo(Temp);
            }
            // Saving Unknown Frames
            if (!_DropUnknown)
                foreach (BinaryFrame BF in _UnknownFrames.Items)
                    if (BF.IsAvailable)
                        BF.FrameStream(Ver).WriteTo(Temp);

            if (_MCDIFrame != null && FramesInfo.IsCompatible(_MCDIFrame.FrameID, Ver))
                if (_MCDIFrame.IsAvailable)
                    _MCDIFrame.FrameStream(Ver).WriteTo(Temp);
            if (_SYTCFrame != null && FramesInfo.IsCompatible(_SYTCFrame.FrameID, Ver))
                if (_SYTCFrame.IsAvailable)
                    _SYTCFrame.FrameStream(Ver).WriteTo(Temp);
            if (_PCNTFrame != null && FramesInfo.IsCompatible(_PCNTFrame.FrameID, Ver))
                if (_PCNTFrame.IsAvailable)
                    _PCNTFrame.FrameStream(Ver).WriteTo(Temp);
            if (_RBUFFrame != null && FramesInfo.IsCompatible(_RBUFFrame.FrameID, Ver))
                if (_RBUFFrame.IsAvailable)
                    _RBUFFrame.FrameStream(Ver).WriteTo(Temp);
            if (_OWNEFrame != null && FramesInfo.IsCompatible(_OWNEFrame.FrameID, Ver))
                if (_OWNEFrame.IsAvailable)
                    _OWNEFrame.FrameStream(Ver).WriteTo(Temp);
            if (_COMRFrame != null && FramesInfo.IsCompatible(_COMRFrame.FrameID, Ver))
                if (_COMRFrame.IsAvailable)
                    _COMRFrame.FrameStream(Ver).WriteTo(Temp);
            if (_RVRBFrame != null && FramesInfo.IsCompatible(_RVRBFrame.FrameID, Ver))
                if (_RVRBFrame.IsAvailable)
                    _RVRBFrame.FrameStream(Ver).WriteTo(Temp);
            if (_EQUAFrame != null && FramesInfo.IsCompatible(_EQUAFrame.FrameID, Ver))
                if (_EQUAFrame.IsAvailable)
                    _EQUAFrame.FrameStream(Ver).WriteTo(Temp);
            if (_RVADFrame != null && FramesInfo.IsCompatible(_RVADFrame.FrameID, Ver))
                if (_RVADFrame.IsAvailable)
                    _RVADFrame.FrameStream(Ver).WriteTo(Temp);
            if (_ETCOFrame != null && FramesInfo.IsCompatible(_ETCOFrame.FrameID, Ver))
                if (_ETCOFrame.IsAvailable)
                    _ETCOFrame.FrameStream(_ver.Minor).WriteTo(Temp);
            if (_POSSFrame != null && FramesInfo.IsCompatible(_POSSFrame.FrameID, Ver))
                if (_POSSFrame.IsAvailable)
                    _POSSFrame.FrameStream(Ver).WriteTo(Temp);

            SaveRestOfFile(StartIndex, Orgin, Temp, Ver);
        }