The Labs \ Source Viewer \ SSCLI \ System.IO \ FileSystemInfo

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class:  FileSystemInfo   
  18. **
  19. **
  20. ** Purpose:
  21. **
  22. **
  23. ===========================================================*/
  24. using System;
  25. using System.Collections;
  26. using System.Security;
  27. using System.Security.Permissions;
  28. using Microsoft.Win32;
  29. using System.Text;
  30. using System.Runtime.InteropServices;
  31. using System.Runtime.Serialization;
  32. using System.Runtime.Versioning;
  33. namespace System.IO
  34. {
  35.     [Serializable()]
  36.     [FileIOPermissionAttribute(SecurityAction.InheritanceDemand, Unrestricted = true)]
  37.     [ComVisible(true)]
  38.     public abstract class FileSystemInfo : MarshalByRefObject, ISerializable
  39.     {
  40.         internal Win32Native.WIN32_FILE_ATTRIBUTE_DATA _data;
  41.         // Cache the file information
  42.         internal int _dataInitialised = -1;
  43.         // We use this field in conjunction with the Refresh methods, if we succeed
  44.         // we store a zero, on failure we store the HResult in it so that we can
  45.         // give back a generic error back.
  46.         private const int ERROR_INVALID_PARAMETER = 87;
  47.         internal const int ERROR_ACCESS_DENIED = 5;
  48.        
  49.         protected string FullPath;
  50.         // fully qualified path of the directory
  51.         protected string OriginalPath;
  52.         // path passed in by the user
  53.         protected FileSystemInfo()
  54.         {
  55.         }
  56.        
  57.         [ResourceExposure(ResourceScope.None)]
  58.         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  59.         protected FileSystemInfo(SerializationInfo info, StreamingContext context)
  60.         {
  61.             if (info == null)
  62.                 throw new ArgumentNullException("info");
  63.            
  64.             // Must use V1 field names here, since V1 didn't implement
  65.             // ISerializable.
  66.             FullPath = Path.GetFullPathInternal(info.GetString("FullPath"));
  67.             OriginalPath = info.GetString("OriginalPath");
  68.            
  69.             // Lazily initialize the file attributes.
  70.             _dataInitialised = -1;
  71.         }
  72.        
  73.        
  74.         // Full path of the direcory/file
  75.         public virtual string FullName {
  76.             get {
  77.                 string demandDir;
  78.                 if (this is DirectoryInfo)
  79.                     demandDir = Directory.GetDemandDir(FullPath, true);
  80.                 else
  81.                     demandDir = FullPath;
  82.                 new FileIOPermission(FileIOPermissionAccess.PathDiscovery, demandDir).Demand();
  83.                 return FullPath;
  84.             }
  85.         }
  86.        
  87.         public string Extension {
  88.             get {
  89.                 // GetFullPathInternal would have already stripped out the terminating "." if present.
  90.                 int length = FullPath.Length;
  91.                 for (int i = length; --i >= 0;) {
  92.                     char ch = FullPath[i];
  93.                     if (ch == '.')
  94.                         return FullPath.Substring(i, length - i);
  95.                     if (ch == Path.DirectorySeparatorChar || ch == Path.AltDirectorySeparatorChar || ch == Path.VolumeSeparatorChar)
  96.                         break;
  97.                 }
  98.                 return String.Empty;
  99.             }
  100.         }
  101.        
  102.         // For files name of the file is returned, for directories the last directory in hierarchy is returned if possible,
  103.         // otherwise the fully qualified name s returned
  104.         public abstract string Name {
  105.             get;
  106.         }
  107.        
  108.         // Whether a file/directory exists
  109.         public abstract bool Exists {
  110.             get;
  111.         }
  112.        
  113.         // Delete a file/directory
  114.         public abstract void Delete();
  115.        
  116.         public DateTime CreationTime {
  117.             get { return CreationTimeUtc.ToLocalTime(); }
  118.            
  119.             set { CreationTimeUtc = value.ToUniversalTime(); }
  120.         }
  121.        
  122.         [ComVisible(false)]
  123.         public DateTime CreationTimeUtc {
  124.             get {
  125.                 if (_dataInitialised == -1) {
  126.                     _data = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
  127.                     Refresh();
  128.                 }
  129.                
  130.                 if (_dataInitialised != 0)
  131.                     // Refresh was unable to initialise the data
  132.                     __Error.WinIOError(_dataInitialised, OriginalPath);
  133.                
  134.                 long fileTime = ((long)_data.ftCreationTimeHigh << 32) | _data.ftCreationTimeLow;
  135.                 return DateTime.FromFileTimeUtc(fileTime);
  136.                
  137.             }
  138.            
  139.             [ResourceExposure(ResourceScope.None)]
  140.             [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  141.             set {
  142.                 if (this is DirectoryInfo)
  143.                     Directory.SetCreationTimeUtc(FullPath, value);
  144.                 else
  145.                     File.SetCreationTimeUtc(FullPath, value);
  146.                 _dataInitialised = -1;
  147.             }
  148.         }
  149.        
  150.         public DateTime LastAccessTime {
  151.             get { return LastAccessTimeUtc.ToLocalTime(); }
  152.             set { LastAccessTimeUtc = value.ToUniversalTime(); }
  153.         }
  154.        
  155.         [ComVisible(false)]
  156.         public DateTime LastAccessTimeUtc {
  157.             get {
  158.                 if (_dataInitialised == -1) {
  159.                     _data = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
  160.                     Refresh();
  161.                 }
  162.                
  163.                 if (_dataInitialised != 0)
  164.                     // Refresh was unable to initialise the data
  165.                     __Error.WinIOError(_dataInitialised, OriginalPath);
  166.                
  167.                 long fileTime = ((long)_data.ftLastAccessTimeHigh << 32) | _data.ftLastAccessTimeLow;
  168.                 return DateTime.FromFileTimeUtc(fileTime);
  169.                
  170.             }
  171.            
  172.             [ResourceExposure(ResourceScope.None)]
  173.             [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  174.             set {
  175.                 if (this is DirectoryInfo)
  176.                     Directory.SetLastAccessTimeUtc(FullPath, value);
  177.                 else
  178.                     File.SetLastAccessTimeUtc(FullPath, value);
  179.                 _dataInitialised = -1;
  180.             }
  181.         }
  182.        
  183.         public DateTime LastWriteTime {
  184.             get { return LastWriteTimeUtc.ToLocalTime(); }
  185.             set { LastWriteTimeUtc = value.ToUniversalTime(); }
  186.         }
  187.        
  188.         [ComVisible(false)]
  189.         public DateTime LastWriteTimeUtc {
  190.             get {
  191.                 if (_dataInitialised == -1) {
  192.                     _data = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
  193.                     Refresh();
  194.                 }
  195.                
  196.                 if (_dataInitialised != 0)
  197.                     // Refresh was unable to initialise the data
  198.                     __Error.WinIOError(_dataInitialised, OriginalPath);
  199.                
  200.                
  201.                 long fileTime = ((long)_data.ftLastWriteTimeHigh << 32) | _data.ftLastWriteTimeLow;
  202.                 return DateTime.FromFileTimeUtc(fileTime);
  203.             }
  204.            
  205.             [ResourceExposure(ResourceScope.None)]
  206.             [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  207.             set {
  208.                 if (this is DirectoryInfo)
  209.                     Directory.SetLastWriteTimeUtc(FullPath, value);
  210.                 else
  211.                     File.SetLastWriteTimeUtc(FullPath, value);
  212.                 _dataInitialised = -1;
  213.             }
  214.         }
  215.        
  216.         [ResourceExposure(ResourceScope.None)]
  217.         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  218.         public void Refresh()
  219.         {
  220.             _dataInitialised = File.FillAttributeInfo(FullPath, ref _data, false, false);
  221.         }
  222.        
  223.         public FileAttributes Attributes {
  224.             get {
  225.                 if (_dataInitialised == -1) {
  226.                     _data = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
  227.                     Refresh();
  228.                     // Call refresh to intialise the data
  229.                 }
  230.                
  231.                 if (_dataInitialised != 0)
  232.                     // Refresh was unable to initialise the data
  233.                     __Error.WinIOError(_dataInitialised, OriginalPath);
  234.                
  235.                 return (FileAttributes)_data.fileAttributes;
  236.             }
  237.             set {
  238.                 new FileIOPermission(FileIOPermissionAccess.Write, FullPath).Demand();
  239.                 bool r = Win32Native.SetFileAttributes(FullPath, (int)value);
  240.                 if (!r) {
  241.                     int hr = Marshal.GetLastWin32Error();
  242.                    
  243.                     if (hr == ERROR_INVALID_PARAMETER)
  244.                         throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileAttrs"));
  245.                    
  246.                     // For whatever reason we are turning ERROR_ACCESS_DENIED into
  247.                     // ArgumentException here (probably done for some 9x code path).
  248.                     // We can't change this now but special casing the error message instead.
  249.                     if (hr == ERROR_ACCESS_DENIED)
  250.                         throw new ArgumentException(Environment.GetResourceString("UnauthorizedAccess_IODenied_NoPathName"));
  251.                     __Error.WinIOError(hr, OriginalPath);
  252.                 }
  253.                 _dataInitialised = -1;
  254.             }
  255.         }
  256.        
  257.         [ComVisible(false)]
  258.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
  259.         public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
  260.         {
  261.             new FileIOPermission(FileIOPermissionAccess.PathDiscovery, FullPath).Demand();
  262.            
  263.             info.AddValue("OriginalPath", OriginalPath, typeof(string));
  264.             info.AddValue("FullPath", FullPath, typeof(string));
  265.         }
  266.     }
  267. }

Developer Fusion