//
-// System.IO.FIle.cs
+// System.IO.File.cs
//
//
// Authors:
//
// Copyright 2002 Ximian, Inc. http://www.ximian.com
// Copyright (C) 2001 Moonlight Enterprises, All Rights Reserved
-//
-
-//
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2004, 2006 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
//
using System;
+using System.Text;
+#if NET_2_0
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Security.AccessControl;
+#endif
namespace System.IO
{
/// <summary>
///
/// </summary>
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public
#if NET_2_0
static
private File () {}
#endif
+#if NET_2_0
+ public static void AppendAllText (string path, string contents)
+ {
+ using (TextWriter w = new StreamWriter (path, true)) {
+ w.Write (contents);
+ }
+ }
+
+ public static void AppendAllText (string path, string contents, Encoding encoding)
+ {
+ using (TextWriter w = new StreamWriter (path, true, encoding)) {
+ w.Write (contents);
+ }
+ }
+#endif
+
public static StreamWriter AppendText (string path)
{
return new StreamWriter (path, true);
}
- [MonoTODO("Security Permision Checks")]
public static void Copy (string sourceFilename, string destFilename)
{
Copy (sourceFilename, destFilename, false);
public static FileStream Create (string path)
{
- return Create (path, 8192);
+ return(Create (path, 8192, FileOptions.None, null));
}
public static FileStream Create (string path, int buffersize)
+ {
+ return(Create (path, buffersize, FileOptions.None,
+ null));
+ }
+
+#if NET_2_0
+ [MonoTODO ("options not implemented")]
+ public static FileStream Create (string path, int bufferSize,
+ FileOptions options)
+ {
+ return(Create (path, bufferSize, options, null));
+ }
+
+ [MonoTODO ("options and fileSecurity not implemented")]
+ public static FileStream Create (string path, int bufferSize,
+ FileOptions options,
+ FileSecurity fileSecurity)
+#else
+ private static FileStream Create (string path, int bufferSize,
+ FileOptions options,
+ object fileSecurity)
+#endif
{
if (null == path)
throw new ArgumentNullException ("path");
}
return new FileStream (path, FileMode.Create, FileAccess.ReadWrite,
- FileShare.None, buffersize);
+ FileShare.None, bufferSize);
}
public static StreamWriter CreateText(string path)
MonoIOError error;
if (!MonoIO.DeleteFile (path, out error)){
- Exception e = MonoIO.GetException (path, error);
- if (! (e is FileNotFoundException))
- throw e;
+ if (error != MonoIOError.ERROR_FILE_NOT_FOUND)
+ throw MonoIO.GetException (path, error);
}
}
}
MonoIOError error;
- bool exists;
-
- exists = MonoIO.ExistsFile (path, out error);
- if (error != MonoIOError.ERROR_SUCCESS &&
- error != MonoIOError.ERROR_FILE_NOT_FOUND &&
- error != MonoIOError.ERROR_PATH_NOT_FOUND &&
- error != MonoIOError.ERROR_INVALID_NAME) {
- throw MonoIO.GetException (path, error);
- }
-
- return(exists);
+ return MonoIO.ExistsFile (path, out error);
}
+#if NET_2_0
+ public static FileSecurity GetAccessControl (string path)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static FileSecurity GetAccessControl (string path, AccessControlSections includeSections)
+ {
+ throw new NotImplementedException ();
+ }
+#endif
+
public static FileAttributes GetAttributes (string path)
{
if (null == path) {
MonoIOStat stat;
MonoIOError error;
CheckPathExceptions (path);
-
- if (!MonoIO.GetFileStat (path, out stat, out error))
+
+ if (!MonoIO.GetFileStat (path, out stat, out error)) {
+#if NET_2_0
+ if (error == MonoIOError.ERROR_PATH_NOT_FOUND || error == MonoIOError.ERROR_FILE_NOT_FOUND)
+ return _defaultLocalFileTime;
+ else
+ throw new IOException (path);
+#else
throw new IOException (path);
+#endif
+ }
return DateTime.FromFileTime (stat.CreationTime);
}
MonoIOError error;
CheckPathExceptions (path);
- if (!MonoIO.GetFileStat (path, out stat, out error))
+ if (!MonoIO.GetFileStat (path, out stat, out error)) {
+#if NET_2_0
+ if (error == MonoIOError.ERROR_PATH_NOT_FOUND || error == MonoIOError.ERROR_FILE_NOT_FOUND)
+ return _defaultLocalFileTime;
+ else
+ throw new IOException (path);
+#else
throw new IOException (path);
+#endif
+ }
return DateTime.FromFileTime (stat.LastAccessTime);
}
MonoIOError error;
CheckPathExceptions (path);
- if (!MonoIO.GetFileStat (path, out stat, out error))
+ if (!MonoIO.GetFileStat (path, out stat, out error)) {
+#if NET_2_0
+ if (error == MonoIOError.ERROR_PATH_NOT_FOUND || error == MonoIOError.ERROR_FILE_NOT_FOUND)
+ return _defaultLocalFileTime;
+ else
+ throw new IOException (path);
+#else
throw new IOException (path);
+#endif
+ }
return DateTime.FromFileTime (stat.LastWriteTime);
}
public static FileStream Open (string path, FileMode mode)
{
- return new FileStream (path, mode, FileAccess.ReadWrite, FileShare.None);
+ return new FileStream (path, mode, mode == FileMode.Append ? FileAccess.Write : FileAccess.ReadWrite, FileShare.None);
}
public static FileStream Open (string path, FileMode mode, FileAccess access)
return new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
}
+#if NET_2_0
+ public static void Replace (string sourceFileName,
+ string destinationFileName,
+ string destinationBackupFileName)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static void Replace (string sourceFileName,
+ string destinationFileName,
+ string destinationBackupFileName,
+ bool ignoreMetadataErrors)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static void SetAccessControl (string path,
+ FileSecurity fileSecurity)
+ {
+ throw new NotImplementedException ();
+ }
+#endif
+
public static void SetAttributes (string path,
FileAttributes attributes)
{
}
#endregion
+
+#if NET_2_0
+ static File() {
+ _defaultLocalFileTime = new DateTime (1601, 1, 1);
+ _defaultLocalFileTime = _defaultLocalFileTime.ToLocalTime ();
+ }
+
+ //
+ // The documentation for this method is most likely wrong, it
+ // talks about doing a "binary read", but the remarks say
+ // that this "detects the encoding".
+ //
+ // This can not detect and do anything useful with the encoding
+ // since the result is a byte [] not a char [].
+ //
+ public static byte [] ReadAllBytes (string path)
+ {
+ using (FileStream s = Open (path, FileMode.Open, FileAccess.Read, FileShare.Read)){
+ long size = s.Length;
+
+ //
+ // Is this worth supporting?
+ //
+ if (size > Int32.MaxValue)
+ throw new ArgumentException ("Reading more than 4gigs with this call is not supported");
+
+ byte [] result = new byte [s.Length];
+
+ s.Read (result, 0, (int) size);
+
+ return result;
+ }
+ }
+
+ public static string [] ReadAllLines (string path)
+ {
+ using (StreamReader reader = File.OpenText (path)) {
+ return ReadAllLines (reader);
+ }
+ }
+
+ public static string [] ReadAllLines (string path, Encoding encoding)
+ {
+ using (StreamReader reader = new StreamReader (path, encoding)) {
+ return ReadAllLines (reader);
+ }
+ }
+
+ static string [] ReadAllLines (StreamReader reader)
+ {
+ List<string> list = new List<string> ();
+ while (!reader.EndOfStream)
+ list.Add (reader.ReadLine ());
+ return list.ToArray ();
+ }
+
+ public static string ReadAllText (string path)
+ {
+ return ReadAllText (path, Encoding.UTF8Unmarked);
+ }
+
+ public static string ReadAllText (string path, Encoding enc)
+ {
+ using (StreamReader sr = new StreamReader (path, enc)) {
+ return sr.ReadToEnd ();
+ }
+ }
+
+ public static void WriteAllBytes (string path, byte [] data)
+ {
+ using (Stream stream = File.Create (path)) {
+ stream.Write (data, 0, data.Length);
+ }
+ }
+
+ public static void WriteAllLines (string path, string [] lines)
+ {
+ using (StreamWriter writer = new StreamWriter (path)) {
+ WriteAllLines (writer, lines);
+ }
+ }
+
+ public static void WriteAllLines (string path, string [] lines, Encoding encoding)
+ {
+ using (StreamWriter writer = new StreamWriter (path, false, encoding)) {
+ WriteAllLines (writer, lines);
+ }
+ }
+
+ static void WriteAllLines (StreamWriter writer, string [] lines)
+ {
+ foreach (string line in lines)
+ writer.WriteLine (line);
+ }
+
+ public static void WriteAllText (string path, string contents)
+ {
+ WriteAllText (path, contents, Encoding.UTF8Unmarked);
+ }
+
+ public static void WriteAllText (string path, string contents, Encoding enc)
+ {
+ using (StreamWriter sw = new StreamWriter (path, false, enc)) {
+ sw.Write (contents);
+ }
+ }
+
+ private static readonly DateTime _defaultLocalFileTime;
+
+ [MonoLimitation ("File encryption isn't supported (even on NTFS).")]
+ public static void Encrypt (string path)
+ {
+ // MS.NET support this only on NTFS file systems, i.e. it's a file-system (not a framework) feature.
+ // otherwise it throws a NotSupportedException (or a PlatformNotSupportedException on older OS).
+ // we throw the same (instead of a NotImplementedException) because most code should already be
+ // handling this exception to work properly.
+ throw new NotSupportedException (Locale.GetText ("File encryption isn't supported on any file system."));
+ }
+
+ [MonoLimitation ("File encryption isn't supported (even on NTFS).")]
+ public static void Decrypt (string path)
+ {
+ // MS.NET support this only on NTFS file systems, i.e. it's a file-system (not a framework) feature.
+ // otherwise it throws a NotSupportedException (or a PlatformNotSupportedException on older OS).
+ // we throw the same (instead of a NotImplementedException) because most code should already be
+ // handling this exception to work properly.
+ throw new NotSupportedException (Locale.GetText ("File encryption isn't supported on any file system."));
+ }
+#endif
}
}
projects / mono.git / blobdiff