C# IOConnectionInfo.IsLocalFile方法代码示例

		private void Initialize(IOConnectionInfo iocBaseFile, bool bTransacted)
		{
			if(iocBaseFile == null) throw new ArgumentNullException("iocBaseFile");

			m_bTransacted = bTransacted;
			m_iocBase = iocBaseFile.CloneDeep();

			string strPath = m_iocBase.Path;

			if(m_iocBase.IsLocalFile())
			{
				try
				{
					if(File.Exists(strPath))
					{
						// Symbolic links are realized via reparse points;
						// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365503.aspx
						// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365680.aspx
						// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365006.aspx
						// Performing a file transaction on a symbolic link
						// would delete/replace the symbolic link instead of
						// writing to its target
						FileAttributes fa = File.GetAttributes(strPath);
						if((long)(fa & FileAttributes.ReparsePoint) != 0)
							m_bTransacted = false;
					}
				}
				catch(Exception) { Debug.Assert(false); }
			}

#if !KeePassUAP
			// Prevent transactions for FTP URLs under .NET 4.0 in order to
			// avoid/workaround .NET bug 621450:
			// https://connect.microsoft.com/VisualStudio/feedback/details/621450/problem-renaming-file-on-ftp-server-using-ftpwebrequest-in-net-framework-4-0-vs2010-only
			if(strPath.StartsWith("ftp:", StrUtil.CaseIgnoreCmp) &&
				(Environment.Version.Major >= 4) && !NativeLib.IsUnix())
				m_bTransacted = false;
#endif

			foreach(KeyValuePair<string, bool> kvp in g_dEnabled)
			{
				if(strPath.StartsWith(kvp.Key, StrUtil.CaseIgnoreCmp))
				{
					m_bTransacted = kvp.Value;
					break;
				}
			}

			if(m_bTransacted)
			{
				m_iocTemp = m_iocBase.CloneDeep();
				m_iocTemp.Path += StrTempSuffix;
			}
			else m_iocTemp = m_iocBase;
		}

 public bool CheckForFileChangeFast(IOConnectionInfo ioc, string previousFileVersion)
 {
     if (!ioc.IsLocalFile())
         return false;
     if (previousFileVersion == null)
         return false;
     DateTime previousDate;
     if (!DateTime.TryParse(previousFileVersion, CultureInfo.InvariantCulture, DateTimeStyles.None, out previousDate))
         return false;
     DateTime currentModificationDate = File.GetLastWriteTimeUtc(ioc.Path);
     TimeSpan diff = currentModificationDate - previousDate;
     return diff > TimeSpan.FromSeconds(1);
     //don't use > operator because milliseconds are truncated
     //return File.GetLastWriteTimeUtc(ioc.Path) - previousDate >= TimeSpan.FromSeconds(1);
 }

        public static Stream OpenWrite(IOConnectionInfo ioc)
        {
            if(ioc.IsLocalFile()) return OpenWriteLocal(ioc);

            return CreateWebClient(ioc).OpenWrite(new Uri(ioc.Path));
        }

        public static void Launch(Activity act, IOConnectionInfo ioc, AppTask appTask)
        {
            if (ioc.IsLocalFile())
            {
                Launch(act, ioc.Path, appTask);
                return;
            }

            Intent i = new Intent(act, typeof(PasswordActivity));

            PutIoConnectionToIntent(ioc, i);
            i.SetFlags(ActivityFlags.ForwardResult);

            appTask.ToIntent(i);

            act.StartActivity(i);
        }

        private static string GetKeyAssocID(IOConnectionInfo iocDb)
        {
            if(iocDb == null) throw new ArgumentNullException("iocDb");

            string strDb = iocDb.Path;
            if((strDb.Length > 0) && iocDb.IsLocalFile() &&
                !UrlUtil.IsAbsolutePath(strDb))
                strDb = UrlUtil.MakeAbsolutePath(WinUtil.GetExecutable(), strDb);

            return strDb;
        }

		internal static IOConnectionInfo CompleteConnectionInfo(IOConnectionInfo ioc,
			bool bSave, bool bCanRememberCred, bool bTestConnection, bool bForceShow)
		{
			if(ioc == null) { Debug.Assert(false); return null; }
			if(!bForceShow && ((ioc.CredSaveMode == IOCredSaveMode.SaveCred) ||
				ioc.IsLocalFile() || ioc.IsComplete))
				return ioc.CloneDeep();

			IOConnectionForm dlg = new IOConnectionForm();
			dlg.InitEx(bSave, ioc.CloneDeep(), bCanRememberCred, bTestConnection);
			if(UIUtil.ShowDialogNotValue(dlg, DialogResult.OK)) return null;

			IOConnectionInfo iocResult = dlg.IOConnectionInfo;
			UIUtil.DestroyForm(dlg);
			return iocResult;
		}

        public static Stream OpenWrite(IOConnectionInfo ioc)
        {
            if(ioc == null) { Debug.Assert(false); return null; }

            RaiseIOAccessPreEvent(ioc, IOAccessType.Write);

            if(ioc.IsLocalFile()) return OpenWriteLocal(ioc);

            Uri uri = new Uri(ioc.Path);
            Stream s;

            // Mono does not set HttpWebRequest.Method to POST for writes,
            // so one needs to set the method to PUT explicitly
            if(NativeLib.IsUnix() && (uri.Scheme.Equals(Uri.UriSchemeHttp,
                StrUtil.CaseIgnoreCmp) || uri.Scheme.Equals(Uri.UriSchemeHttps,
                StrUtil.CaseIgnoreCmp)))
                s = CreateWebClient(ioc).OpenWrite(uri, WebRequestMethods.Http.Put);
            else s = CreateWebClient(ioc).OpenWrite(uri);

            return IocStream.WrapIfRequired(s);
        }

        public static bool FileExists(IOConnectionInfo ioc, bool bThrowErrors)
        {
            if(ioc == null) { Debug.Assert(false); return false; }

            RaiseIOAccessPreEvent(ioc, IOAccessType.Exists);

            if(ioc.IsLocalFile()) return File.Exists(ioc.Path);

            #if (!KeePassLibSD && !KeePassRT)
            if(ioc.Path.StartsWith("ftp://", StrUtil.CaseIgnoreCmp))
            {
                bool b = SendCommand(ioc, WebRequestMethods.Ftp.GetDateTimestamp);
                if(!b && bThrowErrors) throw new InvalidOperationException();
                return b;
            }
            #endif

            try
            {
                Stream s = OpenRead(ioc);
                if(s == null) throw new FileNotFoundException();

                try { s.ReadByte(); }
                catch(Exception) { }

                // We didn't download the file completely; close may throw
                // an exception -- that's okay
                try { s.Close(); }
                catch(Exception) { }
            }
            catch(Exception)
            {
                if(bThrowErrors) throw;
                return false;
            }

            return true;
        }

        public static Stream OpenRead(IOConnectionInfo ioc)
        {
            RaiseIOAccessPreEvent(ioc, IOAccessType.Read);

            if(StrUtil.IsDataUri(ioc.Path))
            {
                byte[] pbData = StrUtil.DataUriToData(ioc.Path);
                if(pbData != null) return new MemoryStream(pbData, false);
            }

            if(ioc.IsLocalFile()) return OpenReadLocal(ioc);

            return IocStream.WrapIfRequired(CreateWebClient(ioc).OpenRead(
                new Uri(ioc.Path)));
        }

		public static Stream OpenWrite(IOConnectionInfo ioc)
		{
			if(ioc == null) { Debug.Assert(false); return null; }

			if(ioc.IsLocalFile()) return OpenWriteLocal(ioc);

			return CreateWebClient(ioc).OpenWrite(new Uri(ioc.Path));
		}

        public void SetKeySource(IOConnectionInfo ioDatabase, string strKeySource,
            bool bIsKeyFile)
        {
            if(ioDatabase == null) throw new ArgumentNullException("ioDatabase");

            string strDb = ioDatabase.Path;
            if((strDb.Length > 0) && ioDatabase.IsLocalFile() &&
                !UrlUtil.IsAbsolutePath(strDb))
                strDb = UrlUtil.MakeAbsolutePath(WinUtil.GetExecutable(), strDb);

            string strKey = strKeySource;
            if(bIsKeyFile && !string.IsNullOrEmpty(strKey))
            {
                if(StrUtil.IsDataUri(strKey))
                    strKey = null; // Don't remember data URIs
                else if(!UrlUtil.IsAbsolutePath(strKey))
                    strKey = UrlUtil.MakeAbsolutePath(WinUtil.GetExecutable(), strKey);
            }

            if(!m_bRememberKeySources) strKey = null;

            foreach(AceKeyAssoc kfp in m_vKeySources)
            {
                if(strDb.Equals(kfp.DatabasePath, StrUtil.CaseIgnoreCmp))
                {
                    if(string.IsNullOrEmpty(strKey)) m_vKeySources.Remove(kfp);
                    else
                    {
                        kfp.KeyFilePath = (bIsKeyFile ? strKey : string.Empty);
                        kfp.KeyProvider = (bIsKeyFile ? string.Empty : strKey);
                    }
                    return;
                }
            }

            if(string.IsNullOrEmpty(strKey)) return;

            AceKeyAssoc kfpNew = new AceKeyAssoc();
            kfpNew.DatabasePath = strDb;
            if(bIsKeyFile) kfpNew.KeyFilePath = strKey;
            else kfpNew.KeyProvider = strKey;
            m_vKeySources.Add(kfpNew);
        }

        public string GetKeySource(IOConnectionInfo ioDatabase, bool bGetKeyFile)
        {
            if(ioDatabase == null) throw new ArgumentNullException("ioDatabase");

            string strDb = ioDatabase.Path;
            if((strDb.Length > 0) && ioDatabase.IsLocalFile() &&
                !UrlUtil.IsAbsolutePath(strDb))
                strDb = UrlUtil.MakeAbsolutePath(WinUtil.GetExecutable(), strDb);

            foreach(AceKeyAssoc kfp in m_vKeySources)
            {
                if(strDb.Equals(kfp.DatabasePath, StrUtil.CaseIgnoreCmp))
                    return (bGetKeyFile ? kfp.KeyFilePath : kfp.KeyProvider);
            }

            return null;
        }

 public bool RequiresCredentials(IOConnectionInfo ioc)
 {
     return (!ioc.IsLocalFile()) && (ioc.CredSaveMode != IOCredSaveMode.SaveCred);
 }

        public bool IsReadOnly(IOConnectionInfo ioc)
        {
            if (ioc.IsLocalFile())
            {
                if (IsLocalFileFlaggedReadOnly(ioc))
                    return true;
                if (IsReadOnlyBecauseKitkatRestrictions(ioc))
                    return true;

                return false;
            }
            //for remote files assume they can be written: (think positive! :-) )
            return false;
        }

 public string GetCurrentFileVersionFast(IOConnectionInfo ioc)
 {
     if (ioc.IsLocalFile())
     {
         return File.GetLastWriteTimeUtc(ioc.Path).ToString(CultureInfo.InvariantCulture);
     }
     else
     {
         return DateTime.MinValue.ToString(CultureInfo.InvariantCulture);
     }
 }