publicconststringArg_AccessViolationException="Attempted to read or write protected memory. This is often an indication that other memory is corrupt.";
publicconststringArg_ApplicationException="Error in the application.";
publicconststringArg_ArgumentException="Value does not fall within the expected range.";
publicconststringArg_ArgumentOutOfRangeException="Specified argument was out of the range of valid values.";
publicconststringArg_ArithmeticException="Overflow or underflow in the arithmetic operation.";
publicconststringArg_ArrayPlusOffTooSmall="Destination array is not long enough to copy all the items in the collection. Check array index and length.";
publicconststringArg_ArrayTypeMismatchException="Attempted to access an element as a type incompatible with the array.";
publicconststringArg_ArrayZeroError="Array must not be of length zero.";
publicconststringArg_BadImageFormatException="Format of the executable (.exe) or library (.dll) is invalid.";
publicconststringArg_BogusIComparer="Unable to sort because the IComparer.Compare() method returns inconsistent results. Either a value does not compare equal to itself, or one value repeatedly compared to another value yields different results. IComparer: '{0}'.";
publicconststringArg_CannotBeNaN="TimeSpan does not accept floating point Not-a-Number values.";
publicconststringArg_CannotHaveNegativeValue="String cannot contain a minus sign if the base is not 10.";
publicconststringArg_CopyNonBlittableArray="Arrays must contain only blittable data in order to be copied to unmanaged memory.";
publicconststringArg_CopyOutOfRange="Requested range extends past the end of the array.";
publicconststringArg_CryptographyException="Error occurred during a cryptographic operation.";
publicconststringArg_DataMisalignedException="A datatype misalignment was detected in a load or store instruction.";
publicconststringArg_DateTimeRange="Combination of arguments to the DateTime constructor is out of the legal range.";
publicconststringArg_DirectoryNotFoundException="Attempted to access a path that is not on the disk.";
publicconststringArg_DecBitCtor="Decimal byte array constructor requires an array of length four containing valid decimal bytes.";
publicconststringArg_DivideByZero="Attempted to divide by zero.";
publicconststringArg_DriveNotFoundException="Attempted to access a drive that is not available.";
publicconststringArg_DlgtNullInst="Delegate to an instance method cannot have null 'this'.";
publicconststringArg_DuplicateWaitObjectException="Duplicate objects in argument.";
publicconststringArg_EnumAndObjectMustBeSameType="Object must be the same type as the enum. The type passed in was '{0}'; the enum type was '{1}'.";
publicconststringArg_EntryPointNotFoundException="Entry point was not found.";
publicconststringArg_ExecutionEngineException="Internal error in the runtime.";
publicconststringArg_ExternalException="External component has thrown an exception.";
publicconststringArg_FieldAccessException="Attempted to access a field that is not accessible by the caller.";
publicconststringArg_FormatException="One of the identified items was in an invalid format.";
publicconststringArg_GuidArrayCtor="Byte array for GUID must be exactly {0} bytes long.";
publicconststringArg_HexStyleNotSupported="The number style AllowHexSpecifier is not supported on floating point data types.";
publicconststringArg_HTCapacityOverflow="Hashtable's capacity overflowed and went negative. Check load factor, capacity and the current size of the table.";
publicconststringArg_IndexOutOfRangeException="Index was outside the bounds of the array.";
publicconststringArg_InsufficientExecutionStackException="Insufficient stack to continue executing the program safely. This can happen from having too many functions on the call stack or function on the stack using too much stack space.";
publicconststringArg_InvalidBase="Invalid Base.";
publicconststringArg_InvalidCastException="Specified cast is not valid.";
publicconststringArg_InvalidHexStyle="With the AllowHexSpecifier bit set in the enum bit field, the only other valid bits that can be combined into the enum value must be a subset of those in HexNumber.";
publicconststringArg_InvalidOperationException="Operation is not valid due to the current state of the object.";
publicconststringArg_OleAutDateInvalid=" Not a legal OleAut date.";
publicconststringArg_OleAutDateScale="OleAut date did not convert to a DateTime correctly.";
publicconststringArgument_AdjustmentRulesOutOfOrder="The elements of the AdjustmentRule array must be in chronological order and must not overlap.";
publicconststringArgument_BadFormatSpecifier="Format specifier was invalid.";
publicconststringArgument_CodepageNotSupported="{0} is not a supported code page.";
publicconststringArgument_CompareOptionOrdinal="CompareOption.Ordinal cannot be used with other options.";
publicconststringArgument_ConflictingDateTimeRoundtripStyles="The DateTimeStyles value RoundtripKind cannot be used with the values AssumeLocal, AssumeUniversal or AdjustToUniversal.";
publicconststringArgument_ConflictingDateTimeStyles="The DateTimeStyles values AssumeLocal and AssumeUniversal cannot be used together.";
publicconststringArgument_ConvertMismatch="The conversion could not be completed because the supplied DateTime did not have the Kind property set correctly. For example, when the Kind property is DateTimeKind.Local, the source time zone must be TimeZoneInfo.Local.";
publicconststringArgument_CultureInvalidIdentifier="{0} is an invalid culture identifier.";
publicconststringArgument_CultureIetfNotSupported="Culture IETF Name {0} is not a recognized IETF name.";
publicconststringArgument_CultureIsNeutral="Culture ID {0} (0x{0:X4}) is a neutral culture; a region cannot be created from it.";
publicconststringArgument_CultureNotSupported="Culture is not supported.";
publicconststringArgument_CustomCultureCannotBePassedByNumber="Customized cultures cannot be passed by LCID, only by name.";
publicconststringArgument_DateTimeBadBinaryData="The binary data must result in a DateTime with ticks between DateTime.MinValue.Ticks and DateTime.MaxValue.Ticks.";
publicconststringArgument_DateTimeHasTicks="The supplied DateTime must have the Year, Month, and Day properties set to 1. The time cannot be specified more precisely than whole milliseconds.";
publicconststringArgument_DateTimeHasTimeOfDay="The supplied DateTime includes a TimeOfDay setting. This is not supported.";
publicconststringArgument_DateTimeIsInvalid="The supplied DateTime represents an invalid time. For example, when the clock is adjusted forward, any time in the period that is skipped is invalid.";
publicconststringArgument_DateTimeIsNotAmbiguous="The supplied DateTime is not in an ambiguous time range.";
publicconststringArgument_DateTimeKindMustBeUnspecified="The supplied DateTime must have the Kind property set to DateTimeKind.Unspecified.";
publicconststringArgument_DateTimeOffsetInvalidDateTimeStyles="The DateTimeStyles value 'NoCurrentDateDefault' is not allowed when parsing DateTimeOffset.";
publicconststringArgument_DateTimeOffsetIsNotAmbiguous="The supplied DateTimeOffset is not in an ambiguous time range.";
publicconststringArgument_EmptyDecString="Decimal separator cannot be the empty string.";
publicconststringArgument_EmptyName="Empty name is not legal.";
publicconststringArgument_EmptyWaithandleArray="Waithandle array may not be empty.";
publicconststringArgument_EncoderFallbackNotEmpty="Must complete Convert() operation or call Encoder.Reset() before calling GetBytes() or GetByteCount(). Encoder '{0}' fallback '{1}'.";
publicconststringArgument_EncodingConversionOverflowBytes="The output byte buffer is too small to contain the encoded data, encoding '{0}' fallback '{1}'.";
publicconststringArgument_EncodingConversionOverflowChars="The output char buffer is too small to contain the decoded characters, encoding '{0}' fallback '{1}'.";
publicconststringArgument_EncodingNotSupported="'{0}' is not a supported encoding name. For information on defining a custom encoding, see the documentation for the Encoding.RegisterProvider method.";
publicconststringArgument_EnumTypeDoesNotMatch="The argument type, '{0}', is not the same as the enum type '{1}'.";
publicconststringArgument_FallbackBufferNotEmpty="Cannot change fallback when buffer is not empty. Previous Convert() call left data in the fallback buffer.";
publicconststringArgument_IdnBadLabelSize="IDN labels must be between 1 and 63 characters long.";
publicconststringArgument_InvalidDateTimeStyles="An undefined DateTimeStyles value is being used.";
publicconststringArgument_InvalidDigitSubstitution="The DigitSubstitution property must be of a valid member of the DigitShapes enumeration. Valid entries include Context, NativeNational or None.";
publicconststringArgument_InvalidEnumValue="The value '{0}' is not valid for this usage of the type {1}.";
publicconststringArgument_InvalidFlag="Value of flags is invalid.";
publicconststringArgument_InvalidGroupSize="Every element in the value array should be between one and nine, except for the last element, which can be zero.";
publicconststringArgument_InvalidHighSurrogate="Found a high surrogate char without a following low surrogate at index: {0}. The input may not be in this encoding, or may not contain valid Unicode (UTF-16) characters.";
publicconststringArgument_InvalidId="The specified ID parameter '{0}' is not supported.";
publicconststringArgument_InvalidLowSurrogate="Found a low surrogate char without a preceding high surrogate at index: {0}. The input may not be in this encoding, or may not contain valid Unicode (UTF-16) characters.";
publicconststringArgument_InvalidNativeDigitCount="The NativeDigits array must contain exactly ten members.";
publicconststringArgument_InvalidNativeDigitValue="Each member of the NativeDigits array must be a single text element (one or more UTF16 code points) with a Unicode Nd (Number, Decimal Digit) property indicating it is a digit.";
publicconststringArgument_InvalidNeutralRegionName="The region name {0} should not correspond to neutral culture; a specific culture name is required.";
publicconststringArgument_InvalidNumberStyles="An undefined NumberStyles value is being used.";
publicconststringArgument_InvalidOffLen="Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.";
publicconststringArgument_InvalidPathChars="Illegal characters in path.";
publicconststringArgument_InvalidREG_TZI_FORMAT="The REG_TZI_FORMAT structure is corrupt.";
publicconststringArgument_InvalidResourceCultureName="The given culture name '{0}' cannot be used to locate a resource file. Resource filenames must consist of only letters, numbers, hyphens or underscores.";
publicconststringArgument_InvalidSerializedString="The specified serialized string '{0}' is not supported.";
publicconststringArgument_InvalidTimeSpanStyles="An undefined TimeSpanStyles value is being used.";
publicconststringArgument_MustBeFalse="Argument must be initialized to false";
publicconststringArgument_NoEra="No Era was supplied.";
publicconststringArgument_NoRegionInvariantCulture="There is no region associated with the Invariant Culture (Culture ID: 0x7F).";
publicconststringArgument_NotIsomorphic="Object contains non-primitive or non-blittable data.";
publicconststringArgument_OffsetLocalMismatch="The UTC Offset of the local dateTime parameter does not match the offset argument.";
publicconststringArgument_OffsetPrecision="Offset must be specified in whole minutes.";
publicconststringArgument_OffsetOutOfRange="Offset must be within plus or minus 14 hours.";
publicconststringArgument_OffsetUtcMismatch="The UTC Offset for Utc DateTime instances must be 0.";
publicconststringArgument_OneOfCulturesNotSupported="Culture name {0} or {1} is not supported.";
publicconststringArgument_OnlyMscorlib="Only mscorlib's assembly is valid.";
publicconststringArgument_OutOfOrderDateTimes="The DateStart property must come before the DateEnd property.";
publicconststringArgumentOutOfRange_Index="Index was out of range. Must be non-negative and less than the size of the collection.";
publicconststringArgumentOutOfRange_NeedNonNegNum="Non-negative number required.";
publicconststringArgumentOutOfRange_NeedNonNegNumRequired="Non-negative number required.";
publicconststringArgument_PathEmpty="Path cannot be the empty string or all whitespace.";
publicconststringArgument_PathFormatNotSupported="The given path's format is not supported.";
publicconststringArgument_RecursiveFallback="Recursive fallback not allowed for character \\\\u{0:X4}.";
publicconststringArgument_RecursiveFallbackBytes="Recursive fallback not allowed for bytes {0}.";
publicconststringArgument_ResultCalendarRange="The result is out of the supported range for this calendar. The result should be between {0} (Gregorian date) and {1} (Gregorian date), inclusive.";
publicconststringArgument_SemaphoreInitialMaximum="The initial count for the semaphore must be greater than or equal to zero and less than the maximum count.";
publicconststringArgument_TimeSpanHasSeconds="The TimeSpan parameter cannot be specified more precisely than whole minutes.";
publicconststringArgument_TimeZoneNotFound="The time zone ID '{0}' was not found on the local computer.";
publicconststringArgument_TimeZoneInfoBadTZif="The tzfile does not begin with the magic characters 'TZif'. Please verify that the file is not corrupt.";
publicconststringArgument_TimeZoneInfoInvalidTZif="The TZif data structure is corrupt.";
publicconststringArgument_TransitionTimesAreIdentical="The DaylightTransitionStart property must not equal the DaylightTransitionEnd property.";
publicconststringArgument_UTCOutOfRange="The UTC time represented when the offset is applied must be between year 0 and 10,000.";
publicconststringArgument_WaitHandleNameTooLong="The name can be no more than 260 characters in length.";
publicconststringArgumentException_OtherNotArrayOfCorrectLength="Object is not a array with the same number of elements as the array to compare it to.";
publicconststringArgumentException_TupleIncorrectType="Argument must be of type {0}.";
publicconststringArgumentException_TupleLastArgumentNotATuple="The last element of an eight element tuple must be a Tuple.";
publicconststringArgumentException_ValueTupleIncorrectType="Argument must be of type {0}.";
publicconststringArgumentException_ValueTupleLastArgumentNotATuple="The TRest type argument of ValueTuple`8 must be a ValueTuple.";
publicconststringArgumentNull_Array="Array cannot be null.";
publicconststringArgumentNull_ArrayElement="At least one element in the specified array was null.";
publicconststringArgumentNull_ArrayValue="Found a null value within an array.";
publicconststringArgumentNull_Generic="Value cannot be null.";
publicconststringArgumentNull_Key="Key cannot be null.";
publicconststringArgumentNull_Obj="Object cannot be null.";
publicconststringArgumentNull_String="String reference not set to an instance of a String.";
publicconststringArgumentNull_Waithandles="The waitHandles parameter cannot be null.";
publicconststringArgumentNull_WithParamName="Parameter '{0}' cannot be null.";
publicconststringArgumentOutOfRange_AddValue="Value to add was out of range.";
publicconststringArgumentOutOfRange_ActualValue="Actual value was {0}.";
publicconststringArgumentOutOfRange_BadYearMonthDay="Year, Month, and Day parameters describe an un-representable DateTime.";
publicconststringArgumentOutOfRange_BadHourMinuteSecond="Hour, Minute, and Second parameters describe an un-representable DateTime.";
publicconststringArgumentOutOfRange_BiggerThanCollection="Must be less than or equal to the size of the collection.";
publicconststringArgumentOutOfRange_Bounds_Lower_Upper="Argument must be between {0} and {1}.";
publicconststringArgumentOutOfRange_CalendarRange="Specified time is not supported in this calendar. It should be between {0} (Gregorian date) and {1} (Gregorian date), inclusive.";
publicconststringArgumentOutOfRange_Capacity="Capacity exceeds maximum capacity.";
publicconststringArgumentOutOfRange_Count="Count must be positive and count must refer to a location within the string/array/collection.";
publicconststringArgumentOutOfRange_DateArithmetic="The added or subtracted value results in an un-representable DateTime.";
publicconststringArgumentOutOfRange_DateTimeBadMonths="Months value must be between +/-120000.";
publicconststringArgumentOutOfRange_DateTimeBadTicks="Ticks must be between DateTime.MinValue.Ticks and DateTime.MaxValue.Ticks.";
publicconststringArgumentOutOfRange_DateTimeBadYears="Years value must be between +/-10000.";
publicconststringArgumentOutOfRange_Day="Day must be between 1 and {0} for month {1}.";
publicconststringArgumentOutOfRange_DayOfWeek="The DayOfWeek enumeration must be in the range 0 through 6.";
publicconststringArgumentOutOfRange_DayParam="The Day parameter must be in the range 1 through 31.";
publicconststringArgumentOutOfRange_DecimalRound="Decimal can only round to between 0 and 28 digits of precision.";
publicconststringArgumentOutOfRange_DecimalScale="Decimal's scale value must be between 0 and 28, inclusive.";
publicconststringArgumentOutOfRange_EndIndexStartIndex="endIndex cannot be greater than startIndex.";
publicconststringArgumentOutOfRange_Enum="Enum value was out of legal range.";
publicconststringArgumentOutOfRange_Era="Time value was out of era range.";
publicconststringArgumentOutOfRange_FileTimeInvalid="Not a valid Win32 FileTime.";
publicconststringArgumentOutOfRange_GenericPositive="Value must be positive.";
publicconststringArgumentOutOfRange_GetByteCountOverflow="Too many characters. The resulting number of bytes is larger than what can be returned as an int.";
publicconststringArgumentOutOfRange_GetCharCountOverflow="Too many bytes. The resulting number of chars is larger than what can be returned as an int.";
publicconststringArgumentOutOfRange_IndexCount="Index and count must refer to a location within the string.";
publicconststringArgumentOutOfRange_IndexCountBuffer="Index and count must refer to a location within the buffer.";
publicconststringArgumentOutOfRange_IndexLength="Index and length must refer to a location within the string.";
publicconststringArgumentOutOfRange_InvalidEraValue="Era value was not valid.";
publicconststringArgumentOutOfRange_InvalidHighSurrogate="A valid high surrogate character is between 0xd800 and 0xdbff, inclusive.";
publicconststringArgumentOutOfRange_InvalidLowSurrogate="A valid low surrogate character is between 0xdc00 and 0xdfff, inclusive.";
publicconststringArgumentOutOfRange_InvalidUTF32="A valid UTF32 value is between 0x000000 and 0x10ffff, inclusive, and should not include surrogate codepoint values (0x00d800 ~ 0x00dfff).";
publicconststringArgumentOutOfRange_LengthTooLarge="The specified length exceeds the maximum value of {0}.";
publicconststringArgumentOutOfRange_LengthGreaterThanCapacity="The length cannot be greater than the capacity.";
publicconststringArgumentOutOfRange_ListInsert="Index must be within the bounds of the List.";
publicconststringArgumentOutOfRange_ListItem="Index was out of range. Must be non-negative and less than the size of the list.";
publicconststringArgumentOutOfRange_ListRemoveAt="Index was out of range. Must be non-negative and less than the size of the list.";
publicconststringArgumentOutOfRange_Month="Month must be between one and twelve.";
publicconststringArgumentOutOfRange_MonthParam="The Month parameter must be in the range 1 through 12.";
publicconststringArgumentOutOfRange_MustBeNonNegInt32="Value must be non-negative and less than or equal to Int32.MaxValue.";
publicconststringArgumentOutOfRange_MustBeNonNegNum="'{0}' must be non-negative.";
publicconststringArgumentOutOfRange_MustBePositive="'{0}' must be greater than zero.";
publicconststringArgumentOutOfRange_NeedNonNegOrNegative1="Number must be either non-negative and less than or equal to Int32.MaxValue or -1.";
publicconststringArgumentOutOfRange_NeedPosNum="Positive number required.";
publicconststringArgumentOutOfRange_NegativeCapacity="Capacity must be positive.";
publicconststringArgumentOutOfRange_NegativeCount="Count cannot be less than zero.";
publicconststringArgumentOutOfRange_NegativeLength="Length cannot be less than zero.";
publicconststringArgumentOutOfRange_OffsetLength="Offset and length must refer to a position in the string.";
publicconststringArgumentOutOfRange_OffsetOut="Either offset did not refer to a position in the string, or there is an insufficient length of destination character array.";
publicconststringArgumentOutOfRange_PartialWCHAR="Pointer startIndex and length do not refer to a valid string.";
publicconststringArgumentOutOfRange_Range="Valid values are between {0} and {1}, inclusive.";
publicconststringArgumentOutOfRange_RoundingDigits="Rounding digits must be between 0 and 15, inclusive.";
publicconststringArgumentOutOfRange_SmallCapacity="capacity was less than the current size.";
publicconststringArgumentOutOfRange_SmallMaxCapacity="MaxCapacity must be one or greater.";
publicconststringArgumentOutOfRange_StartIndex="StartIndex cannot be less than zero.";
publicconststringArgumentOutOfRange_StartIndexLargerThanLength="startIndex cannot be larger than length of string.";
publicconststringArgumentOutOfRange_StartIndexLessThanLength="startIndex must be less than length of string.";
publicconststringArgumentOutOfRange_UtcOffset="The TimeSpan parameter must be within plus or minus 14.0 hours.";
publicconststringArgumentOutOfRange_UtcOffsetAndDaylightDelta="The sum of the BaseUtcOffset and DaylightDelta properties must within plus or minus 14.0 hours.";
publicconststringArgumentOutOfRange_Version="Version's parameters must be greater than or equal to zero.";
publicconststringArgumentOutOfRange_Week="The Week parameter must be in the range 1 through 5.";
publicconststringArgumentOutOfRange_Year="Year must be between 1 and 9999.";
publicconststringArithmetic_NaN="Function does not accept floating point Not-a-Number values.";
publicconststringArrayTypeMismatch_CantAssignType="Source array type cannot be assigned to destination array type.";
publicconststringBadImageFormatException_CouldNotLoadFileOrAssembly="Could not load file or assembly '{0}'. An attempt was made to load a program with an incorrect format.";
publicconststringCollectionCorrupted="A prior operation on this collection was interrupted by an exception. Collection's state is no longer trusted.";
publicconststringException_EndOfInnerExceptionStack="--- End of inner exception stack trace ---";
publicconststringException_WasThrown="Exception of type '{0}' was thrown.";
publicconststringFormat_BadBase64Char="The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters.";
publicconststringFormat_BadBase64CharArrayLength="Invalid length for a Base-64 char array or string.";
publicconststringFormat_BadBoolean="String was not recognized as a valid Boolean.";
publicconststringFormat_BadFormatSpecifier="Format specifier was invalid.";
publicconststringFormat_BadQuote="Cannot find a matching quote character for the character '{0}'.";
publicconststringFormat_EmptyInputString="Input string was either empty or contained only whitespace.";
publicconststringFormat_GuidHexPrefix="Expected hex 0x in '{0}'.";
publicconststringFormat_GuidInvLen="Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).";
publicconststringFormat_GuidInvalidChar="Guid string should only contain hexadecimal characters.";
publicconststringFormat_GuidComma="Could not find a comma, or the length between the previous token and the comma was zero (i.e., '0x,'etc.).";
publicconststringFormat_GuidBraceAfterLastNumber="Could not find a brace, or the length between the previous token and the brace was zero (i.e., '0x,'etc.).";
publicconststringFormat_GuidDashes="Dashes are in the wrong position for GUID parsing.";
publicconststringFormat_GuidEndBrace="Could not find the ending brace.";
publicconststringFormat_ExtraJunkAtEnd="Additional non-parsable characters are at the end of the string.";
publicconststringInvalidOperation_ArrayCreateInstance_NotARuntimeType="Array.CreateInstance() can only accept Type objects created by the runtime.";
publicconststringInvalidOperation_ExpectedEEType="Internal Error: Did not expect an uninstantiated generic type here.";
publicconststringInvalidOperation_ExpectedSpecialLdTokenResult="Internal Error: Expected an uninstantiated generic type here.";
publicconststringInvalidOperation_TooEarly="Internal Error: This operation cannot be invoked in an eager class constructor.";
publicconststringInvalidProgram_Default="Common Language Runtime detected an invalid program.";
publicconststringInvalidProgram_Specific="Common Language Runtime detected an invalid program. The body of method '{0}' is invalid.";
publicconststringInvalidProgram_Vararg="Method '{0}' has a variable argument list. Variable argument lists are not supported in .NET Core.";
publicconststringInvalidTimeZone_InvalidRegistryData="The time zone ID '{0}' was found on the local computer, but the registry information was corrupt.";
publicconststringIO_DriveNotFound_Drive="Could not find the drive '{0}'. The drive might not be ready or might not be mapped.";
publicconststringIO_FileNotFound="Unable to find the specified file.";
publicconststringIO_FileNotFound_FileName="Could not load file or assembly '{0}'. The system cannot find the file specified.";
publicconststringIO_FileLoad="Could not load the specified file.";
publicconststringIO_NoPermissionToDirectoryName="<Path discovery permission to the specified directory was denied.%gt;";
publicconststringIO_PathNotFound_NoPathName="Could not find a part of the path.";
publicconststringIO_PathNotFound_Path="Could not find a part of the path '{0}'.";
publicconststringIO_PathTooLong="The specified path, file name, or both are too long. The fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.";
publicconststringIO_SharingViolation_File="The process cannot access the file '{0}' because it is being used by another process.";
publicconststringIO_SharingViolation_NoFileName="The process cannot access the file because it is being used by another process.";
publicconststringIO_AlreadyExists_Name="Cannot create '{0}' because a file or directory with the same name already exists.";
publicconststringUnauthorizedAccess_IODenied_NoPathName="Access to the path is denied.";
publicconststringUnauthorizedAccess_IODenied_Path="Access to the path '{0}' is denied.";
publicconststringLazy_CreateValue_NoParameterlessCtorForT="The lazily-initialized type does not have a public, parameterless constructor.";
publicconststringLazy_ctor_ModeInvalid="The mode argument specifies an invalid value.";
publicconststringLazy_StaticInit_InvalidOperation="ValueFactory returned null.";
publicconststringLazy_ToString_ValueNotCreated="Value is not created.";
publicconststringLazy_Value_RecursiveCallsToValue="ValueFactory attempted to access the Value property of this instance.";
publicconststringMissingConstructor_Name="Constructor on type '{0}' not found.";
publicconststringMustUseCCRewrite="An assembly (probably '{1}') must be rewritten using the code contracts binary rewriter (CCRewrite) because it is calling Contract.{0} and the CONTRACTS_FULL symbol is defined. Remove any explicit definitions of the CONTRACTS_FULL symbol from your project and rebuild. CCRewrite can be downloaded from http://go.microsoft.com/fwlink/?LinkID=169180. \\r\\nAfter the rewriter is installed, it can be enabled in Visual Studio from the project's Properties page on the Code Contracts pane. Ensure that 'Perform Runtime Contract Checking' is enabled, which will define CONTRACTS_FULL.";
publicconststringnet_uri_AlreadyRegistered="A URI scheme name '{0}' already has a registered custom parser.";
publicconststringnet_uri_BadAuthority="Invalid URI: The Authority/Host could not be parsed.";
publicconststringnet_uri_BadAuthorityTerminator="Invalid URI: The Authority/Host cannot end with a backslash character ('\\\\').";
publicconststringnet_uri_BadFormat="Invalid URI: The format of the URI could not be determined.";
publicconststringnet_uri_BadHostName="Invalid URI: The hostname could not be parsed.";
publicconststringnet_uri_BadPort="Invalid URI: Invalid port specified.";
publicconststringnet_uri_BadScheme="Invalid URI: The URI scheme is not valid.";
publicconststringnet_uri_BadString="Invalid URI: There is an invalid sequence in the string.";
publicconststringnet_uri_BadUserPassword="Invalid URI: The username:password construct is badly formed.";
publicconststringnet_uri_CannotCreateRelative="A relative URI cannot be created because the 'uriString' parameter represents an absolute URI.";
publicconststringnet_uri_SchemeLimit="Invalid URI: The Uri scheme is too long.";
publicconststringnet_uri_EmptyUri="Invalid URI: The URI is empty.";
publicconststringnet_uri_InvalidUriKind="The value '{0}' passed for the UriKind parameter is invalid.";
publicconststringnet_uri_MustRootedPath="Invalid URI: A Dos path must be rooted, for example, 'c:\\\\'.";
publicconststringnet_uri_NeedFreshParser="The URI parser instance passed into 'uriParser' parameter is already registered with the scheme name '{0}'.";
publicconststringnet_uri_NotAbsolute="This operation is not supported for a relative URI.";
publicconststringnet_uri_PortOutOfRange="A derived type '{0}' has reported an invalid value for the Uri port '{1}'.";
publicconststringnet_uri_SizeLimit="Invalid URI: The Uri string is too long.";
publicconststringnet_uri_UserDrivenParsing="A derived type '{0}' is responsible for parsing this Uri instance. The base implementation must not be used.";
publicconststringnet_uri_NotJustSerialization="UriComponents.SerializationInfoString must not be combined with other UriComponents.";
publicconststringnet_uri_BadUnicodeHostForIdn="An invalid Unicode character by IDN standards was specified in the host.";
publicconststringNotSupported_FixedSizeCollection="Collection was of a fixed size.";
publicconststringNotSupported_MaxWaitHandles="The number of WaitHandles must be less than or equal to 64.";
publicconststringNotSupported_OpenType="Cannot create arrays of open type.";
publicconststringNotSupported_NoCodepageData="No data is available for encoding {0}. For information on defining a custom encoding, see the documentation for the Encoding.RegisterProvider method.";
publicconststringNotSupported_ReadOnlyCollection="Collection is read-only.";
publicconststringNotSupported_StringComparison="The string comparison type passed in is currently not supported.";
publicconststringNotSupported_VoidArray="Arrays of System.Void are not supported.";
publicconststringNotSupported_WaitAllSTAThread="WaitAll for multiple handles on a STA thread is not supported.";
publicconststringObjectDisposed_Generic="Cannot access a disposed object.";
publicconststringObjectDisposed_WriterClosed="Cannot write to a closed TextWriter.";
publicconststringOverflow_Byte="Value was either too large or too small for an unsigned byte.";
publicconststringOverflow_Char="Value was either too large or too small for a character.";
publicconststringOverflow_Decimal="Value was either too large or too small for a Decimal.";
publicconststringOverflow_Double="Value was either too large or too small for a Double.";
publicconststringOverflow_TimeSpanElementTooLarge="The TimeSpan could not be parsed because at least one of the numeric components is out of range or contains too many digits.";
publicconststringOverflow_Duration="The duration cannot be returned for TimeSpan.MinValue because the absolute value of TimeSpan.MinValue exceeds the value of TimeSpan.MaxValue.";
publicconststringOverflow_Int16="Value was either too large or too small for an Int16.";
publicconststringOverflow_Int32="Value was either too large or too small for an Int32.";
publicconststringOverflow_Int64="Value was either too large or too small for an Int64.";
publicconststringOverflow_NegateTwosCompNum="Negating the minimum value of a twos complement number is invalid.";
publicconststringOverflow_NegativeUnsigned="The string was being parsed as an unsigned number and could not have a negative sign.";
publicconststringOverflow_SByte="Value was either too large or too small for a signed byte.";
publicconststringOverflow_Single="Value was either too large or too small for a Single.";
publicconststringOverflow_TimeSpanTooLong="TimeSpan overflowed because the duration is too long.";
publicconststringOverflow_UInt16="Value was either too large or too small for a UInt16.";
publicconststringOverflow_UInt32="Value was either too large or too small for a UInt32.";
publicconststringOverflow_UInt64="Value was either too large or too small for a UInt64.";
publicconststringPlatformNotSupported_MakePointerType="MakePointerType() is not supported on this platform.";
publicconststringRank_MultiDimNotSupported="Only single dimension arrays are supported here.";
publicconststringRuntimeWrappedException="An object that does not derive from System.Exception has been wrapped in a RuntimeWrappedException.";
publicconststringSpinWait_SpinUntil_ArgumentNull="The condition argument is null.";
publicconststringSerialization_CorruptField="The value of the field '{0}' is invalid. The serialized data is corrupt.";
publicconststringSerialization_InvalidData="An error occurred while deserializing the object. The serialized data is corrupt.";
publicconststringSerialization_InvalidEscapeSequence="The serialized data contained an invalid escape sequence '\\\\{0}'.";
publicconststringSpinWait_SpinUntil_TimeoutWrong="The timeout must represent a value between -1 and Int32.MaxValue, inclusive.";
publicconststringThreading_AbandonedMutexException="The wait completed due to an abandoned mutex.";
publicconststringThreading_SemaphoreFullException="Adding the specified count to the semaphore would cause it to exceed its maximum count.";
publicconststringThreading_WaitHandleCannotBeOpenedException="No handle of the given name exists.";
publicconststringThreading_WaitHandleCannotBeOpenedException_InvalidHandle="A WaitHandle with system-wide name '{0}' cannot be created. A WaitHandle of a different type might have the same name.";
publicconststringTimeZoneNotFound_MissingRegistryData="The time zone ID '{0}' was not found on the local computer.";
publicconststringTypeInitialization_Default="Type constructor threw an exception.";
publicconststringTypeInitialization_Type="The type initializer for '{0}' threw an exception.";
publicconststringTypeInitialization_Type_NoTypeAvailable="A type initializer threw an exception. To determine which type, inspect the InnerException's StackTrace property.";
publicconststringVerification_Exception="Operation could destabilize the runtime.";
publicconststringArg_EnumFormatUnderlyingTypeAndObjectMustBeSameType="Enum underlying type and the object must be same type or object. Type passed in was '{0}'; the enum underlying type was '{1}'.";
publicconststringFormat_InvalidEnumFormatSpecification="Format String can be only 'G', 'g', 'X', 'x', 'F', 'f', 'D' or 'd'.";
publicconststringArg_MustBeEnumBaseTypeOrEnum="The value passed in must be an enum base or an underlying type for an enum, such as an Int32.";
publicconststringArg_EnumUnderlyingTypeAndObjectMustBeSameType="Enum underlying type and the object must be same type or object must be a String. Type passed in was '{0}'; the enum underlying type was '{1}'.";
publicconststringArg_MustBeType="Type must be a type provided by the runtime.";
publicconststringArg_MustContainEnumInfo="Must specify valid information for parsing in the string.";
publicconststringArg_EnumValueNotFound="Requested value '{0}' was not found.";
publicconststringArgument_StringZeroLength="String cannot be of zero length.";
publicconststringArgument_StringFirstCharIsZero="The first char in the string is the null character.";
publicconststringArgument_LongEnvVarValue="Environment variable name or value is too long.";
publicconststringArgument_IllegalEnvVarName="Environment variable name cannot contain equal character.";
publicconststringArgumentOutOfRange_TimeoutTooLarge="Time-out interval must be less than 2^32-2.";
publicconststringArgumentOutOfRange_PeriodTooLarge="Period must be less than 2^32-2.";
publicconststringTaskScheduler_FromCurrentSynchronizationContext_NoCurrent="The current SynchronizationContext may not be used as a TaskScheduler.";
publicconststringTaskScheduler_ExecuteTask_WrongTaskScheduler="ExecuteTask may not be called for a task which was previously queued to a different TaskScheduler.";
publicconststringTaskScheduler_InconsistentStateAfterTryExecuteTaskInline="The TryExecuteTaskInline call to the underlying scheduler succeeded, but the task body was not invoked.";
publicconststringTaskSchedulerException_ctor_DefaultMessage="An exception was thrown by a TaskScheduler.";
publicconststringTask_MultiTaskContinuation_FireOptions="It is invalid to exclude specific continuation kinds for continuations off of multiple tasks.";
publicconststringTask_ContinueWith_ESandLR="The specified TaskContinuationOptions combined LongRunning and ExecuteSynchronously. Synchronous continuations should not be long running.";
publicconststringTask_MultiTaskContinuation_EmptyTaskList="The tasks argument contains no tasks.";
publicconststringTask_MultiTaskContinuation_NullTask="The tasks argument included a null value.";
publicconststringTask_FromAsync_PreferFairness="It is invalid to specify TaskCreationOptions.PreferFairness in calls to FromAsync.";
publicconststringTask_FromAsync_LongRunning="It is invalid to specify TaskCreationOptions.LongRunning in calls to FromAsync.";
publicconststringAsyncMethodBuilder_InstanceNotInitialized="The builder was not properly initialized.";
publicconststringTaskT_TransitionToFinal_AlreadyCompleted="An attempt was made to transition a task to a final state when it had already completed.";
publicconststringOperationCanceled="The operation was canceled.";
publicconststringCancellationToken_CreateLinkedToken_TokensIsEmpty="No tokens were supplied.";
publicconststringCancellationTokenSource_Disposed="The CancellationTokenSource has been disposed.";
publicconststringCancellationToken_SourceDisposed="The CancellationTokenSource associated with this CancellationToken has been disposed.";
publicconststringTaskExceptionHolder_UnknownExceptionType="(Internal)Expected an Exception or an IEnumerable<Exception>";
publicconststringTaskExceptionHolder_UnhandledException="A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread.";
publicconststringTask_Delay_InvalidMillisecondsDelay="The value needs to be either -1 (signifying an infinite timeout), 0 or a positive integer.";
publicconststringTask_Delay_InvalidDelay="The value needs to translate in milliseconds to -1 (signifying an infinite timeout), 0 or a positive integer less than or equal to Int32.MaxValue.";
publicconststringTask_WaitMulti_NullTask="The tasks array included at least one null element.";
publicconststringTask_ContinueWith_NotOnAnything="The specified TaskContinuationOptions excluded all continuation kinds.";
publicconststringTask_RunSynchronously_AlreadyStarted="RunSynchronously may not be called on a task that was already started.";
publicconststringTask_ThrowIfDisposed="The task has been disposed.";
publicconststringTask_RunSynchronously_TaskCompleted="RunSynchronously may not be called on a task that has already completed.";
publicconststringTask_RunSynchronously_Promise="RunSynchronously may not be called on a task not bound to a delegate, such as the task returned from an asynchronous method.";
publicconststringTask_RunSynchronously_Continuation="RunSynchronously may not be called on a continuation task.";
publicconststringTask_Start_AlreadyStarted="Start may not be called on a task that was already started.";
publicconststringTask_Start_ContinuationTask="Start may not be called on a continuation task.";
publicconststringTask_Start_Promise="Start may not be called on a promise-style task.";
publicconststringTask_Start_TaskCompleted="Start may not be called on a task that has completed.";
publicconststringTaskCanceledException_ctor_DefaultMessage="A task was canceled.";
publicconststringTaskCompletionSourceT_TrySetException_NoExceptions="The exceptions collection was empty.";
publicconststringTaskCompletionSourceT_TrySetException_NullException="The exceptions collection included at least one null element.";
publicconststringArgument_MinMaxValue="'{0}' cannot be greater than {1}.";
publicconststringInvalidOperation_NullContext="Cannot call Set on a null context";
publicconststringExecutionContext_ExceptionInAsyncLocalNotification="An exception was not handled in an AsyncLocal<T> notification callback.";
publicconststringInvalidOperation_WrongAsyncResultOrEndCalledMultiple="Either the IAsyncResult object did not come from the corresponding async method on this type, or the End method was called multiple times with the same IAsyncResult.";
publicconststringSpinLock_IsHeldByCurrentThread="Thread tracking is disabled.";
publicconststringSpinLock_TryEnter_LockRecursionException="The calling thread already holds the lock.";
publicconststringSpinLock_Exit_SynchronizationLockException="The calling thread does not hold the lock.";
publicconststringSpinLock_TryReliableEnter_ArgumentException="The tookLock argument must be set to false before calling this method.";
publicconststringSpinLock_TryEnter_ArgumentOutOfRange="The timeout must be a value between -1 and Int32.MaxValue, inclusive.";
publicconststringManualResetEventSlim_Disposed="The event has been disposed.";
publicconststringManualResetEventSlim_ctor_SpinCountOutOfRange="The spinCount argument must be in the range 0 to {0}, inclusive.";
publicconststringManualResetEventSlim_ctor_TooManyWaiters="There are too many threads currently waiting on the event. A maximum of {0} waiting threads are supported.";
publicconststringInvalidOperation_SendNotSupportedOnWindowsRTSynchronizationContext="Send is not supported in the Windows Runtime SynchronizationContext";
publicconststringSemaphoreSlim_Disposed="The semaphore has been disposed.";
publicconststringSemaphoreSlim_Release_CountWrong="The releaseCount argument must be greater than zero.";
publicconststringSemaphoreSlim_Wait_TimeoutWrong="The timeout must represent a value between -1 and Int32.MaxValue, inclusive.";
publicconststringSemaphoreSlim_ctor_MaxCountWrong="The maximumCount argument must be a positive number. If a maximum is not required, use the constructor without a maxCount parameter.";
publicconststringSemaphoreSlim_ctor_InitialCountWrong="The initialCount argument must be non-negative and less than or equal to the maximumCount.";
publicconststringThreadLocal_ValuesNotAvailable="The ThreadLocal object is not tracking values. To use the Values property, use a ThreadLocal constructor that accepts the trackAllValues parameter and set the parameter to true.";
publicconststringThreadLocal_Value_RecursiveCallsToValue="ValueFactory attempted to access the Value property of this instance.";
publicconststringThreadLocal_Disposed="The ThreadLocal object has been disposed.";
publicconststringLockRecursionException_WriteAfterReadNotAllowed="Write lock may not be acquired with read lock held. This pattern is prone to deadlocks. Please ensure that read locks are released before taking a write lock. If an upgrade is necessary, use an upgrade lock in place of the read lock.";
publicconststringLockRecursionException_RecursiveWriteNotAllowed="Recursive write lock acquisitions not allowed in this mode.";
publicconststringLockRecursionException_ReadAfterWriteNotAllowed="A read lock may not be acquired with the write lock held in this mode.";
publicconststringLockRecursionException_RecursiveUpgradeNotAllowed="Recursive upgradeable lock acquisitions not allowed in this mode.";
publicconststringLockRecursionException_RecursiveReadNotAllowed="Recursive read lock acquisitions not allowed in this mode.";
publicconststringSynchronizationLockException_IncorrectDispose="The lock is being disposed while still being used. It either is being held by a thread and/or has active waiters waiting to acquire the lock.";
publicconststringSynchronizationLockException_MisMatchedWrite="The write lock is being released without being held.";
publicconststringLockRecursionException_UpgradeAfterReadNotAllowed="Upgradeable lock may not be acquired with read lock held.";
publicconststringLockRecursionException_UpgradeAfterWriteNotAllowed="Upgradeable lock may not be acquired with write lock held in this mode. Acquiring Upgradeable lock gives the ability to read along with an option to upgrade to a writer.";
publicconststringSynchronizationLockException_MisMatchedUpgrade="The upgradeable lock is being released without being held.";
publicconststringSynchronizationLockException_MisMatchedRead="The read lock is being released without being held.";
publicconststringInvalidOperation_TimeoutsNotSupported="Timeouts are not supported on this stream.";
publicconststringNotSupported_UnreadableStream="Stream does not support reading.";
publicconststringNotSupported_UnwritableStream="Stream does not support writing.";
publicconststringObjectDisposed_StreamClosed="Cannot access a closed Stream.";
publicconststringNotSupported_SubclassOverride="Derived classes must provide an implementation.";
publicconststringInvalidOperation_NoPublicRemoveMethod="Cannot remove the event handler since no public remove method exists for the event.";
publicconststringInvalidOperation_NoPublicAddMethod="Cannot add the event handler since no public add method exists for the event.";
publicconststringSerialization_NotFound="Member '{0}' was not found.";
publicconststringSerialization_OptionalFieldVersionValue="Version value must be positive.";
publicconststringSerialization_SameNameTwice="Cannot add the same member twice to a SerializationInfo object.";
publicconststringNotSupported_AbstractNonCLS="This non-CLS method is not implemented.";
publicconststringNotSupported_NoTypeInfo="Cannot resolve {0} to a TypeInfo object.";
publicconststringReflectionTypeLoad_LoadFailed="Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.";
publicconststringArg_CustomAttributeFormatException="Binary format of the specified custom attribute was invalid.";
publicconststringArgument_InvalidMemberForNamedArgument="The member must be either a field or a property.";
publicconststringArg_InvalidFilterCriteriaException="Specified filter criteria was invalid.";
publicconststringArg_ParmArraySize="Must specify one or more parameters.";
publicconststringArg_MustBePointer="Type must be a Pointer.";
publicconststringArgument_InvalidEnum="The Enum type should contain one and only one instance field.";
publicconststringArgument_MustHaveAttributeBaseClass="Type passed in must be derived from System.Attribute or System.Attribute itself.";
publicconststringInvalidFilterCriteriaException_CritString="A String must be provided for the filter criteria.";
publicconststringInvalidFilterCriteriaException_CritInt="An Int32 must be provided for the filter criteria.";
publicconststringInvalidOperation_NotSupportedOnWinRTEvent="Adding or removing event handlers dynamically is not supported on WinRT events.";
publicconststringPlatformNotSupported_ReflectionOnly="ReflectionOnly loading is not supported on this platform.";
publicconststringMissingMember_Name="Member '{0}' not found.";
publicconststringMissingMethod_Name="Method '{0}' not found.";
publicconststringMissingField_Name="Field '{0}' not found.";
publicconststringFormat_StringZeroLength="String cannot have zero length.";
publicconststringSecurity_CannotReadRegistryData="The time zone ID '{0}' was found on the local computer, but the application does not have permission to read the registry information.";
publicconststringSecurity_InvalidAssemblyPublicKey="Invalid assembly public key.";
publicconststringSecurity_RegistryPermission="Requested registry access is not allowed.";
publicconststringClassLoad_General="Could not load type '{0}' from assembly '{1}'.";
publicconststringClassLoad_RankTooLarge="'{0}' from assembly '{1}' has too many dimensions.";
publicconststringClassLoad_ExplicitGeneric="Could not load type '{0}' from assembly '{1}' because generic types cannot have explicit layout.";
publicconststringClassLoad_BadFormat="Could not load type '{0}' from assembly '{1}' because the format is invalid.";
publicconststringClassLoad_ValueClassTooLarge="Array of type '{0}' from assembly '{1}' cannot be created because base value type is too large.";
publicconststringClassLoad_ExplicitLayout="Could not load type '{0}' from assembly '{1}' because it contains an object field at offset '{2}' that is incorrectly aligned or overlapped by a non-object field.";
publicconststringEE_MissingMethod="Method not found: '{0}'.";
publicconststringEE_MissingField="Field not found: '{0}'.";
publicconststringUnauthorizedAccess_RegistryKeyGeneric_Key="Access to the registry key '{0}' is denied.";
publicconststringArgument_NotEnoughBytesToRead="There are not enough bytes remaining in the accessor to read at this position.";
publicconststringArgument_NotEnoughBytesToWrite="There are not enough bytes remaining in the accessor to write at this position.";
publicconststringArgument_OffsetAndCapacityOutOfBounds="Offset and capacity were greater than the size of the view.";
publicconststringArgument_UnmanagedMemAccessorWrapAround="The UnmanagedMemoryAccessor capacity and offset would wrap around the high end of the address space.";
publicconststringArgumentOutOfRange_StreamLength="Stream length must be non-negative and less than 2^31 - 1 - origin.";
publicconststringArgumentOutOfRange_UnmanagedMemStreamWrapAround="The UnmanagedMemoryStream capacity would wrap around the high end of the address space.";
publicconststringInvalidOperation_CalledTwice="The method cannot be called twice on the same instance.";
publicconststringIO_FixedCapacity="Unable to expand length of this stream beyond its capacity.";
publicconststringIO_SeekBeforeBegin="An attempt was made to move the position before the beginning of the stream.";
publicconststringIO_StreamTooLong="Stream was too long.";
publicconststringArg_BadDecimal="Read an invalid decimal value from the buffer.";
publicconststringNotSupported_Reading="Accessor does not support reading.";
publicconststringNotSupported_UmsSafeBuffer="This operation is not supported for an UnmanagedMemoryStream created from a SafeBuffer.";
publicconststringNotSupported_Writing="Accessor does not support writing.";
publicconststringNotSupported_UnseekableStream="Stream does not support seeking.";
publicconststringIndexOutOfRange_UMSPosition="Unmanaged memory stream position was beyond the capacity of the stream.";
publicconststringObjectDisposed_StreamIsClosed="Cannot access a closed Stream.";
publicconststringObjectDisposed_ViewAccessorClosed="Cannot access a closed accessor.";
publicconststringArgumentOutOfRange_PositionLessThanCapacityRequired="The position may not be greater or equal to the capacity of the accessor.";
publicconststringIO_EOF_ReadBeyondEOF="Unable to read beyond the end of the stream.";
publicconststringArg_EndOfStreamException="Attempted to read past the end of the stream.";
publicconststringObjectDisposed_FileClosed="Cannot access a closed file.";
publicconststringArg_InvalidSearchPattern="Search pattern cannot contain \\\"..\\\" to move up directories and can be contained only internally in file/directory names, as in \\\"a..b\\\".";
publicconststringArgumentOutOfRange_FileLengthTooBig="Specified file length was too large for the file system.";
publicconststringArgument_InvalidHandle="'handle' has been disposed or is an invalid handle.";
publicconststringArgument_AlreadyBoundOrSyncHandle="'handle' has already been bound to the thread pool, or was not opened for asynchronous I/O.";
publicconststringArgument_PreAllocatedAlreadyAllocated="'preAllocated' is already in use.";
publicconststringArgument_NativeOverlappedAlreadyFree="'overlapped' has already been freed.";
publicconststringArgument_NativeOverlappedWrongBoundHandle="'overlapped' was not allocated by this ThreadPoolBoundHandle instance.";
publicconststringArg_HandleNotAsync="Handle does not support asynchronous operations. The parameters to the FileStream constructor may need to be changed to indicate that the handle was opened synchronously (that is, it was not opened for overlapped I/O).";
publicconststringArgumentNull_Path="Path cannot be null.";
publicconststringArgument_EmptyPath="Empty path name is not legal.";
publicconststringArgument_InvalidFileModeAndAccessCombo="Combining FileMode: {0} with FileAccess: {1} is invalid.";
publicconststringArgument_InvalidAppendMode="Append access can be requested only in write-only mode.";
publicconststringIO_UnknownFileName="[Unknown]";
publicconststringIO_FileStreamHandlePosition="The OS handle's position is not what FileStream expected. Do not use a handle simultaneously in one FileStream and in Win32 code or another FileStream. This may cause data loss.";
publicconststringNotSupported_FileStreamOnNonFiles="FileStream was asked to open a device that was not a file. For support for devices like 'com1:' or 'lpt1:', call CreateFile, then use the FileStream constructors that take an OS handle as an IntPtr.";
publicconststringIO_BindHandleFailed="BindHandle for ThreadPool failed on this handle.";
publicconststringArg_HandleNotSync="Handle does not support synchronous operations. The parameters to the FileStream constructor may need to be changed to indicate that the handle was opened asynchronously (that is, it was opened explicitly for overlapped I/O).";
publicconststringIO_SetLengthAppendTruncate="Unable to truncate data that previously existed in a file opened in Append mode.";
publicconststringIO_SeekAppendOverwrite="Unable seek backward to overwrite data that previously existed in a file opened in Append mode.";
publicconststringIO_FileTooLongOrHandleNotSync="IO operation will not work. Most likely the file will become too long or the handle was not opened to support synchronous IO operations.";
publicconststringIndexOutOfRange_IORaceCondition="Probable I/O race condition detected while copying memory. The I/O package is not thread safe by default. In multithreaded applications, a stream must be accessed in a thread-safe way, such as a thread-safe wrapper returned by TextReader's or TextWriter's Synchronized methods. This also applies to classes like StreamWriter and StreamReader.";
publicconststringArgument_StreamNotSeekable="Stream was not seekable.";
publicconststringArg_ResourceFileUnsupportedVersion="The ResourceReader class does not know how to read this version of .resources files.";
publicconststringResources_StreamNotValid="Stream is not a valid resource file.";
publicconststringBadImageFormat_ResourcesHeaderCorrupted="Corrupt .resources file. Unable to read resources from this file because of invalid header information. Try regenerating the .resources file.";
publicconststringArgument_StreamNotReadable="Stream was not readable.";
publicconststringBadImageFormat_NegativeStringLength="Corrupt .resources file. String length must be non-negative.";
publicconststringBadImageFormat_ResourcesNameInvalidOffset="Corrupt .resources file. The Invalid offset into name section is .";
publicconststringBadImageFormat_TypeMismatch="Corrupt .resources file. The specified type doesn't match the available data in the stream.";
publicconststringBadImageFormat_ResourceNameCorrupted_NameIndex="Corrupt .resources file. The resource name for name index that extends past the end of the stream is ";
publicconststringBadImageFormat_ResourcesDataInvalidOffset="Corrupt .resources file. Invalid offset into data section is ";
publicconststringFormat_Bad7BitInt32="Too many bytes in what should have been a 7 bit encoded Int32.";
publicconststringBadImageFormat_InvalidType="Corrupt .resources file. The specified type doesn't exist.";
publicconststringResourceReaderIsClosed="ResourceReader is closed.";
publicconststringArg_MissingManifestResourceException="Unable to find manifest resource.";
publicconststringSerialization_MissingKeys="The keys for this dictionary are missing.";
publicconststringSerialization_NullKey="One of the serialized keys is null.";
publicconststringNotSupported_KeyCollectionSet="Mutating a key collection derived from a dictionary is not allowed.";
publicconststringNotSupported_ValueCollectionSet="Mutating a value collection derived from a dictionary is not allowed.";
publicconststringIO_IO_StreamTooLong="Stream was too long.";
publicconststringUnauthorizedAccess_MemStreamBuffer="MemoryStream's internal buffer cannot be accessed.";
publicconststringNotSupported_MemStreamNotExpandable="Memory stream is not expandable.";
publicconststringIO_IO_SeekBeforeBegin="An attempt was made to move the position before the beginning of the stream.";
publicconststringArgumentNull_Stream="Stream cannot be null.";
publicconststringIO_IO_InvalidStringLen_Len="BinaryReader encountered an invalid string length of {0} characters.";
publicconststringArgumentOutOfRange_BinaryReaderFillBuffer="The number of bytes requested does not fit into BinaryReader's internal buffer.";
publicconststringBlockingCollection_Add_ConcurrentCompleteAdd="CompleteAdding may not be used concurrently with additions to the collection.";
publicconststringBlockingCollection_Add_Failed="The underlying collection didn't accept the item.";
publicconststringBlockingCollection_CantAddAnyWhenCompleted="At least one of the specified collections is marked as complete with regards to additions.";
publicconststringBlockingCollection_CantTakeAnyWhenAllDone="All collections are marked as complete with regards to additions.";
publicconststringBlockingCollection_CantTakeWhenDone="The collection argument is empty and has been marked as complete with regards to additions.";
publicconststringBlockingCollection_Completed="The collection has been marked as complete with regards to additions.";
publicconststringBlockingCollection_CopyTo_IncorrectType="The array argument is of the incorrect type.";
publicconststringBlockingCollection_CopyTo_MultiDim="The array argument is multidimensional.";
publicconststringBlockingCollection_CopyTo_NonNegative="The index argument must be greater than or equal zero.";
publicconststringCollection_CopyTo_TooManyElems="The number of elements in the collection is greater than the available space from index to the end of the destination array.";
publicconststringBlockingCollection_ctor_BoundedCapacityRange="The boundedCapacity argument must be positive.";
publicconststringBlockingCollection_ctor_CountMoreThanCapacity="The collection argument contains more items than are allowed by the boundedCapacity.";
publicconststringBlockingCollection_Disposed="The collection has been disposed.";
publicconststringBlockingCollection_Take_CollectionModified="The underlying collection was modified from outside of the BlockingCollection<T>.";
publicconststringBlockingCollection_TimeoutInvalid="The specified timeout must represent a value between -1 and {0}, inclusive.";
publicconststringBlockingCollection_ValidateCollectionsArray_DispElems="The collections argument contains at least one disposed element.";
publicconststringBlockingCollection_ValidateCollectionsArray_LargeSize="The collections length is greater than the supported range for 32 bit machine.";
publicconststringBlockingCollection_ValidateCollectionsArray_NullElems="The collections argument contains at least one null element.";
publicconststringBlockingCollection_ValidateCollectionsArray_ZeroSize="The collections argument is a zero-length array.";
publicconststringCommon_OperationCanceled="The operation was canceled.";
publicconststringConcurrentBag_Ctor_ArgumentNullException="The collection argument is null.";
publicconststringConcurrentBag_CopyTo_ArgumentNullException="The array argument is null.";
publicconststringCollection_CopyTo_ArgumentOutOfRangeException="The index argument must be greater than or equal zero.";
publicconststringConcurrentCollection_SyncRoot_NotSupported="The SyncRoot property may not be used for the synchronization of concurrent collections.";
publicconststringConcurrentDictionary_ArrayIncorrectType="The array is multidimensional, or the type parameter for the set cannot be cast automatically to the type of the destination array.";
publicconststringConcurrentDictionary_ConcurrencyLevelMustBePositive="The concurrencyLevel argument must be positive.";
publicconststringConcurrentDictionary_CapacityMustNotBeNegative="The capacity argument must be greater than or equal to zero.";
publicconststringConcurrentDictionary_IndexIsNegative="The index argument is less than zero.";
publicconststringConcurrentDictionary_ArrayNotLargeEnough="The index is equal to or greater than the length of the array, or the number of elements in the dictionary is greater than the available space from index to the end of the destination array.";
publicconststringConcurrentDictionary_KeyAlreadyExisted="The key already existed in the dictionary.";
publicconststringConcurrentDictionary_ItemKeyIsNull="TKey is a reference type and item.Key is null.";
publicconststringConcurrentDictionary_TypeOfKeyIncorrect="The key was of an incorrect type for this dictionary.";
publicconststringConcurrentDictionary_TypeOfValueIncorrect="The value was of an incorrect type for this dictionary.";
publicconststringConcurrentStack_PushPopRange_CountOutOfRange="The count argument must be greater than or equal to zero.";
publicconststringConcurrentStack_PushPopRange_InvalidCount="The sum of the startIndex and count arguments must be less than or equal to the collection's Count.";
publicconststringConcurrentStack_PushPopRange_StartOutOfRange="The startIndex argument must be greater than or equal to zero.";
publicconststringPartitioner_DynamicPartitionsNotSupported="Dynamic partitions are not supported by this partitioner.";
publicconststringPartitionerStatic_CanNotCallGetEnumeratorAfterSourceHasBeenDisposed="Can not call GetEnumerator on partitions after the source enumerable is disposed";
publicconststringPartitionerStatic_CurrentCalledBeforeMoveNext="MoveNext must be called at least once before calling Current.";
publicconststringConcurrentBag_Enumerator_EnumerationNotStartedOrAlreadyFinished="Enumeration has either not started or has already finished.";
