publicconststringPropertyTypeCannotBeVoid="Property cannot have a void type.";
publicconststringInvalidUnboxType="Can only unbox from an object or interface type to a value type.";
publicconststringExpressionMustBeWriteable="Expression must be writeable";
publicconststringArgumentMustNotHaveValueType="Argument must not have a value type.";
publicconststringMustBeReducible="must be reducible node";
publicconststringAllTestValuesMustHaveSameType="All test values must have the same type.";
publicconststringAllCaseBodiesMustHaveSameType="All case bodies and the default body must have the same type.";
publicconststringDefaultBodyMustBeSupplied="Default body must be supplied if case bodies are not System.Void.";
publicconststringLabelMustBeVoidOrHaveExpression="Label type must be System.Void if an expression is not supplied";
publicconststringLabelTypeMustBeVoid="Type must be System.Void for this label argument";
publicconststringQuotedExpressionMustBeLambda="Quoted expression must be a lambda";
publicconststringVariableMustNotBeByRef="Variable '{0}' uses unsupported type '{1}'. Reference types are not supported for variables.";
publicconststringDuplicateVariable="Found duplicate parameter '{0}'. Each ParameterExpression in the list must be a unique object.";
publicconststringStartEndMustBeOrdered="Start and End must be well ordered";
publicconststringFaultCannotHaveCatchOrFinally="fault cannot be used with catch or finally clauses";
publicconststringTryMustHaveCatchFinallyOrFault="try must have at least one catch, finally, or fault clause";
publicconststringBodyOfCatchMustHaveSameTypeAsBodyOfTry="Body of catch must have the same type as body of try.";
publicconststringExtensionNodeMustOverrideProperty="Extension node must override the property {0}.";
publicconststringUserDefinedOperatorMustBeStatic="User-defined operator method '{0}' must be static.";
publicconststringUserDefinedOperatorMustNotBeVoid="User-defined operator method '{0}' must not be void.";
publicconststringCoercionOperatorNotDefined="No coercion operator is defined between types '{0}' and '{1}'.";
publicconststringUnaryOperatorNotDefined="The unary operator {0} is not defined for the type '{1}'.";
publicconststringBinaryOperatorNotDefined="The binary operator {0} is not defined for the types '{1}' and '{2}'.";
publicconststringReferenceEqualityNotDefined="Reference equality is not defined for the types '{0}' and '{1}'.";
publicconststringOperandTypesDoNotMatchParameters="The operands for operator '{0}' do not match the parameters of method '{1}'.";
publicconststringOverloadOperatorTypeDoesNotMatchConversionType="The return type of overload method for operator '{0}' does not match the parameter type of conversion method '{1}'.";
publicconststringConversionIsNotSupportedForArithmeticTypes="Conversion is not supported for arithmetic types without operator overloading.";
publicconststringArgumentMustBeArray="Argument must be array";
publicconststringArgumentMustBeBoolean="Argument must be boolean";
publicconststringEqualityMustReturnBoolean="The user-defined equality method '{0}' must return a boolean value.";
publicconststringArgumentMustBeFieldInfoOrPropertyInfo="Argument must be either a FieldInfo or PropertyInfo";
publicconststringArgumentMustBeFieldInfoOrPropertyInfoOrMethod="Argument must be either a FieldInfo, PropertyInfo or MethodInfo";
publicconststringArgumentMustBeInstanceMember="Argument must be an instance member";
publicconststringArgumentMustBeInteger="Argument must be of an integer type";
publicconststringArgumentMustBeArrayIndexType="Argument for array index must be of type Int32";
publicconststringArgumentMustBeSingleDimensionalArrayType="Argument must be single-dimensional, zero-based array type";
publicconststringArgumentTypesMustMatch="Argument types do not match";
publicconststringCannotAutoInitializeValueTypeElementThroughProperty="Cannot auto initialize elements of value type through property '{0}', use assignment instead";
publicconststringCannotAutoInitializeValueTypeMemberThroughProperty="Cannot auto initialize members of value type through property '{0}', use assignment instead";
publicconststringIncorrectTypeForTypeAs="The type used in TypeAs Expression must be of reference or nullable type, {0} is neither";
publicconststringCoalesceUsedOnNonNullType="Coalesce used with type that cannot be null";
publicconststringExpressionTypeCannotInitializeArrayType="An expression of type '{0}' cannot be used to initialize an array of type '{1}'";
publicconststringArgumentTypeDoesNotMatchMember=" Argument type '{0}' does not match the corresponding member type '{1}'";
publicconststringArgumentMemberNotDeclOnType=" The member '{0}' is not declared on type '{1}' being created";
publicconststringExpressionTypeDoesNotMatchReturn="Expression of type '{0}' cannot be used for return type '{1}'";
publicconststringExpressionTypeDoesNotMatchAssignment="Expression of type '{0}' cannot be used for assignment to type '{1}'";
publicconststringExpressionTypeDoesNotMatchLabel="Expression of type '{0}' cannot be used for label of type '{1}'";
publicconststringExpressionTypeNotInvocable="Expression of type '{0}' cannot be invoked";
publicconststringFieldNotDefinedForType="Field '{0}' is not defined for type '{1}'";
publicconststringInstanceFieldNotDefinedForType="Instance field '{0}' is not defined for type '{1}'";
publicconststringFieldInfoNotDefinedForType="Field '{0}.{1}' is not defined for type '{2}'";
publicconststringIncorrectNumberOfIndexes="Incorrect number of indexes";
publicconststringIncorrectNumberOfLambdaDeclarationParameters="Incorrect number of parameters supplied for lambda declaration";
publicconststringIncorrectNumberOfMembersForGivenConstructor=" Incorrect number of members for constructor";
publicconststringIncorrectNumberOfArgumentsForMembers="Incorrect number of arguments for the given members ";
publicconststringLambdaTypeMustBeDerivedFromSystemDelegate="Lambda type parameter must be derived from System.MulticastDelegate";
publicconststringMemberNotFieldOrProperty="Member '{0}' not field or property";
publicconststringTypeIsGeneric="Type {0} is a generic type definition";
publicconststringTypeMissingDefaultConstructor="Type '{0}' does not have a default constructor";
publicconststringElementInitializerMethodNotAdd="Element initializer method must be named 'Add'";
publicconststringElementInitializerMethodNoRefOutParam="Parameter '{0}' of element initializer method '{1}' must not be a pass by reference parameter";
publicconststringElementInitializerMethodWithZeroArgs="Element initializer method must have at least 1 parameter";
publicconststringElementInitializerMethodStatic="Element initializer method must be an instance method";
publicconststringTypeNotIEnumerable="Type '{0}' is not IEnumerable";
publicconststringUserDefinedOpMustHaveConsistentTypes="The user-defined operator method '{1}' for operator '{0}' must have identical parameter and return types.";
publicconststringUserDefinedOpMustHaveValidReturnType="The user-defined operator method '{1}' for operator '{0}' must return the same type as its parameter or a derived type.";
publicconststringLogicalOperatorMustHaveBooleanOperators="The user-defined operator method '{1}' for operator '{0}' must have associated boolean True and False operators.";
publicconststringMethodWithArgsDoesNotExistOnType="No method '{0}' on type '{1}' is compatible with the supplied arguments.";
publicconststringGenericMethodWithArgsDoesNotExistOnType="No generic method '{0}' on type '{1}' is compatible with the supplied type arguments and arguments. No type arguments should be provided if the method is non-generic. ";
publicconststringMethodWithMoreThanOneMatch="More than one method '{0}' on type '{1}' is compatible with the supplied arguments.";
publicconststringPropertyWithMoreThanOneMatch="More than one property '{0}' on type '{1}' is compatible with the supplied arguments.";
publicconststringIncorrectNumberOfTypeArgsForFunc="An incorrect number of type arguments were specified for the declaration of a Func type.";
publicconststringIncorrectNumberOfTypeArgsForAction="An incorrect number of type arguments were specified for the declaration of an Action type.";
publicconststringArgumentCannotBeOfTypeVoid="Argument type cannot be System.Void.";
publicconststringOutOfRange="{0} must be greater than or equal to {1}";
publicconststringLabelTargetAlreadyDefined="Cannot redefine label '{0}' in an inner block.";
publicconststringLabelTargetUndefined="Cannot jump to undefined label '{0}'.";
publicconststringControlCannotLeaveFinally="Control cannot leave a finally block.";
publicconststringControlCannotLeaveFilterTest="Control cannot leave a filter test.";
publicconststringAmbiguousJump="Cannot jump to ambiguous label '{0}'.";
publicconststringControlCannotEnterTry="Control cannot enter a try block.";
publicconststringControlCannotEnterExpression="Control cannot enter an expression--only statements can be jumped into.";
publicconststringNonLocalJumpWithValue="Cannot jump to non-local label '{0}' with a value. Only jumps to labels defined in outer blocks can pass values.";
publicconststringCannotCompileConstant="CompileToMethod cannot compile constant '{0}' because it is a non-trivial value, such as a live object. Instead, create an expression tree that can construct this value.";
publicconststringCannotCompileDynamic="Dynamic expressions are not supported by CompileToMethod. Instead, create an expression tree that uses System.Runtime.CompilerServices.CallSite.";
publicconststringInvalidLvalue="Invalid lvalue for assignment: {0}.";
publicconststringUndefinedVariable="variable '{0}' of type '{1}' referenced from scope '{2}', but it is not defined";
publicconststringCannotCloseOverByRef="Cannot close over byref parameter '{0}' referenced in lambda '{1}'";
publicconststringUnexpectedVarArgsCall="Unexpected VarArgs call to method '{0}'";
publicconststringRethrowRequiresCatch="Rethrow statement is valid only inside a Catch block.";
publicconststringTryNotAllowedInFilter="Try expression is not allowed inside a filter body.";
publicconststringMustRewriteToSameNode="When called from '{0}', rewriting a node of type '{1}' must return a non-null value of the same type. Alternatively, override '{2}' and change it to not visit children of this type.";
publicconststringMustRewriteChildToSameType="Rewriting child expression from type '{0}' to type '{1}' is not allowed, because it would change the meaning of the operation. If this is intentional, override '{2}' and change it to allow this rewrite.";
publicconststringMustRewriteWithoutMethod="Rewritten expression calls operator method '{0}', but the original node had no operator method. If this is intentional, override '{1}' and change it to allow this rewrite.";
publicconststringInvalidNullValue="The value null is not of type '{0}' and cannot be used in this collection.";
publicconststringInvalidObjectType="The value '{0}' is not of type '{1}' and cannot be used in this collection.";
publicconststringTryNotSupportedForMethodsWithRefArgs="TryExpression is not supported as an argument to method '{0}' because it has an argument with by-ref type. Construct the tree so the TryExpression is not nested inside of this expression.";
publicconststringTryNotSupportedForValueTypeInstances="TryExpression is not supported as a child expression when accessing a member on type '{0}' because it is a value type. Construct the tree so the TryExpression is not nested inside of this expression.";
publicconststringEnumerationIsDone="Enumeration has either not started or has already finished.";
publicconststringTestValueTypeDoesNotMatchComparisonMethodParameter="Test value of type '{0}' cannot be used for the comparison method parameter of type '{1}'";
publicconststringSwitchValueTypeDoesNotMatchComparisonMethodParameter="Switch value of type '{0}' cannot be used for the comparison method parameter of type '{1}'";
publicconststringPdbGeneratorNeedsExpressionCompiler="DebugInfoGenerator created by CreatePdbGenerator can only be used with LambdaExpression.CompileToMethod.";
publicconststringCollectionModifiedWhileEnumerating="Collection was modified; enumeration operation may not execute.";
publicconststringExpressionMustBeReadable="Expression must be readable";
publicconststringExpressionTypeDoesNotMatchMethodParameter="Expression of type '{0}' cannot be used for parameter of type '{1}' of method '{2}'";
publicconststringExpressionTypeDoesNotMatchParameter="Expression of type '{0}' cannot be used for parameter of type '{1}'";
publicconststringExpressionTypeDoesNotMatchConstructorParameter="Expression of type '{0}' cannot be used for constructor parameter of type '{1}'";
publicconststringIncorrectNumberOfMethodCallArguments="Incorrect number of arguments supplied for call to method '{0}'";
publicconststringIncorrectNumberOfLambdaArguments="Incorrect number of arguments supplied for lambda invocation";
publicconststringIncorrectNumberOfConstructorArguments="Incorrect number of arguments for constructor";
publicconststringNonStaticConstructorRequired="The constructor should not be static";
publicconststringNonAbstractConstructorRequired="Can't compile a NewExpression with a constructor declared on an abstract class";
publicconststringFirstArgumentMustBeCallSite="First argument of delegate must be CallSite";
publicconststringNoOrInvalidRuleProduced="No or Invalid rule produced";
publicconststringTypeMustBeDerivedFromSystemDelegate="Type must be derived from System.Delegate";
publicconststringTypeParameterIsNotDelegate="Type parameter is {0}. Expected a delegate.";
publicconststringArgumentTypeCannotBeVoid="Argument type cannot be void";
publicconststringArgCntMustBeGreaterThanNameCnt="Argument count must be greater than number of named arguments.";
publicconststringBinderNotCompatibleWithCallSite="The result type '{0}' of the binder '{1}' is not compatible with the result type '{2}' expected by the call site.";
publicconststringDynamicBinderResultNotAssignable="The result type '{0}' of the dynamic binding produced by binder '{1}' is not compatible with the result type '{2}' expected by the call site.";
publicconststringDynamicBindingNeedsRestrictions="The result of the dynamic binding produced by the object with type '{0}' for the binder '{1}' needs at least one restriction.";
publicconststringDynamicObjectResultNotAssignable="The result type '{0}' of the dynamic binding produced by the object with type '{1}' for the binder '{2}' is not compatible with the result type '{3}' expected by the call site.";
publicconststringInvalidMetaObjectCreated="An IDynamicMetaObjectProvider {0} created an invalid DynamicMetaObject instance.";
publicconststringAmbiguousMatchInExpandoObject="More than one key matching '{0}' was found in the ExpandoObject.";
publicconststringCollectionReadOnly="Collection is read-only.";
publicconststringKeyDoesNotExistInExpando="The specified key '{0}' does not exist in the ExpandoObject.";
publicconststringSameKeyExistsInExpando="An element with the same key '{0}' already exists in the ExpandoObject.";
publicconststringEmptyEnumerable="Enumeration yielded no results";
publicconststringMoreThanOneElement="Sequence contains more than one element";
publicconststringMoreThanOneMatch="Sequence contains more than one matching element";
publicconststringNoElements="Sequence contains no elements";
publicconststringNoMatch="Sequence contains no matching element";
publicconststringParallelPartitionable_NullReturn="The return value must not be null.";
publicconststringParallelPartitionable_IncorretElementCount="The returned array's length must equal the number of partitions requested.";
publicconststringParallelPartitionable_NullElement="Elements returned must not be null.";
publicconststringPLINQ_CommonEnumerator_Current_NotStarted="Enumeration has not started. MoveNext must be called to initiate enumeration.";
publicconststringPLINQ_ExternalCancellationRequested="The query has been canceled via the token supplied to WithCancellation.";
publicconststringPLINQ_DisposeRequested="The query enumerator has been disposed.";
publicconststringParallelQuery_DuplicateTaskScheduler="The WithTaskScheduler operator may be used at most once in a query.";
publicconststringParallelQuery_DuplicateDOP="The WithDegreeOfParallelism operator may be used at most once in a query.";
publicconststringParallelQuery_DuplicateExecutionMode="The WithExecutionMode operator may be used at most once in a query.";
publicconststringPartitionerQueryOperator_NullPartitionList="Partitioner returned null instead of a list of partitions.";
publicconststringPartitionerQueryOperator_WrongNumberOfPartitions="Partitioner returned a wrong number of partitions.";
publicconststringPartitionerQueryOperator_NullPartition="Partitioner returned a null partition.";
publicconststringParallelQuery_DuplicateWithCancellation="The WithCancellation operator may by used at most once in a query.";
publicconststringParallelQuery_DuplicateMergeOptions="The WithMergeOptions operator may be used at most once in a query.";
publicconststringPLINQ_EnumerationPreviouslyFailed="The query enumerator previously threw an exception.";
publicconststringParallelQuery_PartitionerNotOrderable="AsOrdered may not be used with a partitioner that is not orderable.";
publicconststringParallelQuery_InvalidAsOrderedCall="AsOrdered may only be called on the result of AsParallel, ParallelEnumerable.Range, or ParallelEnumerable.Repeat.";
publicconststringParallelQuery_InvalidNonGenericAsOrderedCall="Non-generic AsOrdered may only be called on the result of the non-generic AsParallel.";
publicconststringParallelEnumerable_BinaryOpMustUseAsParallel="The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.";
publicconststringParallelEnumerable_WithQueryExecutionMode_InvalidMode="The executionMode argument contains an invalid value.";
publicconststringParallelEnumerable_WithMergeOptions_InvalidOptions="The mergeOptions argument contains an invalid value.";
publicconststringArgumentNotIEnumerableGeneric="{0} is not IEnumerable<>";
publicconststringArgumentNotValid="Argument {0} is not valid";
publicconststringNoMethodOnType="There is no method '{0}' on type '{1}'";
publicconststringNoMethodOnTypeMatchingArguments="There is no method '{0}' on type '{1}' that matches the specified arguments";
publicconststringEnumeratingNullEnumerableExpression="Cannot enumerate a query created from a null IEnumerable<>";
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_NeedNonemptyPipeName="pipeName cannot be an empty string.";
publicconststringArgument_NonContainerInvalidAnyFlag="This flag may not be set on a pipe.";
publicconststringArgument_EmptyServerName="serverName cannot be an empty string. Use \\\\\\\".\\\\\\\" for current machine.";
publicconststringArgumentNull_Buffer="Buffer cannot be null.";
publicconststringArgumentNull_ServerName="serverName cannot be null. Use \\\".\\\" for current machine.";
publicconststringArgumentOutOfRange_AnonymousReserved="The pipeName \\\"anonymous\\\" is reserved.";
publicconststringArgumentOutOfRange_TransmissionModeByteOrMsg="For named pipes, transmission mode can be TransmissionMode.Byte or PipeTransmissionMode.Message. For anonymous pipes, transmission mode can be TransmissionMode.Byte.";
publicconststringArgumentOutOfRange_DirectionModeInOutOrInOut="For named pipes, the pipe direction can be PipeDirection.In, PipeDirection.Out or PipeDirection.InOut. For anonymous pipes, the pipe direction can be PipeDirection.In or PipeDirection.Out.";
publicconststringArgumentOutOfRange_ImpersonationInvalid="TokenImpersonationLevel.None, TokenImpersonationLevel.Anonymous, TokenImpersonationLevel.Identification, TokenImpersonationLevel.Impersonation or TokenImpersonationLevel.Delegation required.";
publicconststringArgumentOutOfRange_OptionsInvalid="options contains an invalid flag.";
publicconststringArgumentOutOfRange_HandleInheritabilityNoneOrInheritable="HandleInheritability.None or HandleInheritability.Inheritable required.";
publicconststringArgumentOutOfRange_InvalidTimeout="Timeout must be non-negative or equal to -1 (Timeout.Infinite)";
publicconststringArgumentOutOfRange_MaxNumServerInstances="maxNumberOfServerInstances must either be a value between 1 and 254, or NamedPipeServerStream.MaxAllowedServerInstances (to obtain the maximum number allowed by system resources).";
publicconststringArgumentOutOfRange_NeedPosNum="Positive number required.";
publicconststringInvalidOperation_PipeNotYetConnected="Pipe hasn't been connected yet.";
publicconststringInvalidOperation_PipeDisconnected="Pipe is in a disconnected state.";
publicconststringInvalidOperation_PipeHandleNotSet="Pipe handle has not been set. Did your PipeStream implementation call InitializeHandle?";
publicconststringInvalidOperation_PipeNotAsync="Pipe is not opened in asynchronous mode.";
publicconststringInvalidOperation_PipeReadModeNotMessage="ReadMode is not of PipeTransmissionMode.Message.";
publicconststringInvalidOperation_PipeAlreadyConnected="Already in a connected state.";
publicconststringInvalidOperation_PipeAlreadyDisconnected="Already in a disconnected state.";
publicconststringIO_EOF_ReadBeyondEOF="Unable to read beyond the end of the stream.";
publicconststringIO_FileNotFound="Unable to find the specified file.";
publicconststringIO_FileNotFound_FileName="Could not find file '{0}'.";
publicconststringIO_AlreadyExists_Name="Cannot create \\\"{0}\\\" because a file or directory with the same name already exists.";
publicconststringIO_PathNotFound_Path="Could not find a part of the path '{0}'.";
publicconststringIO_PathNotFound_NoPathName="Could not find a part of the path.";
publicconststringIO_PathTooLong="The specified file name or path is too long, or a component of the specified path is too long.";
publicconststringNotSupported_UnreadableStream="Stream does not support reading.";
publicconststringNotSupported_UnseekableStream="Stream does not support seeking.";
publicconststringNotSupported_UnwritableStream="Stream does not support writing.";
publicconststringNotSupported_AnonymousPipeUnidirectional="Anonymous pipes can only be in one direction.";
publicconststringNotSupported_AnonymousPipeMessagesNotSupported="Anonymous pipes do not support PipeTransmissionMode.Message ReadMode.";
publicconststringObjectDisposed_PipeClosed="Cannot access a closed pipe.";
publicconststringUnauthorizedAccess_IODenied_Path="Access to the path '{0}' is denied.";
publicconststringUnauthorizedAccess_IODenied_NoPathName="Access to the path is denied.";
publicconststringArgumentOutOfRange_FileLengthTooBig="Specified file length was too large for the file system.";
publicconststringPlatformNotSupported_MessageTransmissionMode="Message transmission mode is not supported on this platform.";
publicconststringPlatformNotSupported_RemotePipes="Access to remote named pipes is not supported on this platform.";
publicconststringPlatformNotSupported_InvalidPipeNameChars="The name of a pipe on this platform must be a valid file name or a valid absolute path to a file name.";
publicconststringObjectDisposed_StreamClosed="Cannot access a closed Stream.";
publicconststringPlatformNotSupported_OperatingSystemError="The operating system returned error '{0}' indicating that the operation is not supported.";
publicconststringIO_AllPipeInstancesAreBusy="All pipe instances are busy.";
publicconststringIO_PathTooLong_Path="The path '{0}' is too long, or a component of the specified path is too long.";
publicconststringUnauthorizedAccess_NotOwnedByCurrentUser="Could not connect to the pipe because it was not owned by the current user.";
publicconststringUnauthorizedAccess_ClientIsNotCurrentUser="Client connection (user id {0}) was refused because it was not owned by the current user (id {1}).";
publicconststringnet_invalidversion="This protocol version is not supported.";
publicconststringnet_noseek="This stream does not support seek operations.";
publicconststringnet_invasync="Cannot block a call on this socket while an earlier asynchronous call is in progress.";
publicconststringnet_io_timeout_use_gt_zero="Timeout can be only be set to 'System.Threading.Timeout.Infinite' or a value > 0.";
publicconststringnet_notconnected="The operation is not allowed on non-connected sockets.";
publicconststringnet_notstream="The operation is not allowed on non-stream oriented sockets.";
publicconststringnet_stopped="Not listening. You must call the Start() method before calling this method.";
publicconststringnet_udpconnected="Cannot send packets to an arbitrary host while connected.";
publicconststringnet_readonlystream="The stream does not support writing.";
publicconststringnet_writeonlystream="The stream does not support reading.";
publicconststringnet_InvalidAddressFamily="The AddressFamily {0} is not valid for the {1} end point, use {2} instead.";
publicconststringnet_InvalidEndPointAddressFamily="The supplied EndPoint of AddressFamily {0} is not valid for this Socket, use {1} instead.";
publicconststringnet_InvalidSocketAddressSize="The supplied {0} is an invalid size for the {1} end point.";
publicconststringnet_invalidAddressList="None of the discovered or specified addresses match the socket address family.";
publicconststringnet_completed_result="This operation cannot be performed on a completed asynchronous result object.";
publicconststringnet_protocol_invalid_family="'{0}' Client can only accept InterNetwork or InterNetworkV6 addresses.";
publicconststringnet_protocol_invalid_multicast_family="Multicast family is not the same as the family of the '{0}' Client.";
publicconststringnet_sockets_zerolist="The parameter {0} must contain one or more elements.";
publicconststringnet_sockets_blocking="The operation is not allowed on a non-blocking Socket.";
publicconststringnet_sockets_useblocking="Use the Blocking property to change the status of the Socket.";
publicconststringnet_sockets_select="The operation is not allowed on objects of type {0}. Use only objects of type {1}.";
publicconststringnet_sockets_toolarge_select="The {0} list contains too many items; a maximum of {1} is allowed.";
publicconststringnet_sockets_empty_select="All lists are either null or empty.";
publicconststringnet_sockets_mustbind="You must call the Bind method before performing this operation.";
publicconststringnet_sockets_mustlisten="You must call the Listen method before performing this operation.";
publicconststringnet_sockets_mustnotlisten="You may not perform this operation after calling the Listen method.";
publicconststringnet_sockets_mustnotbebound="The socket must not be bound or connected.";
publicconststringnet_sockets_namedmustnotbebound="{0}: The socket must not be bound or connected.";
publicconststringnet_sockets_invalid_ipaddress_length="The number of specified IP addresses has to be greater than 0.";
publicconststringnet_sockets_invalid_optionValue="The specified value is not a valid '{0}'.";
publicconststringnet_sockets_invalid_optionValue_all="The specified value is not valid.";
publicconststringnet_sockets_invalid_dnsendpoint="The parameter {0} must not be of type DnsEndPoint.";
publicconststringnet_sockets_disconnectedConnect="Once the socket has been disconnected, you can only reconnect again asynchronously, and only to a different EndPoint. BeginConnect must be called on a thread that won't exit until the operation has been completed.";
publicconststringnet_sockets_disconnectedAccept="Once the socket has been disconnected, you can only accept again asynchronously. BeginAccept must be called on a thread that won't exit until the operation has been completed.";
publicconststringnet_tcplistener_mustbestopped="The TcpListener must not be listening before performing this operation.";
publicconststringnet_socketopinprogress="An asynchronous socket operation is already in progress using this SocketAsyncEventArgs instance.";
publicconststringnet_buffercounttoosmall="The Buffer space specified by the Count property is insufficient for the AcceptAsync method.";
publicconststringnet_multibuffernotsupported="Multiple buffers cannot be used with this method.";
publicconststringnet_ambiguousbuffers="Buffer and BufferList properties cannot both be non-null.";
publicconststringnet_io_writefailure="Unable to write data to the transport connection: {0}.";
publicconststringnet_io_readfailure="Unable to read data from the transport connection: {0}.";
publicconststringnet_io_invalidasyncresult="The IAsyncResult object was not returned from the corresponding asynchronous method on this class.";
publicconststringnet_io_invalidendcall="{0} can only be called once for each asynchronous operation.";
publicconststringnet_value_cannot_be_negative="The specified value cannot be negative.";
publicconststringArgumentOutOfRange_Bounds_Lower_Upper="Argument must be between {0} and {1}.";
publicconststringnet_sockets_connect_multiconnect_notsupported="Sockets on this platform are invalid for use after a failed connection attempt.";
publicconststringnet_sockets_dualmode_receivefrom_notsupported="This platform does not support packet information for dual-mode sockets. If packet information is not required, use Socket.Receive. If packet information is required set Socket.DualMode to false.";
publicconststringnet_sockets_accept_receive_notsupported="This platform does not support receiving data with Socket.AcceptAsync. Instead, make a separate call to Socket.ReceiveAsync.";
publicconststringnet_sockets_duplicateandclose_notsupported="This platform does not support Socket.DuplicateAndClose. Instead, create a new socket.";
publicconststringnet_sockets_transmitfileoptions_notsupported="This platform does not support TransmitFileOptions other than TransmitFileOptions.UseDefaultWorkerThread.";
publicconststringArgumentOutOfRange_PathLengthInvalid="The path '{0}' is of an invalid length for use with domain sockets on this platform. The length must be between 1 and {1} characters, inclusive.";
publicconststringnet_io_readwritefailure="Unable to transfer data on the transport connection: {0}.";
publicconststringPlatformNotSupported_AcceptSocket="Accepting into an existing Socket is not supported on this platform.";
publicconststringPlatformNotSupported_IOControl="Socket.IOControl handles Windows-specific control codes and is not supported on this platform.";
publicconststringPlatformNotSupported_IPProtectionLevel="IP protection level cannot be controlled on this platform.";
publicconststringInvalidOperation_BufferNotExplicitArray="This operation may only be performed when the buffer was set using the SetBuffer overload that accepts an array.";
publicconststringInvalidOperation_IncorrectToken="The result of the operation was already consumed and may not be used again.";
publicconststringInvalidOperation_MultipleContinuations="Another continuation was already registered.";
publicconststringArgument_InvalidOidValue="The OID value was invalid.";
publicconststringArgument_InvalidValue="Value was invalid.";
publicconststringArg_CryptographyException="Error occurred during a cryptographic operation.";
publicconststringCryptography_ArgECDHKeySizeMismatch="The keys from both parties must be the same size to generate a secret agreement.";
publicconststringCryptography_ArgECDHRequiresECDHKey="Keys used with the ECDiffieHellmanCng algorithm must have an algorithm group of ECDiffieHellman.";
publicconststringCryptography_TlsRequiresLabelAndSeed="The TLS key derivation function requires both the label and seed properties to be set.";
publicconststringCryptography_TlsRequires64ByteSeed="The TLS key derivation function requires a seed value of exactly 64 bytes.";
publicconststringCryptography_BadHashSize_ForAlgorithm="The provided value of {0} bytes does not match the expected size of {1} bytes for the algorithm ({2}).";
publicconststringCryptography_Config_EncodedOIDError="Encoded OID length is too large (greater than 0x7f bytes).";
publicconststringCryptography_CSP_NoPrivateKey="Object contains only the public half of a key pair. A private key must also be provided.";
publicconststringCryptography_DSA_KeyGenNotSupported="DSA keys can be imported, but new key generation is not supported on this platform.";
publicconststringCryptography_Encryption_MessageTooLong="The message exceeds the maximum allowable length for the chosen options ({0}).";
publicconststringCryptography_ECXmlSerializationFormatRequired="XML serialization of an elliptic curve key requires using an overload which specifies the XML format to be used.";
publicconststringCryptography_ECC_NamedCurvesOnly="Only named curves are supported on this platform.";
publicconststringCryptography_HashAlgorithmNameNullOrEmpty="The hash algorithm name cannot be null or empty.";
publicconststringCryptography_InvalidOID="Object identifier (OID) is unknown.";
publicconststringCryptography_CurveNotSupported="The specified curve '{0}' or its parameters are not valid for this platform.";
publicconststringCryptography_InvalidCurveOid="The specified Oid is not valid. The Oid.FriendlyName or Oid.Value property must be set.";
publicconststringCryptography_InvalidCurveKeyParameters="The specified key parameters are not valid. Q.X and Q.Y are required fields. Q.X, Q.Y must be the same length. If D is specified it must be the same length as Q.X and Q.Y for named curves or the same length as Order for explicit curves.";
publicconststringCryptography_InvalidDsaParameters_MissingFields="The specified DSA parameters are not valid; P, Q, G and Y are all required.";
publicconststringCryptography_InvalidDsaParameters_MismatchedPGY="The specified DSA parameters are not valid; P, G and Y must be the same length (the key size).";
publicconststringCryptography_InvalidDsaParameters_MismatchedQX="The specified DSA parameters are not valid; Q and X (if present) must be the same length.";
publicconststringCryptography_InvalidDsaParameters_MismatchedPJ="The specified DSA parameters are not valid; J (if present) must be shorter than P.";
publicconststringCryptography_InvalidDsaParameters_SeedRestriction_ShortKey="The specified DSA parameters are not valid; Seed, if present, must be 20 bytes long for keys shorter than 1024 bits.";
publicconststringCryptography_InvalidDsaParameters_QRestriction_ShortKey="The specified DSA parameters are not valid; Q must be 20 bytes long for keys shorter than 1024 bits.";
publicconststringCryptography_InvalidDsaParameters_QRestriction_LargeKey="The specified DSA parameters are not valid; Q's length must be one of 20, 32 or 64 bytes.";
publicconststringCryptography_InvalidECCharacteristic2Curve="The specified Characteristic2 curve parameters are not valid. Polynomial, A, B, G.X, G.Y, and Order are required. A, B, G.X, G.Y must be the same length, and the same length as Q.X, Q.Y and D if those are specified. Seed, Cofactor and Hash are optional. Other parameters are not allowed.";
publicconststringCryptography_InvalidECPrimeCurve="The specified prime curve parameters are not valid. Prime, A, B, G.X, G.Y and Order are required and must be the same length, and the same length as Q.X, Q.Y and D if those are specified. Seed, Cofactor and Hash are optional. Other parameters are not allowed.";
publicconststringCryptography_InvalidECNamedCurve="The specified named curve parameters are not valid. Only the Oid parameter must be set.";
publicconststringCryptography_InvalidKeySize="Specified key is not a valid size for this algorithm.";
publicconststringCryptography_InvalidKey_SemiWeak="Specified key is a known semi-weak key for '{0}' and cannot be used.";
publicconststringCryptography_InvalidKey_Weak="Specified key is a known weak key for '{0}' and cannot be used.";
publicconststringCryptography_InvalidIVSize="Specified initialization vector (IV) does not match the block size for this algorithm.";
publicconststringCryptography_InvalidOperation="This operation is not supported for this class.";
publicconststringCryptography_InvalidPadding="Padding is invalid and cannot be removed.";
publicconststringCryptography_InvalidRsaParameters="The specified RSA parameters are not valid; both Exponent and Modulus are required fields.";
publicconststringCryptography_InvalidPaddingMode="Specified padding mode is not valid for this algorithm.";
publicconststringCryptography_Invalid_IA5String="The string contains a character not in the 7 bit ASCII character set.";
publicconststringCryptography_KeyTooSmall="The key is too small for the requested operation.";
publicconststringCryptography_MissingIV="The cipher mode specified requires that an initialization vector (IV) be used.";
publicconststringCryptography_MissingKey="No asymmetric key object has been associated with this formatter object.";
publicconststringCryptography_MissingOID="Required object identifier (OID) cannot be found.";
publicconststringCryptography_MustTransformWholeBlock="TransformBlock may only process bytes in block sized increments.";
publicconststringCryptography_NotValidPrivateKey="Key is not a valid private key.";
publicconststringCryptography_NotValidPublicOrPrivateKey="Key is not a valid public or private key.";
publicconststringCryptography_OAEP_Decryption_Failed="Error occurred while decoding OAEP padding.";
publicconststringCryptography_OpenInvalidHandle="Cannot open an invalid handle.";
publicconststringCryptography_PartialBlock="The input data is not a complete block.";
publicconststringCryptography_PasswordDerivedBytes_FewBytesSalt="Salt is not at least eight bytes.";
publicconststringCryptography_RC2_EKS40="EffectiveKeySize value must be at least 40 bits.";
publicconststringCryptography_RC2_EKSKS="KeySize value must be at least as large as the EffectiveKeySize value.";
publicconststringCryptography_RC2_EKSKS2="EffectiveKeySize must be the same as KeySize in this implementation.";
publicconststringCryptography_Rijndael_BlockSize="BlockSize must be 128 in this implementation.";
publicconststringCryptography_RSA_DecryptWrongSize="The length of the data to decrypt is not valid for the size of this key.";
publicconststringCryptography_SignHash_WrongSize="The provided hash value is not the expected size for the specified hash algorithm.";
publicconststringCryptography_TransformBeyondEndOfBuffer="Attempt to transform beyond end of buffer.";
publicconststringCryptography_CipherModeNotSupported="The specified CipherMode '{0}' is not supported.";
publicconststringCryptography_UnknownHashAlgorithm="'{0}' is not a known hash algorithm.";
publicconststringCryptography_UnexpectedTransformTruncation="CNG provider unexpectedly terminated encryption or decryption prematurely.";
publicconststringCryptography_Unmapped_System_Typed_Error="The system cryptographic library returned error '{0}' of type '{1}'";
publicconststringCryptography_UnsupportedPaddingMode="The specified PaddingMode is not supported.";
publicconststringNotSupported_Method="Method not supported.";
publicconststringNotSupported_SubclassOverride="Method not supported. Derived class must override.";
publicconststringCryptography_AlgorithmTypesMustBeVisible="Algorithms added to CryptoConfig must be accessable from outside their assembly.";
publicconststringCryptography_AddNullOrEmptyName="CryptoConfig cannot add a mapping for a null or empty name.";
publicconststringArgument_Invalid_SafeHandleInvalidOrClosed="The method cannot be called with an invalid or closed SafeHandle.";
publicconststringCryptography_ArgExpectedECDiffieHellmanCngPublicKey="DeriveKeyMaterial requires an ECDiffieHellmanCngPublicKey.";
publicconststringCryptography_ArgDSARequiresDSAKey="Keys used with the DSACng algorithm must have an algorithm group of DSA.";
publicconststringCryptography_ArgECDsaRequiresECDsaKey="Keys used with the ECDsaCng algorithm must have an algorithm group of ECDsa.";
publicconststringCryptography_ArgRSARequiresRSAKey="Keys used with the RSACng algorithm must have an algorithm group of RSA.";
publicconststringCryptography_CngKeyWrongAlgorithm="This key is for algorithm '{0}'. Expected '{1}'.";
publicconststringCryptography_InvalidAlgorithmGroup="The algorithm group '{0}' is invalid.";
publicconststringCryptography_InvalidAlgorithmName="The algorithm name '{0}' is invalid.";
publicconststringCryptography_InvalidCipherMode="Specified cipher mode is not valid for this algorithm.";
publicconststringCryptography_InvalidKeyBlobFormat="The key blob format '{0}' is invalid.";
publicconststringCryptography_InvalidProviderName="The provider name '{0}' is invalid.";
publicconststringCryptography_KeyBlobParsingError="Key Blob not in expected format.";
publicconststringCryptography_OpenEphemeralKeyHandleWithoutEphemeralFlag="The CNG key handle being opened was detected to be ephemeral, but the EphemeralKey open option was not specified.";
publicconststringCryptography_WeakKey="Specified key is a known weak key for this algorithm and cannot be used.";
publicconststringPlatformNotSupported_CryptographyCng="Windows Cryptography Next Generation (CNG) is not supported on this platform.";
publicconststringCountdownEvent_Increment_AlreadyZero="The event is already signaled and cannot be incremented.";
publicconststringCountdownEvent_Increment_AlreadyMax="The increment operation would cause the CurrentCount to overflow.";
publicconststringCountdownEvent_Decrement_BelowZero="Invalid attempt made to decrement the event's count below zero.";
publicconststringCommon_OperationCanceled="The operation was canceled.";
publicconststringBarrier_Dispose="The barrier has been disposed.";
publicconststringBarrier_SignalAndWait_InvalidOperation_ZeroTotal="The barrier has no registered participants.";
publicconststringBarrier_SignalAndWait_ArgumentOutOfRange="The specified timeout must represent a value between -1 and Int32.MaxValue, inclusive.";
publicconststringBarrier_RemoveParticipants_InvalidOperation="The participantCount argument is greater than the number of participants that haven't yet arrived at the barrier in this phase.";
publicconststringBarrier_RemoveParticipants_ArgumentOutOfRange="The participantCount argument must be less than or equal the number of participants.";
publicconststringBarrier_RemoveParticipants_NonPositive_ArgumentOutOfRange="The participantCount argument must be a positive value.";
publicconststringBarrier_InvalidOperation_CalledFromPHA="This method may not be called from within the postPhaseAction.";
publicconststringBarrier_AddParticipants_NonPositive_ArgumentOutOfRange="The participantCount argument must be a positive value.";
publicconststringBarrier_SignalAndWait_InvalidOperation_ThreadsExceeded="The number of threads using the barrier exceeded the total number of registered participants.";
publicconststringBarrierPostPhaseException="The postPhaseAction failed with an exception.";
publicconststringBarrier_ctor_ArgumentOutOfRange="The participantCount argument must be non-negative and less than or equal to 32767.";
publicconststringBarrier_AddParticipants_Overflow_ArgumentOutOfRange="Adding participantCount participants would result in the number of participants exceeding the maximum number allowed.";
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.";
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.";
publicconststringOverflow_UInt16="Value was either too large or too small for a UInt16.";
publicconststringReaderWriterLock_Timeout="The operation has timed out. {0}";
publicconststringArgumentOutOfRange_TimeoutMilliseconds="Timeout value in milliseconds must be nonnegative and less than or equal to Int32.MaxValue, or -1 for an infinite timeout.";
publicconststringReaderWriterLock_NotOwner="Attempt to release a lock that is not owned by the calling thread. {0}";
publicconststringExceptionFromHResult="(Exception from HRESULT: 0x{0:X})";
publicconststringReaderWriterLock_InvalidLockCookie="The specified lock cookie is invalid for this operation. {0}";
publicconststringReaderWriterLock_RestoreLockWithOwnedLocks="ReaderWriterLock.RestoreLock was called without releasing all locks acquired since the call to ReleaseLock.";
publicconststringHostExecutionContextManager_InvalidOperation_NotNewCaptureContext="Cannot apply a context that has been marshaled across AppDomains, that was not acquired through a Capture operation or that has already been the argument to a Set call.";
publicconststringHostExecutionContextManager_InvalidOperation_CannotOverrideSetWithoutRevert="Must override both HostExecutionContextManager.SetHostExecutionContext and HostExecutionContextManager.Revert.";
publicconststringHostExecutionContextManager_InvalidOperation_CannotUseSwitcherOtherThread="Undo operation must be performed on the thread where the corresponding context was Set.";
publicconststringArg_NonZeroLowerBound="The lower bound of target array must be zero.";
publicconststringArg_WrongType="The value '{0}' is not of type '{1}' and cannot be used in this generic collection.";
publicconststringArg_ArrayPlusOffTooSmall="Destination array is not long enough to copy all the items in the collection. Check array index and length.";
publicconststringArgumentOutOfRange_SmallCapacity="capacity was less than the current size.";
publicconststringArgument_AddingDuplicate="An item with the same key has already been added. Key: {0}";
publicconststringInvalidOperation_ConcurrentOperationsNotSupported="Operations that change non-concurrent collections must have exclusive access. A concurrent update was performed on this collection and corrupted its state. The collection's state is no longer correct.";
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.";
publicconststringArg_ArrayLengthsDiffer="Array lengths must be the same.";
publicconststringArg_BitArrayTypeUnsupported="Only supported array types for CopyTo on BitArrays are Boolean[], Int32[] and Byte[].";
publicconststringArg_HSCapacityOverflow="HashSet capacity is too big.";
publicconststringArg_HTCapacityOverflow="Hashtable's capacity overflowed and went negative. Check load factor, capacity and the current size of the table.";
publicconststringArg_InsufficientSpace="Insufficient space in the target location to copy the information.";
publicconststringArg_RankMultiDimNotSupported="Only single dimensional arrays are supported for the requested action.";
publicconststringArgument_ArrayTooLarge="The input array length must not exceed Int32.MaxValue / {0}. Otherwise BitArray.Length would exceed Int32.MaxValue.";
publicconststringArgument_InvalidArrayType="Target array type is not compatible with the type of items in the collection.";
publicconststringArgumentOutOfRange_BiggerThanCollection="Must be less than or equal to the size of the collection.";
publicconststringArgumentOutOfRange_Index="Index was out of range. Must be non-negative and less than the size of the collection.";
publicconststringExternalLinkedListNode="The LinkedList node does not belong to current LinkedList.";
publicconststringLinkedListEmpty="The LinkedList is empty.";
publicconststringLinkedListNodeIsAttached="The LinkedList node already belongs to a LinkedList.";
publicconststringNotSupported_SortedListNestedWrite="This operation is not supported on SortedList nested types because they require modifying the original SortedList.";
publicconststringSortedSet_LowerValueGreaterThanUpperValue="Must be less than or equal to upperValue.";
publicconststringSerialization_InvalidOnDeser="OnDeserialization method was called while the object was not being deserialized.";
publicconststringSerialization_MismatchedCount="The serialized Count information doesn't match the number of items.";
publicconststringSerialization_MissingKeys="The keys for this dictionary are missing.";
publicconststringSerialization_MissingValues="The values for this dictionary are missing.";
publicconststringArgument_MapNameEmptyString="Map name cannot be an empty string.";
publicconststringArgument_EmptyFile="A positive capacity must be specified for a Memory Mapped File backed by an empty file.";
publicconststringArgument_NewMMFWriteAccessNotAllowed="MemoryMappedFileAccess.Write is not permitted when creating new memory mapped files. Use MemoryMappedFileAccess.ReadWrite instead.";
publicconststringArgument_ReadAccessWithLargeCapacity="When specifying MemoryMappedFileAccess.Read access, the capacity must not be larger than the file size.";
publicconststringArgument_NewMMFAppendModeNotAllowed="FileMode.Append is not permitted when creating new memory mapped files. Instead, use MemoryMappedFileView to ensure write-only access within a specified region.";
publicconststringArgument_NewMMFTruncateModeNotAllowed="FileMode.Truncate is not permitted when creating new memory mapped files.";
publicconststringArgumentNull_MapName="Map name cannot be null.";
publicconststringArgumentNull_FileStream="fileStream cannot be null.";
publicconststringArgumentOutOfRange_CapacityLargerThanLogicalAddressSpaceNotAllowed="The capacity cannot be greater than the size of the system's logical address space.";
publicconststringArgumentOutOfRange_NeedPositiveNumber="A positive number is required.";
publicconststringArgumentOutOfRange_PositiveOrDefaultCapacityRequired="The capacity must be greater than or equal to 0. 0 represents the size of the file being mapped.";
publicconststringArgumentOutOfRange_PositiveOrDefaultSizeRequired="The size must be greater than or equal to 0. If 0 is specified, the view extends from the specified offset to the end of the file mapping.";
publicconststringArgumentOutOfRange_CapacityGEFileSizeRequired="The capacity may not be smaller than the file size.";
publicconststringIO_NotEnoughMemory="Not enough memory to map view.";