public void CopyFile(string sourceFileName, string destinationFileName, bool overwrite) { ArgumentException.ThrowIfNullOrEmpty(sourceFileName); ArgumentException.ThrowIfNullOrEmpty(destinationFileName); EnsureStoreIsValid(); string sourceFileNameFullPath = GetFullPath(sourceFileName); string destinationFileNameFullPath = GetFullPath(destinationFileName); try { File.Copy(sourceFileNameFullPath, destinationFileNameFullPath, overwrite); } catch (FileNotFoundException) { throw new FileNotFoundException(SR.Format(SR.PathNotFound_Path, sourceFileName)); } catch (PathTooLongException) { throw; } catch (Exception e) { throw GetIsolatedStorageException(SR.IsolatedStorage_Operation, e); } }
#pragma warning disable CS8765 // Nullability of parameter 'name' doesn't match overridden member public override string[]? GetValues(string name) #pragma warning restore CS8765 { ArgumentException.ThrowIfNullOrEmpty(name); return(base.GetValues(name)); }
public void CopyFile(string sourceFileName, string destinationFileName) { ArgumentException.ThrowIfNullOrEmpty(sourceFileName); ArgumentException.ThrowIfNullOrEmpty(destinationFileName); CopyFile(sourceFileName, destinationFileName, false); }
#pragma warning disable CS8765 // Nullability of parameter 'name' doesn't match overridden member public override void Remove(string name) #pragma warning restore CS8765 { ArgumentException.ThrowIfNullOrEmpty(name); base.Remove(name); }
// /// <summary> // /// Asynchronously extracts the contents of a stream that represents a tar archive into the specified directory. // /// </summary> // /// <param name="source">The stream containing the tar archive.</param> // /// <param name="destinationDirectoryName">The path of the destination directory where the filesystem entries should be extracted.</param> // /// <param name="overwriteFiles"><see langword="true"/> to overwrite files and directories in <paramref name="destinationDirectoryName"/>; <see langword="false"/> to avoid overwriting, and throw if any files or directories are found with existing names.</param> // /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> // /// <returns>A task that represents the asynchronous extraction operation.</returns> // /// <remarks><para>Files of type <see cref="TarEntryType.BlockDevice"/>, <see cref="TarEntryType.CharacterDevice"/> or <see cref="TarEntryType.Fifo"/> can only be extracted in Unix platforms.</para> // /// <para>Elevation is required to extract a <see cref="TarEntryType.BlockDevice"/> or <see cref="TarEntryType.CharacterDevice"/> to disk.</para></remarks> // /// <exception cref="UnauthorizedAccessException">Operation not permitted due to insufficient permissions.</exception> // public static Task ExtractToDirectoryAsync(Stream source, string destinationDirectoryName, bool overwriteFiles, CancellationToken cancellationToken = default) // { // throw new NotImplementedException(); // } /// <summary> /// Extracts the contents of a tar file into the specified directory. /// </summary> /// <param name="sourceFileName">The path of the tar file to extract.</param> /// <param name="destinationDirectoryName">The path of the destination directory where the filesystem entries should be extracted.</param> /// <param name="overwriteFiles"><see langword="true"/> to overwrite files and directories in <paramref name="destinationDirectoryName"/>; <see langword="false"/> to avoid overwriting, and throw if any files or directories are found with existing names.</param> /// <remarks><para>Files of type <see cref="TarEntryType.BlockDevice"/>, <see cref="TarEntryType.CharacterDevice"/> or <see cref="TarEntryType.Fifo"/> can only be extracted in Unix platforms.</para> /// <para>Elevation is required to extract a <see cref="TarEntryType.BlockDevice"/> or <see cref="TarEntryType.CharacterDevice"/> to disk.</para></remarks> /// <exception cref="UnauthorizedAccessException">Operation not permitted due to insufficient permissions.</exception> public static void ExtractToDirectory(string sourceFileName, string destinationDirectoryName, bool overwriteFiles) { ArgumentException.ThrowIfNullOrEmpty(sourceFileName); ArgumentException.ThrowIfNullOrEmpty(destinationDirectoryName); // Rely on Path.GetFullPath for validation of paths sourceFileName = Path.GetFullPath(sourceFileName); destinationDirectoryName = Path.GetFullPath(destinationDirectoryName); if (!File.Exists(sourceFileName)) { throw new FileNotFoundException(string.Format(SR.IO_FileNotFound, sourceFileName)); } if (!Directory.Exists(destinationDirectoryName)) { throw new DirectoryNotFoundException(string.Format(SR.IO_PathNotFound_Path, destinationDirectoryName)); } FileStreamOptions fileStreamOptions = new() { Access = FileAccess.Read, BufferSize = 0x1000, Mode = FileMode.Open, Share = FileShare.Read }; using FileStream archive = File.Open(sourceFileName, fileStreamOptions); ExtractToDirectoryInternal(archive, destinationDirectoryName, overwriteFiles, leaveOpen: false); }
public void Add(string host, int port, string authenticationType, NetworkCredential credential) { ArgumentException.ThrowIfNullOrEmpty(host); ArgumentNullException.ThrowIfNull(authenticationType); if (port < 0) { throw new ArgumentOutOfRangeException(nameof(port)); } if ((credential is SystemNetworkCredential) && !((string.Equals(authenticationType, NegotiationInfoClass.NTLM, StringComparison.OrdinalIgnoreCase)) || (string.Equals(authenticationType, NegotiationInfoClass.Kerberos, StringComparison.OrdinalIgnoreCase)) || (string.Equals(authenticationType, NegotiationInfoClass.Negotiate, StringComparison.OrdinalIgnoreCase))) ) { throw new ArgumentException(SR.Format(SR.net_nodefaultcreds, authenticationType), nameof(authenticationType)); } ++_version; var key = new CredentialHostKey(host, port, authenticationType); if (NetEventSource.Log.IsEnabled()) { NetEventSource.Info(this, $"Adding key:[{key}], cred:[{credential.Domain}],[{credential.UserName}]"); } _cacheForHosts ??= new Dictionary <CredentialHostKey, NetworkCredential>(); _cacheForHosts.Add(key, credential); }
public void MoveDirectory(string sourceDirectoryName, string destinationDirectoryName) { ArgumentException.ThrowIfNullOrEmpty(sourceDirectoryName); ArgumentException.ThrowIfNullOrEmpty(destinationDirectoryName); EnsureStoreIsValid(); string sourceDirectoryNameFullPath = GetFullPath(sourceDirectoryName); string destinationDirectoryNameFullPath = GetFullPath(destinationDirectoryName); try { Directory.Move(sourceDirectoryNameFullPath, destinationDirectoryNameFullPath); } catch (DirectoryNotFoundException) { throw new DirectoryNotFoundException(SR.Format(SR.PathNotFound_Path, sourceDirectoryName)); } catch (PathTooLongException) { throw; } catch (Exception e) { throw GetIsolatedStorageException(SR.IsolatedStorage_Operation, e); } }
// Moves a given file to a new location and potentially a new file name. // Optionally overwrites existing file. // This method does work across volumes. public void MoveTo(string destFileName, bool overwrite) { ArgumentException.ThrowIfNullOrEmpty(destFileName); string fullDestFileName = Path.GetFullPath(destFileName); // These checks are in place to ensure Unix error throwing happens the same way // as it does on Windows.These checks can be removed if a solution to // https://github.com/dotnet/runtime/issues/14885 is found that doesn't require // validity checks before making an API call. if (!new DirectoryInfo(Path.GetDirectoryName(FullName) !).Exists) { throw new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, FullName)); } if (!Exists) { throw new FileNotFoundException(SR.Format(SR.IO_FileNotFound_FileName, FullName), FullName); } FileSystem.MoveFile(FullPath, fullDestFileName, overwrite); FullPath = fullDestFileName; OriginalPath = destFileName; _name = Path.GetFileName(fullDestFileName); // Flush any cached information about the file. Invalidate(); }
public override byte[] DeriveKeyFromHmac( ECDiffieHellmanPublicKey otherPartyPublicKey, HashAlgorithmName hashAlgorithm, byte[]?hmacKey, byte[]?secretPrepend, byte[]?secretAppend) { ArgumentNullException.ThrowIfNull(otherPartyPublicKey); ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm)); using (SafeNCryptSecretHandle secretAgreement = DeriveSecretAgreementHandle(otherPartyPublicKey)) { Interop.NCrypt.SecretAgreementFlags flags = hmacKey == null ? Interop.NCrypt.SecretAgreementFlags.UseSecretAsHmacKey : Interop.NCrypt.SecretAgreementFlags.None; return(Interop.NCrypt.DeriveKeyMaterialHmac( secretAgreement, hashAlgorithm.Name, hmacKey, secretPrepend, secretAppend, flags)); } }
/// <summary> /// Verifies that a digital signature is valid for the provided data. /// </summary> /// <param name="data">An array that contains the signed data.</param> /// <param name="offset">The starting index of the signed portion of <paramref name="data"/>.</param> /// <param name="count">The number of bytes in <paramref name="data"/> that were signed.</param> /// <param name="signature">The signature to verify.</param> /// <param name="hashAlgorithm">The hash algorithm used to hash the data for the verification process.</param> /// <param name="signatureFormat">The encoding format for <paramref name="signature"/>.</param> /// <returns> /// <see langword="true"/> if the digital signature is valid for the provided data; otherwise, <see langword="false"/>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="data"/> or <paramref name="signature"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="signatureFormat"/> is not a known format. /// /// -or- /// /// <paramref name="offset" /> is less than zero. /// /// -or- /// /// <paramref name="count" /> is less than zero. /// /// -or- /// /// <paramref name="offset" /> + <paramref name="count"/> - 1 results in an index that is /// beyond the upper bound of <paramref name="data"/>. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="hashAlgorithm"/> has a <see langword="null"/> or empty <see cref="HashAlgorithmName.Name"/>. /// </exception> /// <exception cref="CryptographicException"> /// An error occurred in the hashing or verification operation. /// </exception> public bool VerifyData( byte[] data, int offset, int count, byte[] signature, HashAlgorithmName hashAlgorithm, DSASignatureFormat signatureFormat) { ArgumentNullException.ThrowIfNull(data); if (offset < 0 || offset > data.Length) { throw new ArgumentOutOfRangeException(nameof(offset)); } if (count < 0 || count > data.Length - offset) { throw new ArgumentOutOfRangeException(nameof(count)); } ArgumentNullException.ThrowIfNull(signature); ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm)); if (!signatureFormat.IsKnownValue()) { throw DSASignatureFormatHelpers.CreateUnknownValueException(signatureFormat); } return(VerifyDataCore( new ReadOnlySpan <byte>(data, offset, count), signature, hashAlgorithm, signatureFormat)); }
internal FieldBuilder(TypeBuilder typeBuilder, string fieldName, Type type, Type[]?requiredCustomModifiers, Type[]?optionalCustomModifiers, FieldAttributes attributes) { ArgumentException.ThrowIfNullOrEmpty(fieldName); if (fieldName[0] == '\0') { throw new ArgumentException(SR.Argument_IllegalName, nameof(fieldName)); } ArgumentNullException.ThrowIfNull(type); if (type == typeof(void)) { throw new ArgumentException(SR.Argument_BadFieldType); } m_fieldName = fieldName; m_typeBuilder = typeBuilder; m_fieldType = type; m_Attributes = attributes & ~FieldAttributes.ReservedMask; SignatureHelper sigHelp = SignatureHelper.GetFieldSigHelper(m_typeBuilder.Module); sigHelp.AddArgument(type, requiredCustomModifiers, optionalCustomModifiers); byte[] signature = sigHelp.InternalGetSignature(out int sigLength); ModuleBuilder module = m_typeBuilder.GetModuleBuilder(); m_fieldTok = TypeBuilder.DefineField(new QCallModule(ref module), typeBuilder.TypeToken, fieldName, signature, sigLength, m_Attributes); }
// Constructor called when creating a new 'TarEntry*' instance that can be passed to a TarWriter. internal TarEntry(TarEntryType entryType, string entryName, TarFormat format) { ArgumentException.ThrowIfNullOrEmpty(entryName); // Throws if format is unknown or out of range TarHelpers.VerifyEntryTypeIsSupported(entryType, format, forWriting: false); _readerOfOrigin = null; _header = default; _header._extendedAttributes = new Dictionary <string, string>(); _header._name = entryName; _header._linkName = string.Empty; _header._typeFlag = entryType; _header._mode = (int)TarHelpers.DefaultMode; _header._gName = string.Empty; _header._uName = string.Empty; DateTimeOffset now = DateTimeOffset.Now; _header._mTime = now; _header._aTime = now; _header._cTime = now; }
/// <summary> /// Adds a country or region attribute. /// </summary> /// <param name="twoLetterCode">The two letter code of the country or region.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="twoLetterCode" /> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="twoLetterCode" /> is not exactly two characters, or contains /// characters that are not A through Z. /// </exception> /// <remarks> /// <para>This encodes an attribute with the OID 2.5.4.6 as a PrintableString.</para> /// <para> /// <paramref name="twoLetterCode" /> should be a two letter ISO 3166 alpha-2 code, and /// will be normalized to upper case characters. /// </para> /// </remarks> public void AddCountryOrRegion(string twoLetterCode) { // ITU T-REC X.520 Annex A: // id-at-countryName // WITH SYNTAX CountryName // CountryName ::= PrintableString(SIZE (2)) // An attribute value for country name is a string chosen from ISO 3166-1 alpha-2 or ISO 3166-3 alpha-2. // We can't reasonably enforce the ISO 3166 list, but we can ensure it's a two letter ISO code // and consists of alpha characters. ArgumentException.ThrowIfNullOrEmpty(twoLetterCode); ReadOnlySpan <char> twoLetterCodeSpan = twoLetterCode; // This could be a surrogate pair, but since we are encoding as a PrintableString, // those will be prohibited, so "Length" should be fine for checking the length of // the string. // Input must be A-Z per ISO 3166. if (twoLetterCode.Length != 2 || !IsAlpha(twoLetterCode[0]) || !IsAlpha(twoLetterCode[1])) { throw new ArgumentException(SR.Argument_X500_InvalidCountryOrRegion, nameof(twoLetterCode)); } Span <char> fixupTwoLetterCode = stackalloc char[2]; int written = twoLetterCodeSpan.ToUpperInvariant(fixupTwoLetterCode); Debug.Assert(written == 2); EncodeComponent( Oids.CountryOrRegionName, fixupTwoLetterCode, UniversalTagNumber.PrintableString, nameof(twoLetterCode));
private static OpenExistingResult OpenExistingWorker(string name, out Semaphore?result) { #if TARGET_WINDOWS ArgumentException.ThrowIfNullOrEmpty(name); // Pass false to OpenSemaphore to prevent inheritedHandles SafeWaitHandle myHandle = Interop.Kernel32.OpenSemaphore(AccessRights, false, name); if (myHandle.IsInvalid) { result = null; int errorCode = Marshal.GetLastPInvokeError(); if (errorCode == Interop.Errors.ERROR_FILE_NOT_FOUND || errorCode == Interop.Errors.ERROR_INVALID_NAME) { return(OpenExistingResult.NameNotFound); } if (errorCode == Interop.Errors.ERROR_PATH_NOT_FOUND) { return(OpenExistingResult.PathNotFound); } if (errorCode == Interop.Errors.ERROR_INVALID_HANDLE) { return(OpenExistingResult.NameInvalid); } // this is for passed through NativeMethods Errors throw Win32Marshal.GetExceptionForLastWin32Error(); } result = new Semaphore(myHandle); return(OpenExistingResult.Success); #else throw new PlatformNotSupportedException(SR.PlatformNotSupported_NamedSynchronizationPrimitives); #endif }
private ModuleBuilder DefineDynamicModuleInternalNoLock(string name) { ArgumentException.ThrowIfNullOrEmpty(name); if (name[0] == '\0') { throw new ArgumentException(SR.Argument_InvalidName, nameof(name)); } // Create the dynamic module- only one ModuleBuilder per AssemblyBuilder can be created. if (_isManifestModuleUsedAsDefinedModule) { throw new InvalidOperationException(SR.InvalidOperation_NoMultiModuleAssembly); } Debug.Assert(_assemblyData != null, "_assemblyData is null in DefineDynamicModuleInternal"); // Init(...) has already been called on _manifestModuleBuilder in InitManifestModule() ModuleBuilder dynModule = _manifestModuleBuilder; _assemblyData._moduleBuilderList.Add(dynModule); if (dynModule == _manifestModuleBuilder) { // We are reusing manifest module as user-defined dynamic module _isManifestModuleUsedAsDefinedModule = true; } return(dynModule); }
/// <summary> /// Copies an existing file to a new file. /// If <paramref name="overwrite"/> is false, an exception will be /// raised if the destination exists. Otherwise it will be overwritten. /// </summary> public static void Copy(string sourceFileName, string destFileName, bool overwrite) { ArgumentException.ThrowIfNullOrEmpty(sourceFileName); ArgumentException.ThrowIfNullOrEmpty(destFileName); FileSystem.CopyFile(Path.GetFullPath(sourceFileName), Path.GetFullPath(destFileName), overwrite); }
public NetworkCredential?GetCredential(string host, int port, string authenticationType) { ArgumentException.ThrowIfNullOrEmpty(host); ArgumentNullException.ThrowIfNull(authenticationType); if (port < 0) { throw new ArgumentOutOfRangeException(nameof(port)); } if (_cacheForHosts == null) { if (NetEventSource.Log.IsEnabled()) { NetEventSource.Info(this, "CredentialCache::GetCredential short-circuiting because the dictionary is null."); } return(null); } var key = new CredentialHostKey(host, port, authenticationType); NetworkCredential?match; _cacheForHosts.TryGetValue(key, out match); if (NetEventSource.Log.IsEnabled()) { NetEventSource.Info(this, $"Returning {((match == null) ? "null" : "(" + match.UserName + ":" + match.Domain + ")")}"); } return(match); }
/// <summary> /// Asynchronously extracts the contents of a tar file into the specified directory. /// </summary> /// <param name="sourceFileName">The path of the tar file to extract.</param> /// <param name="destinationDirectoryName">The path of the destination directory where the filesystem entries should be extracted.</param> /// <param name="overwriteFiles"><see langword="true"/> to overwrite files and directories in <paramref name="destinationDirectoryName"/>; <see langword="false"/> to avoid overwriting, and throw if any files or directories are found with existing names.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> /// <returns>A task that represents the asynchronous extraction operation.</returns> /// <remarks><para>Files of type <see cref="TarEntryType.BlockDevice"/>, <see cref="TarEntryType.CharacterDevice"/> or <see cref="TarEntryType.Fifo"/> can only be extracted in Unix platforms.</para> /// <para>Elevation is required to extract a <see cref="TarEntryType.BlockDevice"/> or <see cref="TarEntryType.CharacterDevice"/> to disk.</para></remarks> /// <exception cref="UnauthorizedAccessException">Operation not permitted due to insufficient permissions.</exception> public static Task ExtractToDirectoryAsync(string sourceFileName, string destinationDirectoryName, bool overwriteFiles, CancellationToken cancellationToken = default) { if (cancellationToken.IsCancellationRequested) { return(Task.FromCanceled(cancellationToken)); } ArgumentException.ThrowIfNullOrEmpty(sourceFileName); ArgumentException.ThrowIfNullOrEmpty(destinationDirectoryName); // Rely on Path.GetFullPath for validation of paths sourceFileName = Path.GetFullPath(sourceFileName); destinationDirectoryName = Path.GetFullPath(destinationDirectoryName); if (!File.Exists(sourceFileName)) { return(Task.FromException(new FileNotFoundException(string.Format(SR.IO_FileNotFound, sourceFileName)))); } if (!Directory.Exists(destinationDirectoryName)) { return(Task.FromException(new DirectoryNotFoundException(string.Format(SR.IO_PathNotFound_Path, destinationDirectoryName)))); } return(ExtractToDirectoryInternalAsync(sourceFileName, destinationDirectoryName, overwriteFiles, cancellationToken)); }
public NamedPipeClientStream(string serverName, string pipeName, PipeDirection direction, PipeOptions options, TokenImpersonationLevel impersonationLevel, HandleInheritability inheritability) : base(direction, 0) { ArgumentException.ThrowIfNullOrEmpty(pipeName); ArgumentNullException.ThrowIfNull(serverName); if (serverName.Length == 0) { throw new ArgumentException(SR.Argument_EmptyServerName); } if ((options & ~(PipeOptions.WriteThrough | PipeOptions.Asynchronous | PipeOptions.CurrentUserOnly)) != 0) { throw new ArgumentOutOfRangeException(nameof(options), SR.ArgumentOutOfRange_OptionsInvalid); } if (impersonationLevel < TokenImpersonationLevel.None || impersonationLevel > TokenImpersonationLevel.Delegation) { throw new ArgumentOutOfRangeException(nameof(impersonationLevel), SR.ArgumentOutOfRange_ImpersonationInvalid); } if (inheritability < HandleInheritability.None || inheritability > HandleInheritability.Inheritable) { throw new ArgumentOutOfRangeException(nameof(inheritability), SR.ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable); } if ((options & PipeOptions.CurrentUserOnly) != 0) { IsCurrentUserOnly = true; } _normalizedPipePath = GetPipePath(serverName, pipeName); _direction = direction; _inheritability = inheritability; _impersonationLevel = impersonationLevel; _pipeOptions = options; }
private static OpenExistingResult OpenExistingWorker(string name, out EventWaitHandle?result) { #if TARGET_WINDOWS ArgumentException.ThrowIfNullOrEmpty(name); result = null; SafeWaitHandle myHandle = Interop.Kernel32.OpenEvent(AccessRights, false, name); if (myHandle.IsInvalid) { int errorCode = Marshal.GetLastPInvokeError(); if (errorCode == Interop.Errors.ERROR_FILE_NOT_FOUND || errorCode == Interop.Errors.ERROR_INVALID_NAME) { return(OpenExistingResult.NameNotFound); } if (errorCode == Interop.Errors.ERROR_PATH_NOT_FOUND) { return(OpenExistingResult.PathNotFound); } if (errorCode == Interop.Errors.ERROR_INVALID_HANDLE) { return(OpenExistingResult.NameInvalid); } throw Win32Marshal.GetExceptionForWin32Error(errorCode, name); } result = new EventWaitHandle(myHandle); return(OpenExistingResult.Success); #else throw new PlatformNotSupportedException(SR.PlatformNotSupported_NamedSynchronizationPrimitives); #endif }
/// <summary> /// Initializes a new instance of the <see cref="System.IO.FileStream" /> class with the specified path, creation mode, read/write and sharing permission, the access other FileStreams can have to the same file, the buffer size, additional file options and the allocation size. /// </summary> /// <param name="path">A relative or absolute path for the file that the current <see cref="System.IO.FileStream" /> instance will encapsulate.</param> /// <param name="options">An object that describes optional <see cref="System.IO.FileStream" /> parameters to use.</param> /// <exception cref="T:System.ArgumentNullException"><paramref name="path" /> or <paramref name="options" /> is <see langword="null" />.</exception> /// <exception cref="T:System.ArgumentException"><paramref name="path" /> is an empty string (""), contains only white space, or contains one or more invalid characters. /// -or- /// <paramref name="path" /> refers to a non-file device, such as <c>CON:</c>, <c>COM1:</c>, <c>LPT1:</c>, etc. in an NTFS environment.</exception> /// <exception cref="T:System.NotSupportedException"><paramref name="path" /> refers to a non-file device, such as <c>CON:</c>, <c>COM1:</c>, <c>LPT1:</c>, etc. in a non-NTFS environment.</exception> /// <exception cref="T:System.IO.FileNotFoundException">The file cannot be found, such as when <see cref="System.IO.FileStreamOptions.Mode" /> is <see langword="FileMode.Truncate" /> or <see langword="FileMode.Open" />, and the file specified by <paramref name="path" /> does not exist. The file must already exist in these modes.</exception> /// <exception cref="T:System.IO.IOException">An I/O error, such as specifying <see langword="FileMode.CreateNew" /> when the file specified by <paramref name="path" /> already exists, occurred. /// -or- /// The stream has been closed. /// -or- /// The disk was full (when <see cref="System.IO.FileStreamOptions.PreallocationSize" /> was provided and <paramref name="path" /> was pointing to a regular file). /// -or- /// The file was too large (when <see cref="System.IO.FileStreamOptions.PreallocationSize" /> was provided and <paramref name="path" /> was pointing to a regular file).</exception> /// <exception cref="T:System.Security.SecurityException">The caller does not have the required permission.</exception> /// <exception cref="T:System.IO.DirectoryNotFoundException">The specified path is invalid, such as being on an unmapped drive.</exception> /// <exception cref="T:System.UnauthorizedAccessException">The <see cref="System.IO.FileStreamOptions.Access" /> requested is not permitted by the operating system for the specified <paramref name="path" />, such as when <see cref="System.IO.FileStreamOptions.Access" /> is <see cref="System.IO.FileAccess.Write" /> or <see cref="System.IO.FileAccess.ReadWrite" /> and the file or directory is set for read-only access. /// -or- /// <see cref="F:System.IO.FileOptions.Encrypted" /> is specified for <see cref="System.IO.FileStreamOptions.Options" /> , but file encryption is not supported on the current platform.</exception> /// <exception cref="T:System.IO.PathTooLongException">The specified path, file name, or both exceed the system-defined maximum length. </exception> public FileStream(string path, FileStreamOptions options) { ArgumentException.ThrowIfNullOrEmpty(path); ArgumentNullException.ThrowIfNull(options); if ((options.Access & FileAccess.Read) != 0 && options.Mode == FileMode.Append) { throw new ArgumentException(SR.Argument_InvalidAppendMode, nameof(options)); } else if ((options.Access & FileAccess.Write) == 0) { if (options.Mode == FileMode.Truncate || options.Mode == FileMode.CreateNew || options.Mode == FileMode.Create || options.Mode == FileMode.Append) { throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, options.Mode, options.Access), nameof(options)); } } if (options.PreallocationSize > 0) { FileStreamHelpers.ValidateArgumentsForPreallocation(options.Mode, options.Access); } if (options.UnixCreateMode.HasValue) { // Only allow UnixCreateMode for file modes that can create a new file. if (options.Mode == FileMode.Truncate || options.Mode == FileMode.Open) { throw new ArgumentException(SR.Argument_InvalidUnixCreateMode, nameof(options)); } } FileStreamHelpers.SerializationGuard(options.Access); _strategy = FileStreamHelpers.ChooseStrategy( this, path, options.Mode, options.Access, options.Share, options.BufferSize, options.Options, options.PreallocationSize, options.UnixCreateMode); }
public AssemblyName(string assemblyName) : this() { ArgumentException.ThrowIfNullOrEmpty(assemblyName); if (assemblyName[0] == '\0') { throw new ArgumentException(SR.Format_StringZeroLength); } AssemblyNameParser.AssemblyNameParts parts = AssemblyNameParser.Parse(assemblyName); _name = parts._name; _version = parts._version; _flags = parts._flags; if ((parts._flags & AssemblyNameFlags.PublicKey) != 0) { _publicKey = parts._publicKeyOrToken; } else { _publicKeyToken = parts._publicKeyOrToken; } if (parts._cultureName != null) { _cultureInfo = new CultureInfo(parts._cultureName); } }
public virtual byte[] SignData(Stream data, HashAlgorithmName hashAlgorithm) { ArgumentNullException.ThrowIfNull(data); ArgumentException.ThrowIfNullOrEmpty(hashAlgorithm.Name, nameof(hashAlgorithm)); byte[] hash = HashData(data, hashAlgorithm); return(SignHash(hash)); }
/// <summary> /// ctor. /// </summary> /// <param name="contentType">Unparsed value of the Content-Type header.</param> public ContentType(string contentType) { ArgumentException.ThrowIfNullOrEmpty(contentType); _isChanged = true; _type = contentType; ParseValue(); }
public static void WriteAllBytes(string path, byte[] bytes) { ArgumentException.ThrowIfNullOrEmpty(path); ArgumentNullException.ThrowIfNull(bytes); using SafeFileHandle sfh = OpenHandle(path, FileMode.Create, FileAccess.Write, FileShare.Read); RandomAccess.WriteAtOffset(sfh, bytes, 0); }
internal void SetContentFromFile(string fileName, string?mediaType) { ArgumentException.ThrowIfNullOrEmpty(fileName); Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); _part.SetContent(stream, null, mediaType); }
public static Task WriteAllBytesAsync(string path, byte[] bytes, CancellationToken cancellationToken = default(CancellationToken)) { ArgumentException.ThrowIfNullOrEmpty(path); ArgumentNullException.ThrowIfNull(bytes); return(cancellationToken.IsCancellationRequested ? Task.FromCanceled(cancellationToken) : Core(path, bytes, cancellationToken));
internal static void VerifyValidPath(string path, string argName) { ArgumentException.ThrowIfNullOrEmpty(path, argName); if (path.Contains('\0')) { throw new ArgumentException(SR.Argument_InvalidPathChars, argName); } }
/// <summary> /// Adds a Relative Distinguished Name attribute identified by an OID. /// </summary> /// <param name="oidValue">The OID of the attribute.</param> /// <param name="value">The value of the attribute.</param> /// <param name="stringEncodingType"> /// The encoding type to use when encoding the <paramref name="value" /> /// in to the attribute. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="oidValue" /> or <paramref name="value" /> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentException"> /// <para> /// <paramref name="oidValue" /> is an empty string or not a valid OID. /// </para> /// <para>-or-</para> /// <para> /// <paramref name="stringEncodingType" /> is not a type for character strings. /// </para> /// <para>-or-</para> /// <para> /// <paramref name="value" /> is not encodable as defined by <paramref name="stringEncodingType" />. /// </para> /// </exception> public void Add(string oidValue, string value, UniversalTagNumber?stringEncodingType = null) { ArgumentNullException.ThrowIfNull(value); ArgumentException.ThrowIfNullOrEmpty(oidValue); UniversalTagNumber tag = GetAndValidateTagNumber(stringEncodingType); EncodeComponent(oidValue, value, tag); }
/// <summary> /// Adds a locality name attribute. /// </summary> /// <param name="localityName">The locality name to add.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="localityName" /> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="localityName" /> is empty. /// </exception> /// <remarks> /// This encodes an attribute with the OID 2.5.4.7 as a UTF8String. /// </remarks> public void AddLocalityName(string localityName) { // ITU T-REC X.520 Annex A: // id-at-localityName // WITH SYNTAX UnboundedDirectoryString ArgumentException.ThrowIfNullOrEmpty(localityName); EncodeComponent(Oids.LocalityName, localityName, UniversalTagNumber.UTF8String); }