// Methods public static bool FileExists(string filePath) { if (File.Exists(filePath)) { return true; } FileIOPermission permission = null; try { permission = new FileIOPermission(FileIOPermissionAccess.AllAccess, filePath); } catch { return false; } try { permission.Demand(); } catch (Exception exception) { // } return false; }
public static bool CopyFile(string newFile, string oldFile) { var newfile = new FileInfo(newFile); var oldfile = new FileInfo(oldFile); string errorMsg = ""; var f2 = new FileIOPermission(FileIOPermissionAccess.AllAccess, oldFile); f2.AddPathList(FileIOPermissionAccess.Write | FileIOPermissionAccess.Read, newFile); try { f2.Demand(); } catch (SecurityException s) { Console.WriteLine(s.Message); } for (int x = 0; x < 100; x++) { try { File.Delete(oldfile.FullName); newfile.CopyTo(oldfile.FullName, true); return true; } catch(Exception e) { errorMsg = e.Message + " : " + e.InnerException; Thread.Sleep(200); } } Data.Logger(errorMsg); return false; }
public void Capture( OnlineCaptureInfo info ) { try { // Ensure permission to write to the archive directory. FileIOPermission p = new FileIOPermission( FileIOPermissionAccess.Write, new FileInfo( info.ArchiveDir ).FullName ); p.Demand(); logger = info.Logger; string html = CaptureText( info.AccountName, info.Credentials ); // Write HTML results to file string filename = Path.Combine( info.ArchiveDir, info.BaseName + ".htm" ); info.CapturedFiles.Add( Path.GetFileName( filename ) ); File.WriteAllText( filename, html ); } catch( SecurityException ex ) { throw new OnlineReaderException( "Security violation: " + ex.Message, ex ); } }
public Image ScanImage(ImageFormat outputFormat, string fileName) { if (outputFormat == null) throw new ArgumentNullException("outputFormat"); FileIOPermission filePerm = new FileIOPermission(FileIOPermissionAccess.AllAccess, fileName); filePerm.Demand(); ImageFile imageObject = null; try { if (WiaManager == null) WiaManager = new CommonDialogClass(); imageObject = WiaManager.ShowAcquireImage(WiaDeviceType.ScannerDeviceType, WiaImageIntent.GrayscaleIntent, WiaImageBias.MaximizeQuality, outputFormat.Guid.ToString("B"), false, true, true); imageObject.SaveFile(fileName); return Image.FromFile(fileName); } catch (COMException ex) { string message = "Error scanning image"; throw new WiaOperationException(message, ex); } finally { if (imageObject != null) Marshal.ReleaseComObject(imageObject); } }
public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config) { base.Initialize(name, config); if (string.IsNullOrEmpty(config["dataStorePath"])) throw new ProviderException("dataStorePath config attribute is required."); this._dataStorePath = config["dataStorePath"]; if (!VirtualPathUtility.IsAppRelative(this._dataStorePath)) throw new ArgumentException("dataStorePath must be app-relative"); string fullyQualifiedPath = VirtualPathUtility.Combine( VirtualPathUtility.AppendTrailingSlash(HttpRuntime.AppDomainAppVirtualPath), this._dataStorePath); this._dataStorePath = HostingEnvironment.MapPath(fullyQualifiedPath); config.Remove("dataStorePath"); // Make sure we have permission to read the XML data source and // throw an exception if we don't if (!Directory.Exists(this._dataStorePath)) Directory.CreateDirectory(this._dataStorePath); FileIOPermission permission = new FileIOPermission(FileIOPermissionAccess.AllAccess, this._dataStorePath); permission.Demand(); if (config.Count > 0) throw new ProviderException(string.Format("Unknown config attribute '{0}'", config.GetKey(0))); }
private static string _strRootFolder; //定义操作的根目录 /// <summary> /// 文件是否存在 /// </summary> /// <param name="filePath">文件路径</param> /// <returns></returns> public static bool FileExists(string filePath) { if (File.Exists(filePath)) { return true; } FileIOPermission permission = null; try { permission = new FileIOPermission(FileIOPermissionAccess.Read, filePath); } catch { return false; } try { permission.Demand(); } catch (Exception exception) { // Foe.Common.Log.ErrorFormat(string.Format("FileManager doesn't have the right to read the config file \"{0}\". Cause : {1}", filePath, exception.Message), exception); } return false; }
/// <summary> /// Creates a new WebTransform. /// </summary> public WebTransform() { //[IsolatedStorageFilePermissionAttribute(SecurityAction.Demand, Unrestricted=true)] FileIOPermission filePerm = new FileIOPermission(PermissionState.None); RegistryPermission regPerm = new RegistryPermission(PermissionState.None); filePerm.Demand(); regPerm.Demand(); }
private void ShowFileReadUI() { MessageBox.Show("Before calling demand"); FileIOPermission myPerm = new FileIOPermission(FileIOPermissionAccess.Read, "C:\\"); myPerm.Demand(); // All callers must have read permission to C drive. // Note: Using imperative syntax // Code to show UI MessageBox.Show("Showing FileRead UI"); // This is executed only if the demand is successful. }
public static bool RunSecurityDemands() { FileIOPermission fPer = new FileIOPermission(PermissionState.None); fPer.AllLocalFiles = FileIOPermissionAccess.AllAccess; fPer.AllFiles = FileIOPermissionAccess.AllAccess; try { fPer.Demand(); } catch (SecurityException s) { Common.DebugHelper.WriteLine("File IO Permission Error: {0}", s.Message); return false; } System.Security.Permissions.FileDialogPermission fdPer = new FileDialogPermission(FileDialogPermissionAccess.None); fdPer.Access = FileDialogPermissionAccess.OpenSave; try { fdPer.Demand(); } catch (System.Security.SecurityException s) { Common.DebugHelper.WriteLine("File Dialog Persmission Error: {0}", s.Message); return false; } System.Security.Permissions.RegistryPermission rPer = new RegistryPermission(PermissionState.None); rPer.SetPathList(RegistryPermissionAccess.AllAccess, "HKEY_LOCAL_MACHINE"); try { fPer.Demand(); } catch (System.Security.SecurityException s) { Common.DebugHelper.WriteLine("Registry Access Permission Error: {0}", s.Message); return false; } return true; }
/// <summary> /// Returns a dictionary of right names and the roles associated with them. /// </summary> /// <returns></returns> public override IDictionary<string, IEnumerable<string>> FillRights() { var path = string.Format("{0}rights.xml", BlogConfig.StorageLocation); if (!VirtualPathUtility.IsAppRelative(path)) { throw new ArgumentException("rights must be app-relative"); } var fullyQualifiedPath = VirtualPathUtility.Combine( VirtualPathUtility.AppendTrailingSlash(HttpRuntime.AppDomainAppVirtualPath), path); fullyQualifiedPath = HostingEnvironment.MapPath(fullyQualifiedPath); var rightsDict = new Dictionary<string, IEnumerable<string>>(); if (File.Exists(fullyQualifiedPath)) { // Make sure we have permission to read the XML data source and // throw an exception if we don't var permission = new FileIOPermission(FileIOPermissionAccess.Write, fullyQualifiedPath); permission.Demand(); var doc = new XmlDocument(); doc.Load(fullyQualifiedPath); foreach (XmlNode rightNode in doc.GetElementsByTagName("right")) { var rightName = rightNode.Attributes["name"].Value; var roleList = new HashSet<string>(StringComparer.OrdinalIgnoreCase); foreach (XmlNode roleNode in rightNode.ChildNodes) { if (roleNode.Name.Equals("role", StringComparison.OrdinalIgnoreCase)) { var roleName = roleNode.Attributes["name"].Value; roleName = roleName.Trim(); roleList.Add(roleName); } } rightsDict.Add(rightName, roleList); } } return rightsDict; }
public void Run() { var f = new FileIOPermission(PermissionState.None); f.AllLocalFiles = FileIOPermissionAccess.Read; try { f.Demand(); } catch (SecurityException s) { Console.WriteLine(s.Message); } }
private static void ImperativeCAS() { FileIOPermission f = new FileIOPermission(PermissionState.None); f.AllLocalFiles = FileIOPermissionAccess.Read; try { f.Demand(); } catch (SecurityException e) { Console.WriteLine(e.Message); } }
private void CASImerativeExample() { Console.WriteLine("Example of Imperative approach"); FileIOPermission f = new FileIOPermission(PermissionState.None); f.AllLocalFiles = FileIOPermissionAccess.Read; try { f.Demand(); } catch(SecurityException ex) { Console.WriteLine(ex.Message); } }
public static bool VerifyVermission(FileIOPermissionAccess permission, string path) { var ioPermission = new FileIOPermission(permission, path); try { ioPermission.Demand(); return true; } catch (SecurityException s) { return false; } }
/// <summary>Gets a list of resources for the specified resource set.</summary> /// <param name="resourceSetName">The name of the resource set to get resources for.</param> /// <returns>List of resources for the specified resource set. Note that if such resource set was not yet seen by this context /// it will get created (with empty list).</returns> public IList GetResourceSetEntities(string resourceSetName) { List<object> entities; if (resourceSetName != typeof(Design).Name) { if (!this.resourceSetsStorage.TryGetValue(resourceSetName, out entities)) { entities = new List<object>(); this.resourceSetsStorage[resourceSetName] = entities; } } else { entities = new List<object>(); entities.Add(new Design(){ Data="", FileName="new_design" //, FileURL="" }); //se están pidiendo los diseños grabados en el servidor. Tengo que elaborar la lista. // Create a StringBuilder used to create the result string StringBuilder resultText = new StringBuilder(); // Create an FileIOPermission for accessing the HttpContext.Current.Server.MapPath("/storage") folder String folderPath = HttpContext.Current.Server.MapPath(Servidor.STORAGE_RELATIVE_PATH); FileIOPermission permFileIO = new FileIOPermission(FileIOPermissionAccess.AllAccess, folderPath); try { // Demand the permission to access the C:\Temp folder. permFileIO.Demand(); System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(folderPath); foreach (var fileInfo in di.GetFiles("*.design")) { Design ds = new Design() { FileName = fileInfo.Name.Replace(".design",""), TimeStamp = fileInfo.LastWriteTime.ToString("dd/MM/yyyy hh:mm") //, FileURL = fileInfo.FullName.Replace(HttpContext.Current.Request.ServerVariables["APPL_PHYSICAL_PATH"], "/").Replace(@"\", "/") }; entities.Add(ds); } } catch (SecurityException se) { resultText.Append("The demand for permission to access the " + folderPath + " folder failed.\nException message: "); resultText.Append(se.Message); resultText.Append("\n\n"); } } return entities; }
public void Setup() { var examplesFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory + "\\ExampleJson"); FileIOPermission fileIoPermission = new FileIOPermission(FileIOPermissionAccess.Read, examplesFolder); fileIoPermission.Demand(); var transcriptJson = File.ReadAllText(examplesFolder + "\\Transcript.json"); transcript = JsonConvert.DeserializeObject<Transcript>(transcriptJson); var courseJson = File.ReadAllText(examplesFolder + "\\Course.json"); course = JsonConvert.DeserializeObject<Course>(courseJson); var courseModulesJson = File.ReadAllText(examplesFolder + "\\CourseModules.json"); course.CourseModules = JsonConvert.DeserializeObject<List<CourseModule>>(courseModulesJson); }
//Main_11_2_3 public static void Main_11_2_3() { //��ȡ��ȡ��д��tmp.txt�ļ���Ȩ�� FileIOPermission fileIOPermission = new FileIOPermission(FileIOPermissionAccess.Read | FileIOPermissionAccess.Write, @"E:\tmp.txt"); try { //ִ��Ȩ��� fileIOPermission.Demand(); } catch (SecurityException se) { Console.WriteLine("û�в������ļ���Ȩ�ޣ�"); } Console.Read(); }
public static bool AllowRead(params string[] files) { FileIOPermission f2 = new FileIOPermission(PermissionState.None); for (int i = 0; i < files.Length; i++) { f2.AddPathList(FileIOPermissionAccess.Read, files[i]); } try { f2.Demand(); return true; } catch { return false; } }
public IEnumerable<OnlineTransaction> Parse( OnlineCaptureInfo info ) { try { // Ensure permission to read from the archive directory. FileIOPermission p = new FileIOPermission( FileIOPermissionAccess.Read, new FileInfo( info.ArchiveDir ).FullName ); p.Demand(); string html = File.ReadAllText( Path.Combine( info.ArchiveDir, info.CapturedFiles[0] ) ); return ParseText( info.AccountName, html ); } catch( SecurityException ex ) { throw new OnlineReaderException( "Security violation: " + ex.Message, ex ); } }
public override void Initialize(string name, NameValueCollection config) { // Verify that config isn't null if (config == null) throw new ArgumentNullException("config"); // Assign the provider a default name if it doesn't have one if (String.IsNullOrEmpty(name)) name = "DynamicPersonalizationProvider"; // Add a default "description" attribute to config if the // attribute doesn't exist or is empty if (string.IsNullOrEmpty(config["description"])) { config.Remove("description"); config.Add("description", "Text file personalization provider"); } // Call the base class's Initialize method base.Initialize(name, config); // Throw an exception if unrecognized attributes remain if (config.Count > 0) { string attr = config.GetKey(0); if (!String.IsNullOrEmpty(attr)) throw new ProviderException ("Unrecognized attribute: " + attr); } string directory = HttpContext.Current.Server.MapPath("~/App_Data/Personalization_Data"); if (!Directory.Exists(directory)) Directory.CreateDirectory(directory); // Make sure we can read and write files in the // ~/App_Data/Personalization_Data directory FileIOPermission permission = new FileIOPermission (FileIOPermissionAccess.AllAccess, directory); permission.Demand(); }
/// <summary> /// Usuwa plik lub folder. Nie przenosi do kosza! /// </summary> /// <param name="fileOrFolder">Plik lub Folder</param> public static bool Delete(string fileOrFolder) { //TODO: Usuwanie do kosza! var folder = new DirectoryInfo(fileOrFolder); var folderIoPermission = new FileIOPermission(FileIOPermissionAccess.Write, folder.FullName); try { folderIoPermission.Demand(); File.SetAttributes(folder.FullName, FileAttributes.Normal); //Przy .SVN robi problemy :) foreach (var file in folder.GetFiles()) { File.SetAttributes(file.FullName, FileAttributes.Normal); file.Delete(); } if (folder.Exists) { folder.Delete(true); } } catch (IOException) { var file = new FileInfo(fileOrFolder); var fileIoPermission = new FileIOPermission(FileIOPermissionAccess.Write, file.FullName); try { if (file.Exists) { fileIoPermission.Demand(); File.SetAttributes(file.FullName, FileAttributes.Normal); file.Delete(); } } catch (UnauthorizedAccessException) { return false; } } return true; }
/// <summary> /// Ensure chosen folder is not protected before operating /// </summary> /// <param name="Path"></param> /// <returns></returns> public static bool Accessible(string Path) { if (!Directory.Exists(Path)) return false; try { string[] asDirs = Directory.GetDirectories(Path, "*", SearchOption.TopDirectoryOnly); FileIOPermission fp; for (int i = 0; i < asDirs.Length; i++) { fp = new FileIOPermission(FileIOPermissionAccess.Read | FileIOPermissionAccess.Write, asDirs[i]); fp.Demand(); } } catch { return false; } return true; }
public override void Install(IDictionary savedState) { // Demand IO permission required for LoadFrom FXCop 191096 FileIOPermission ioPermission = new FileIOPermission(FileIOPermissionAccess.Read, (string)Context.Parameters["assemblypath"]); ioPermission.Demand(); base.Install(savedState); // Context.LogMessage(RC.GetString("WMISCHEMA_INSTALLATIONSTART")); string assemblyPath = Context.Parameters["assemblypath"]; Assembly assembly = Assembly.LoadFrom(assemblyPath); SchemaNaming naming = SchemaNaming.GetSchemaNaming(assembly); // // We always use the full version number for Whidbey. // naming.DecoupledProviderInstanceName = AssemblyNameUtility.UniqueToAssemblyFullVersion(assembly); // See if this assembly provides instrumentation if(null == naming) return; // // [RAID: 123895] // If the force parameter is present, we update registration information independent if it already // exists. // if( ( naming.IsAssemblyRegistered() == false ) || ( Context.Parameters.ContainsKey ( "force" ) ) || ( Context.Parameters.ContainsKey ( "f" ) ) ) { Context.LogMessage(RC.GetString("REGESTRING_ASSEMBLY") + " " + naming.DecoupledProviderInstanceName); naming.RegisterNonAssemblySpecificSchema(Context); naming.RegisterAssemblySpecificSchema(); } mof = naming.Mof; Context.LogMessage(RC.GetString("WMISCHEMA_INSTALLATIONEND")); }
static public PolicyLevel LoadPolicyLevelFromFile(String path, PolicyLevelType type) { if (path == null) { throw new ArgumentNullException("path"); } ConfigId id = SharedStatics.GetNextConfigId(); ConfigRetval retval = Config.InitData(id, path); if ((retval & ConfigRetval.ConfigFile) == 0) { throw new ArgumentException(Environment.GetResourceString("Argument_PolicyFileDoesNotExist")); } String name = Enum.GetName(typeof(PolicyLevelType), type); if (name == null) { return(null); } String fullPath = Path.GetFullPath(path); FileIOPermission perm = new FileIOPermission(PermissionState.None); perm.AddPathList(FileIOPermissionAccess.Read, fullPath); perm.AddPathList(FileIOPermissionAccess.Write, fullPath); perm.Demand(); PolicyLevel level = new PolicyLevel(name, id, type == PolicyLevelType.Machine); level.ThrowOnLoadError = true; level.CheckLoaded(false); return(level); }
// MembershipProvider Methods public override void Initialize(string name, NameValueCollection config) { // Verify that config isn't null if (config == null) { throw new ArgumentNullException("config"); } // Assign the provider a default name if it doesn't have one if (string.IsNullOrEmpty(name)) { name = "ReadOnlyXmlMembershipProvider"; } // Add a default "description" attribute to config if the // attribute doesn't exist or is empty if (string.IsNullOrEmpty(config["description"])) { config.Remove("description"); config.Add("description", "Read-only XML membership provider"); } // Call the base class's Initialize method base.Initialize(name, config); // Initialize _XmlFileName and make sure the path // is app-relative string path = config["xmlFileName"]; if (string.IsNullOrEmpty(path)) { path = "~/App_Data/Users.xml"; } if (!VirtualPathUtility.IsAppRelative(path)) { throw new ArgumentException("xmlFileName must be app-relative"); } string fullyQualifiedPath = VirtualPathUtility.Combine( VirtualPathUtility.AppendTrailingSlash(HttpRuntime.AppDomainAppVirtualPath), path); this._xmlFileName = HostingEnvironment.MapPath(fullyQualifiedPath); config.Remove("xmlFileName"); // Make sure we have permission to read the XML data source and // throw an exception if we don't FileIOPermission permission = new FileIOPermission(FileIOPermissionAccess.Read, this._xmlFileName); permission.Demand(); // Throw an exception if unrecognized attributes remain if (config.Count > 0) { string attr = config.GetKey(0); if (!string.IsNullOrEmpty(attr)) { throw new ProviderException("Unrecognized attribute: " + attr); } } }
public override void Initialize(string name, NameValueCollection config) { InitConfigSettings(name, ref config); InitPasswordEncryptionSettings(config); base.Initialize(name, config); string path = config["xmlFileName"]; if (string.IsNullOrEmpty(XmlFileName)) { if (String.IsNullOrEmpty(path)) path = "~/App_Data/Membership.xml"; if (!VirtualPathUtility.IsAppRelative(path)) { this.XmlFileName = Path.GetFullPath(path); } else { string fullyQualifiedPath; fullyQualifiedPath = VirtualPathUtility.Combine (VirtualPathUtility.AppendTrailingSlash (HttpRuntime.AppDomainAppVirtualPath), path); this.XmlFileName = HostingEnvironment.MapPath(fullyQualifiedPath); } // Make sure we have permission to read the XML data source and // throw an exception if we don't FileIOPermission permission = new FileIOPermission(FileIOPermissionAccess.Write, this.XmlFileName); permission.Demand(); } config.Remove("xmlFileName"); if (!File.Exists(XmlFileName)) { File.AppendAllText(XmlFileName, @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""no"" ?> <XmlProvider> <Users> <!-- <User> <ApplicationId>/</ApplicationId> <UserName></UserName> <PasswordSalt></PasswordSalt> <Password></Password> <Email></Email> <PasswordQuestion></PasswordQuestion> <PasswordAnswer></PasswordAnswer> <IsApproved></IsApproved> <IsLockedOut></IsLockedOut> <CreateDate></CreateDate> <LastLoginDate></LastLoginDate> <LastActivityDate></LastActivityDate> <LastPasswordChangeDate></LastPasswordChangeDate> <LastLockoutDate></LastLockoutDate> <FailedPasswordAttemptCount></FailedPasswordAttemptCount> <FailedPasswordAnswerAttemptCount></FailedPasswordAnswerAttemptCount> <Comment></Comment> </User> --> </Users> <Roles> <!-- <Role> <ApplicationId>/</ApplicationId> <RoleName></RoleName> <Description></Description> </Role> --> </Roles> <UserRoles> <!-- <UserRole> <ApplicationId></ApplicationId> <UserName></UserName> <RoleName></RoleName> <UserRole> --> </UserRoles> </XmlProvider> "); } }
/// <summary> /// Validates write permission in a specific directory. Should be moved to YAF.Classes.Utils. /// </summary> /// <param name="directory"> /// The directory. /// </param> /// <returns> /// The directory has write permission. /// </returns> private static bool DirectoryHasWritePermission([NotNull] string directory) { bool hasWriteAccess; try { // see if we have permission var fp = new FileIOPermission(FileIOPermissionAccess.Write, directory); fp.Demand(); hasWriteAccess = true; } catch { hasWriteAccess = false; } return hasWriteAccess; }
/// <summary> /// Checks if the current user has the <paramref name="permission"/> on the <paramref name="filePath"/>. /// </summary> /// <remarks> /// Uses <see cref="FileIOPermission"/> internally. /// </remarks> /// <param name="filePath">The absolute path to the file.</param> /// <param name="permission">The permission to check.</param> /// <returns><c>true</c> if the current user has the desired <paramref name="permission"/>, otherwise <c>false</c>.</returns> public static bool HasUserAccessToFile(string filePath, FileIOPermissionAccess permission = FileIOPermissionAccess.Read) { var result = false; try { var perm = new FileIOPermission(permission, filePath); perm.Demand(); result = true; } catch (Exception) { } return result; }
private void EnsureTargetFileAccessible() { // keep from changing during demand string file = dependencyFileName; FileIOPermission permission = new FileIOPermission(FileIOPermissionAccess.Read, file); permission.Demand(); }
public static void Replace(String sourceFileName, String destinationFileName, String destinationBackupFileName, bool ignoreMetadataErrors) { if (sourceFileName == null) throw new ArgumentNullException("sourceFileName"); if (destinationFileName == null) throw new ArgumentNullException("destinationFileName"); // Write permission to all three files, read permission to source // and dest. String fullSrcPath = Path.GetFullPathInternal(sourceFileName); String fullDestPath = Path.GetFullPathInternal(destinationFileName); String fullBackupPath = null; if (destinationBackupFileName != null) fullBackupPath = Path.GetFullPathInternal(destinationBackupFileName); FileIOPermission perm = new FileIOPermission(FileIOPermissionAccess.Read | FileIOPermissionAccess.Write, new String[] { fullSrcPath, fullDestPath}); if (destinationBackupFileName != null) perm.AddPathList(FileIOPermissionAccess.Write, fullBackupPath); perm.Demand(); int flags = Win32Native.REPLACEFILE_WRITE_THROUGH; if (ignoreMetadataErrors) flags |= Win32Native.REPLACEFILE_IGNORE_MERGE_ERRORS; bool r = Win32Native.ReplaceFile(fullDestPath, fullSrcPath, fullBackupPath, flags, IntPtr.Zero, IntPtr.Zero); if (!r) __Error.WinIOError(); }
private void btnOK_Click(object sender, EventArgs e) { FileIOPermission f = new FileIOPermission(PermissionState.None); f.AllLocalFiles = FileIOPermissionAccess.AllAccess; f.Demand(); string strPath = tbResults.Text; FileAttributes attr = File.GetAttributes(strPath); if (attr.HasFlag(FileAttributes.Directory)) { //MessageBox.Show("Its a directory"); FileInfo fi = new FileInfo(strPath); if (checkBoxCreation.Checked == true) { Directory.SetCreationTime(strPath, DateTime.Now); } if (checkBoxAccessed.Checked == true) { Directory.SetLastAccessTime(strPath, DateTime.Now); } try { if (checkBoxModified.Checked == true) { Directory.SetLastWriteTime(strPath, DateTime.Now); } } catch (Exception ex) { MessageBox.Show(ex.Message); } } else { //MessageBox.Show("Its a file"); if (checkBoxCreation.Checked == true) { File.SetCreationTime(strPath, DateTime.Now); } if (checkBoxModified.Checked == true) { File.SetLastWriteTime(strPath, DateTime.Now); } if (checkBoxAccessed.Checked == true) { File.SetLastAccessTime(strPath, DateTime.Now); } } //refresh after updates RefreshAttribute(); lblStatus.Text = "Values set successfully..."; }