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_DlgtNullInst="Delegate to an instance method cannot have null 'this'.";
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_NeedNonNegNum="Non-negative number required.";
publicconststringArgumentOutOfRange_NeedNonNegNumRequired="Non-negative number required.";
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.";
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}.";
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_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.";
publicconststringInsufficientMemory_MemFailPoint="Insufficient available memory to meet the expected demands of an operation at this time. Please try again later.";
publicconststringInsufficientMemory_MemFailPoint_TooBig="Insufficient memory to meet the expected demands of an operation, and this system is likely to never satisfy this request. If this is a 32 bit system, consider booting in 3 GB mode.";
publicconststringInsufficientMemory_MemFailPoint_VAFrag="Insufficient available memory to meet the expected demands of an operation at this time, possibly due to virtual address space fragmentation. Please try again later.";
publicconststringInvalidOperation_NullContext="Cannot call Set on a null context";
publicconststringInvalidOperation_CannotUseAFCOtherThread="AsyncFlowControl object must be used on the thread where it was created.";
publicconststringInvalidOperation_CannotRestoreUnsupressedFlow="Cannot restore context flow when it is not suppressed.";
publicconststringInvalidOperation_CannotSupressFlowMultipleTimes="Context flow is already suppressed.";
publicconststringInvalidOperation_CannotUseAFCMultiple="AsyncFlowControl object can be used only once to call Undo().";
publicconststringInvalidOperation_AsyncFlowCtrlCtxMismatch="AsyncFlowControl objects can be used to restore flow only on a Context that had its flow suppressed.";
publicconststringInvalidTimeZone_InvalidRegistryData="The time zone ID '{0}' was found on the local computer, but the registry information was corrupt.";
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.";
publicconststringNotSupported_FixedSizeCollection="Collection was of a fixed size.";
publicconststringNotSupported_MaxWaitHandles="The number of WaitHandles must be less than or equal to 64.";
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.";
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.";
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}'.";
publicconststringSerialization_InvalidType="Only system-provided types can be passed to the GetUninitializedObject method. '{0}' is not a valid instance of a type.";
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}.";
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.";
publicconststringPlatformNotSupported_OSXFileLocking="Locking/unlocking file regions is not supported on this platform. Use FileShare on the entire file instead.";
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.";
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.";
publicconststringSerialization_InsufficientDeserializationState="Insufficient state to deserialize the object. Missing field '{0}'.";
publicconststringNotSupported_UnitySerHolder="The UnitySerializationHolder object is designed to transmit information about other types and is not serializable itself.";
publicconststringSerialization_UnableToFindModule="The given module {0} cannot be found within the assembly {1}.";
publicconststringInvalidOperation_InvalidHandle="The handle is invalid.";
publicconststringPlatformNotSupported_NamedSynchronizationPrimitives="The named version of this synchronization primitive is not supported on this platform.";
publicconststringOverflow_MutexReacquireCount="The current thread attempted to reacquire a mutex that has reached its maximum acquire count.";
publicconststringSerialization_InsufficientState="Insufficient state to return the real object.";
publicconststringSerialization_UnknownMember="Cannot get the member '{0}'.";
publicconststringSerialization_NullSignature="The method signature cannot be null.";
publicconststringSerialization_MemberTypeNotRecognized="Unknown member type.";
publicconststringSerialization_BadParameterInfo="Non existent ParameterInfo. Position bigger than member's parameters length.";
publicconststringSerialization_NoParameterInfo="Serialized member does not have a ParameterInfo.";
publicconststringArgumentNull_Assembly="Assembly cannot be null.";
publicconststringArg_InvalidNeutralResourcesLanguage_Asm_Culture="The NeutralResourcesLanguageAttribute on the assembly \"{0}\" specifies an invalid culture name: \"{1}\".";
publicconststringArg_InvalidNeutralResourcesLanguage_FallbackLoc="The NeutralResourcesLanguageAttribute specifies an invalid or unrecognized ultimate resource fallback location: \"{0}\".";
publicconststringArg_InvalidSatelliteContract_Asm_Ver="Satellite contract version attribute on the assembly '{0}' specifies an invalid version: {1}.";
publicconststringArg_ResMgrNotResSet="Type parameter must refer to a subclass of ResourceSet.";
publicconststringBadImageFormat_ResourceNameCorrupted="Corrupt .resources file. A resource name extends past the end of the stream.";
publicconststringBadImageFormat_ResourcesNameTooLong="Corrupt .resources file. Resource name extends past the end of the file.";
publicconststringInvalidOperation_ResMgrBadResSet_Type="'{0}': ResourceSet derived classes must provide a constructor that takes a String file name and a constructor that takes a Stream.";
publicconststringInvalidOperation_ResourceNotStream_Name="Resource '{0}' was not a Stream - call GetObject instead.";
publicconststringMissingManifestResource_MultipleBlobs="A case-insensitive lookup for resource file \"{0}\" in assembly \"{1}\" found multiple entries. Remove the duplicates or specify the exact case.";
publicconststringMissingManifestResource_NoNeutralAsm="Could not find any resources appropriate for the specified culture or the neutral culture. Make sure \"{0}\" was correctly embedded or linked into assembly \"{1}\" at compile time, or that all the satellite assemblies required are loadable and fully signed.";
publicconststringMissingManifestResource_NoNeutralDisk="Could not find any resources appropriate for the specified culture (or the neutral culture) on disk.";
publicconststringMissingManifestResource_NoPRIresources="Unable to open Package Resource Index.";
publicconststringMissingManifestResource_ResWFileNotLoaded="Unable to load resources for resource file \"{0}\" in package \"{1}\".";
publicconststringMissingSatelliteAssembly_Culture_Name="The satellite assembly named \"{1}\" for fallback culture \"{0}\" either could not be found or could not be loaded. This is generally a setup problem. Please consider reinstalling or repairing the application.";
publicconststringMissingSatelliteAssembly_Default="Resource lookup fell back to the ultimate fallback resources in a satellite assembly, but that satellite either was not found or could not be loaded. Please consider reinstalling or repairing the application.";
publicconststringNotSupported_ObsoleteResourcesFile="Found an obsolete .resources file in assembly '{0}'. Rebuild that .resources file then rebuild that assembly.";
publicconststringNotSupported_ResourceObjectSerialization="Cannot read resources that depend on serialization.";
publicconststringObjectDisposed_ResourceSet="Cannot access a closed resource set.";
publicconststringArg_ResourceNameNotExist="The specified resource name \"{0}\" does not exist in the resource file.";
publicconststringBadImageFormat_ResourceDataLengthInvalid="Corrupt .resources file. The specified data length '{0}' is not a valid position in the stream.";
publicconststringBadImageFormat_ResourcesIndexTooLong="Corrupt .resources file. String for name index '{0}' extends past the end of the file.";
publicconststringInvalidOperation_ResourceNotString_Name="Resource '{0}' was not a String - call GetObject instead.";
publicconststringInvalidOperation_ResourceNotString_Type="Resource was of type '{0}' instead of String - call GetObject instead.";
publicconststringNotSupported_WrongResourceReader_Type="This .resources file should not be read with this reader. The resource reader type is \"{0}\".";
publicconststringArg_MustBeDelegate="Type must derive from Delegate.";
publicconststringNotSupported_GlobalMethodSerialization="Serialization of global methods (including implicit serialization via the use of asynchronous delegates) is not supported.";
publicconststringNotSupported_DelegateSerHolderSerial="DelegateSerializationHolder objects are designed to represent a delegate during serialization and are not serializable themselves.";
publicconststringDelegateSer_InsufficientMetadata="The delegate cannot be serialized properly due to missing metadata for the target method.";
publicconststringArgument_NoUninitializedStrings="Uninitialized Strings cannot be created.";
publicconststringArgumentOutOfRangeException_NoGCRegionSizeTooLarge="totalSize is too large. For more information about setting the maximum size, see \\\"Latency Modes\\\" in http://go.microsoft.com/fwlink/?LinkId=522706.";
publicconststringInvalidOperationException_AlreadyInNoGCRegion="The NoGCRegion mode was already in progress.";
publicconststringInvalidOperationException_NoGCRegionAllocationExceeded="Allocated memory exceeds specified memory for NoGCRegion mode.";
publicconststringInvalidOperationException_NoGCRegionInduced="Garbage collection was induced in NoGCRegion mode.";
publicconststringInvalidOperationException_NoGCRegionNotInProgress="NoGCRegion mode must be set.";
publicconststringInvalidOperationException_SetLatencyModeNoGC="The NoGCRegion mode is in progress. End it and then set a different mode.";
publicconststringInvalidOperation_NotWithConcurrentGC="This API is not available when the concurrent GC is enabled.";
publicconststringThreadState_AlreadyStarted="Thread is running or terminated; it cannot restart.";
publicconststringThreadState_Dead_Priority="Thread is dead; priority cannot be accessed.";
publicconststringThreadState_Dead_State="Thread is dead; state cannot be accessed.";
publicconststringThreadState_NotStarted="Thread has not been started.";
publicconststringThreadState_SetPriorityFailed="Unable to set thread priority.";
publicconststringSerialization_InvalidFieldState="Object fields may not be properly initialized.";
publicconststringAcc_CreateAbst="Cannot create an abstract class.";
publicconststringAcc_CreateGeneric="Cannot create a type for which Type.ContainsGenericParameters is true.";
publicconststringArgument_InvalidValue="Value was invalid.";
publicconststringNotSupported_ManagedActivation="Cannot create uninitialized instances of types requiring managed activation.";
publicconststringPlatformNotSupported_ResourceManager_ResWFileUnsupportedMethod="ResourceManager method '{0}' is not supported when reading from .resw resource files.";
publicconststringPlatformNotSupported_ResourceManager_ResWFileUnsupportedProperty="ResourceManager property '{0}' is not supported when reading from .resw resource files.";
publicconststringSerialization_NonSerType="Type '{0}' in Assembly '{1}' is not marked as serializable.";
publicconststringInvalidCast_DBNull="Object cannot be cast to DBNull.";
publicconststringNotSupported_NYI="This feature is not currently implemented.";
publicconststringDelegate_GarbageCollected="The corresponding delegate has been garbage collected. Please make sure the delegate is still referenced by managed code when you are using the marshalled native function pointer.";
publicconststringArg_AmbiguousMatchException="Ambiguous match found.";
publicconststringNotSupported_ChangeType="ChangeType operation is not supported.";
publicconststringArg_EmptyArray="Array may not be empty.";
publicconststringMissingMember="Member not found.";
publicconststringMissingField="Field not found.";
publicconststringInvalidCast_FromDBNull="Object cannot be cast from DBNull to other types.";
publicconststringNotSupported_DBNullSerial="Only one DBNull instance may exist, and calls to DBNull deserialization methods are not allowed.";
publicconststringSerialization_StringBuilderCapacity="The serialized Capacity property of StringBuilder must be positive, less than or equal to MaxCapacity and greater than or equal to the String length.";
publicconststringSerialization_StringBuilderMaxCapacity="The serialized MaxCapacity property of StringBuilder must be positive and greater than or equal to the String length.";
publicconststringPlatformNotSupported_Remoting="Remoting is not supported on this platform.";
publicconststringPlatformNotSupported_StrongNameSigning="Strong-name signing is not supported on this platform.";
publicconststringSerialization_MissingDateTimeData="Invalid serialized DateTime data. Unable to find 'ticks' or 'dateData'.";
publicconststringSerialization_DateTimeTicksOutOfRange="Invalid serialized DateTime data. Ticks must be between DateTime.MinValue.Ticks and DateTime.MaxValue.Ticks.";
publicconststringArg_InvalidANSIString="The ANSI string passed in could not be converted from the default ANSI code page to Unicode.";
publicconststringArg_ExpectedNulTermination="The value passed was not NUL terminated.";
publicconststringPlatformNotSupported_ArgIterator="ArgIterator is not supported on this platform.";
publicconststringArg_TypeUnloadedException="Type had been unloaded.";
publicconststringOverflow_Currency="Value was either too large or too small for a Currency.";
publicconststringPlatformNotSupported_SecureBinarySerialization="Secure binary serialization is not supported on this platform.";
publicconststringSerialization_InvalidPtrValue="An IntPtr or UIntPtr with an eight byte value cannot be deserialized on a machine with a four byte word size.";
publicconststringEventSource_ListenerNotFound="Listener not found.";
publicconststringEventSource_ImplementGetMetadata="Please implement the GetMetadata method in your derived class";
publicconststringEventSource_NeedGuid="The Guid of an EventSource must be non zero.";
publicconststringEventSource_NeedName="The name of an EventSource must not be null.";
publicconststringEventSource_NeedDescriptors="The descriptor of an EventSource must be non-null.";
publicconststringEventSource_NeedManifest="The manifest of an EventSource must be non-null.";
publicconststringEventSource_EventSourceGuidInUse="An instance of EventSource with Guid {0} already exists.";
publicconststringEventSource_ListenerWriteFailure="An error occurred when writing to a listener.";
publicconststringEventSource_NoManifest="A manifest could not be generated for this EventSource because it contains one or more ill-formed event methods.";
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.";
