C# FileStream.?.Close方法代码示例

        protected override DateTime? GetBuildTime()
        {
            if (!Configuration.UseBuildTime) return null;

            const int peHeaderOffset = 60;
            const int linkerTimestampOffset = 8;

            FileStream s = null;
            var b = new byte[2048];

            try
            {
                var filePath = GetFirstAssembly().Location;
                s = new FileStream(filePath, FileMode.Open, FileAccess.Read);
                s.Read(b, 0, 2048);
            }
            finally
            {
                s?.Close();
            }

            var i = BitConverter.ToInt32(b, peHeaderOffset);
            var secondsSince1970 = BitConverter.ToInt32(b, i + linkerTimestampOffset);
            var dt = new DateTime(1970, 1, 1, 0, 0, 0);
            dt = dt.AddSeconds(secondsSince1970);
            dt = dt.AddHours(TimeZone.CurrentTimeZone.GetUtcOffset(dt).Hours);

            return dt;
        }

 public void AddFlie(string name, string filename)
 {
     if (!File.Exists(filename))
         throw new FileNotFoundException(filename);
     FileStream fs = null;
     try
     {
         fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
         var fileData = new byte[fs.Length];
         fs.Read(fileData, 0, fileData.Length);
         AddFlie(name, Path.GetFileName(filename), fileData, fileData.Length);
     }
     finally
     {
         fs?.Close();
     }
 }

 // 二进制数据写入到文件
 public static bool WriteData(string path, byte[] data)
 {
     FileStream fs = null;
     try
     {
         fs = new FileStream(path, FileMode.Create);
         fs.Write(data, 0, data.Length);
     }
     catch (Exception e)
     {
         MessageBox.Show(e.Message, e.Source, MessageBoxButton.OK, MessageBoxImage.Error);
         return false;
     }
     finally
     {
         fs?.Close();
     }
     return true;
 }

        public static void DownLoad(string FileName)
        {
            string filePath = MapPathFile(FileName);
            long chunkSize = 204800;
            byte[] buffer = new byte[chunkSize];
            FileStream stream = null;
            try
            {
                stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
                var dataToRead = stream.Length;

                HttpContext.Current.Response.ContentType = "application/octet-stream";
                HttpContext.Current.Response.AddHeader("Content-Disposition", "attachement;filename=" + HttpUtility.UrlEncode(Path.GetFileName(filePath)));
                HttpContext.Current.Response.AddHeader("Content-Length", dataToRead.ToString());

                while (dataToRead > 0)
                {
                    if (HttpContext.Current.Response.IsClientConnected)
                    {
                        int length = stream.Read(buffer, 0, Convert.ToInt32(chunkSize));
                        HttpContext.Current.Response.OutputStream.Write(buffer, 0, length);
                        HttpContext.Current.Response.Flush();
                        HttpContext.Current.Response.Clear();
                        dataToRead -= length;
                    }
                    else
                    {
                        dataToRead = -1;
                    }
                }
            }
            catch (Exception ex)
            {
                HttpContext.Current.Response.Write("Error:" + ex.Message);
            }
            finally
            {
                stream?.Close();
                HttpContext.Current.Response.Close();
            }
        }

        private static void GenerateVCFile()
        {
            var fileName = Arguments[Parameters.GenerateVC.TL()] != null
                               ? Arguments[Parameters.GenerateVC.TL()].First()
                               : "VersioningControl.xml";

            var stream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(VersionControlResource);
            if (stream == null)
            {
                throw new MissingManifestResourceException("A versioning control file cannot be created. The embedded resource is not found.");
            }

            FileStream file = null;
            try
            {
                file = new FileStream(fileName, FileMode.Create);
                var b = new byte[stream.Length + 1];
                stream.Read(b, 0, Convert.ToInt32(stream.Length));
                file.Write(b, 0, Convert.ToInt32(b.Length - 1));
                file.Flush();
            }
            catch (UnauthorizedAccessException ex)
            {
                throw new ProcessCommandException("A versioning control file cannot be created by unauthorized access.", ex);
            }
            catch (IOException ex)
            {
                throw new ProcessCommandException($"A versioning control file cannot be created by an unknown error.\n{ex.Message}", ex);
            }
            catch (ArgumentException ex)
            {
                throw new ProcessCommandException($"A versioning control file cannot be created.\n{ex.Message}", ex);
            }
            finally
            {
                file?.Close();
                stream?.Close();
            }
        }

        public static bool SaveFile(string fileName, object toSerialize, System.Windows.Forms.IWin32Window owner)
        {
            FileStream outStream = null;
            bool saveOk = false;

            try
            {
                outStream = new FileStream(fileName, FileMode.Create);
                (new BinaryFormatter()).Serialize(outStream, toSerialize);

                outStream.Close();
                outStream = null;

                saveOk = true;
            }
            catch (IOException ex)
            {
                FormAlert.Alert(AlertType.FileErrorSave, owner, fileName, ex.Message);
            }
            finally
            {
                outStream?.Close();
            }

            return saveOk;
        }

        public static object LoadFile(string fileName, bool ignoreMissingFile, System.Windows.Forms.IWin32Window owner)
        {
            object obj = null;
            FileStream inStream = null;

            try
            {
                inStream = new FileStream(fileName, FileMode.Open);
                obj = (new BinaryFormatter()).Deserialize(inStream);
                inStream.Close();
                inStream = null;
            }
            catch (FileNotFoundException ex)
            {
                if (!ignoreMissingFile)
                    FormAlert.Alert(AlertType.FileErrorOpen, owner, fileName, ex.Message);
            }
            catch (IOException ex)
            {
                FormAlert.Alert(AlertType.FileErrorOpen, owner, fileName, ex.Message);
            }
            catch (System.Runtime.Serialization.SerializationException)
            {
                FormAlert.Alert(AlertType.FileErrorOpen, owner, fileName, Strings.FileFormatBad);
            }
            finally
            {
                inStream?.Close();
            }

            return obj;
        }

        private static bool FileIsWriteLocked(string fileName)
        {
            Stream fileStream = null;

            if (!File.Exists(fileName))
            {
                // It can't be locked if it doesn't exist
                return false;
            }

            try
            {
                // Try to open for shared reading
                fileStream = new FileStream(fileName,
                    FileMode.Open,
                    FileAccess.Read,
                    FileShare.Read | FileShare.Delete);

                // If we can open it for shared reading, it is not write locked
                return false;
            }
            catch
            {
                return true;
            }
            finally
            {
                fileStream?.Close();
            }
        }

        // Validate that we can write to the file.  This will enforce the ACL's
        // on the file.  Since we do our moving of files to replace, this is 
        // nice to ensure we are not by-passing some security permission
        // that someone set (although that could bypass this via move themselves)
        //
        // Note: 1) This is really just a nice to have, since with directory permissions
        //          they could do the same thing we are doing
        //
        //       2) We are depending on the current behavior that if the file is locked 
        //          and we can not open it, that we will get an UnauthorizedAccessException
        //          and not the IOException.
        private void ValidateWriteAccess(string filename)
        {
            FileStream fs = null;

            try
            {
                // Try to open file for write access
                fs = new FileStream(filename,
                    FileMode.Open,
                    FileAccess.Write,
                    FileShare.ReadWrite);
            }
            catch (IOException)
            {
                // Someone else was using the file.  Since we did not get
                // the unauthorizedAccessException we have access to the file
            }
            finally
            {
                fs?.Close();
            }
        }

 public void SaveFile(byte[] binData, string fileName, string fileType)
 {
     FileStream fileStream = null;
     MemoryStream m = new MemoryStream(binData);
     try
     {
         string savePath = HttpContext.Current.Server.MapPath("~/File/");
         if (!Directory.Exists(savePath))
         {
             Directory.CreateDirectory(savePath);
         }
         string File = savePath + fileName + fileType;
         fileStream = new FileStream(File, FileMode.Create);
         m.WriteTo(fileStream);
     }
     finally
     {
         m.Close();
         fileStream?.Close();
     }
 }

        static async Task WriteToDisk(HttpResponseMessage response, Uri uri, string filePath)
        {
            FileStream stream = null;
            try
            {
                stream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.None);
                await response.Content.CopyToAsync(stream);

            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error '{ex.Message}' when trying to fetch: {uri}");
            }
            finally
            {
                stream?.Close();
            }

        }

        public PinballXMenu UnmarshallXml(string filepath)
        {
            var menu = new PinballXMenu();

            if (!File.Exists(filepath)) {
                return menu;
            }
            Stream reader = null;
            try {
                var serializer = new XmlSerializer(typeof(PinballXMenu));
                reader = new FileStream(filepath, FileMode.Open);
                menu = serializer.Deserialize(reader) as PinballXMenu;

            } catch (Exception e) {
                _logger.Error(e, "Error parsing {0}: {1}", filepath, e.Message);
                _crashManager.Report(e, "xml");

            } finally {
                reader?.Close();
            }
            return menu;
        }

        public static DecisionBatch Load(string path)
        {
            DecisionBatch cls = null;
            FileStream fs = null;

            try
            {
                fs = new FileStream(path, FileMode.Open, FileAccess.Read);
                var formatter = new BinaryFormatter();
                cls = (DecisionBatch)formatter.Deserialize(fs);
                cls.Id = NCls++;
            }
            catch (Exception e)
            {
                Logger.Log(e);
            }
            finally
            {
                fs?.Close();
            }

            return cls;
        }

        public static DateTime RetrieveLinkerTimestamp()
        {
            var filePath = Assembly.GetCallingAssembly().Location;
            const int peHeaderOffset = 60;
            const int linkerTimestampOffset = 8;
            var b = new byte[2048];
            Stream s = null;

            try
            {
                s = new FileStream(filePath, FileMode.Open, FileAccess.Read);
                s.Read(b, 0, 2048);
            }
            finally
            {
                s?.Close();
            }

            var i = BitConverter.ToInt32(b, peHeaderOffset);
            var secondsSince1970 = BitConverter.ToInt32(b, i + linkerTimestampOffset);
            var dt = new DateTime(1970, 1, 1, 0, 0, 0);
            dt = dt.AddSeconds(secondsSince1970);
            dt = dt.AddHours(TimeZone.CurrentTimeZone.GetUtcOffset(dt).Hours);
            return dt;
        }

		private static bool IsFileLocked( string path ) {
			FileStream stream = null;
			try {
				stream = new FileStream( path, FileMode.Open, FileAccess.Read );
			} catch {
				return true;
			} finally {
				stream?.Close();
			}

			return false;
		}