SRP

Extensions\XmlReaderExtensions.cs (4)

16throw new XmlException(SRP.Format(SRP.Xml_InvalidNodeType, reader.NodeType.ToString()), null, lineInfo?.LineNumber ?? 0, lineInfo?.LinePosition ?? 0); 27throw new XmlException(SRP.Format(SRP.Xml_InvalidNodeType, reader.NodeType.ToString()), null, lineInfo?.LineNumber ?? 0, lineInfo?.LinePosition ?? 0);

Internals\System\Runtime\Remoting\SoapHexBinary.cs (4)

51throw new FormatException(SRP.Format(SRP.Remoting_SOAPInteropxsdInvalid, "xsd:hexBinary", value)); 73throw new FormatException(SRP.Format(SRP.Remoting_SOAPInteropxsdInvalid, "xsd:hexBinary", value));

Internals\System\Runtime\TimeoutHelper.cs (2)

239return new TimeoutException(SRP.Format(SRP.LockTimeoutExceptionMessage, timeout));

Internals\System\Text\BinHexEncoding.cs (29)

Internals\System\Xml\XmlExceptionHelper.cs (4)

24string s = SRP.Format(res, arg1, arg2, arg3); 28s += " " + SRP.Format(SRP.XmlLineInfo, lineInfo.LineNumber, lineInfo.LinePosition); 36ThrowXmlException(reader, SRP.XmlMaxStringContentLengthExceeded, maxStringContentLength.ToString(NumberFormatInfo.CurrentInfo));

Internals\System\Xml\XmlMtomReader.cs (153)

Internals\System\Xml\XmlMtomWriter.cs (33)

SMDiagnostics\System\ServiceModel\Diagnostics\ExceptionUtility.cs (2)

34return (ArgumentException)ThrowHelperError(new ArgumentException(SRP.StringNullOrEmpty, arg)); 59return ThrowHelperCallback(SRP.GenericCallbackException, innerException);

System\IdentityModel\Claims\Claim.cs (2)

60throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("claimType", SRP.ArgumentCannotBeEmptyString); 70throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("right", SRP.ArgumentCannotBeEmptyString);

System\IdentityModel\CryptoHelper.cs (8)

72throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SRP.Format(SRP.CustomCryptoAlgorithmIsNotValidKeyedHashAlgorithm, algorithm))); 84throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SRP.Format(SRP.UnsupportedCryptoAlgorithm, algorithm))); 189throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SRP.Format(SRP.CustomCryptoAlgorithmIsNotValidHashAlgorithm, algorithm))); 205throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SRP.Format(SRP.UnsupportedCryptoAlgorithm, algorithm)));

System\IdentityModel\Psha1DerivedKeyGenerator.cs (3)

68throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(derivedKeySize), SRP.ValueMustBeNonNegative)); 72throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(position), SRP.Format(SRP.ValueMustBeInRange, 0, _position)));

System\IdentityModel\Selectors\KerberosSecurityTokenProvider.cs (2)

34SRP.Format(SRP.ImpersonationLevelNotSupported, tokenImpersonationLevel)));

System\IdentityModel\Selectors\SecurityTokenAuthenticator.cs (4)

36throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenValidationException(SRP.Format(SRP.CannotValidateSecurityTokenType, this, token.GetType()))); 52string errorMsg = SRP.Format(SRP.CannotValidateSecurityTokenType, this, token.GetType());

System\IdentityModel\Selectors\SecurityTokenProvider.cs (16)

33throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SRP.Format(SRP.TokenProviderUnableToGetToken, this))); 54throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SRP.Format(SRP.TokenProviderUnableToGetToken, this))); 65throw Fx.Exception.AsError(new SecurityTokenException(SRP.Format(SRP.TokenProviderUnableToGetToken, this))); 108throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SRP.Format(SRP.TokenProviderUnableToRenewToken, this))); 134throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SRP.Format(SRP.TokenProviderUnableToRenewToken, this))); 150throw Fx.Exception.AsError(new SecurityTokenException(SRP.Format(SRP.TokenProviderUnableToRenewToken, this))); 158throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.TokenRenewalNotSupported, this))); 225throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.TokenCancellationNotSupported, this)));

System\IdentityModel\Selectors\SecurityTokenRequirement.cs (3)

123throw Fx.Exception.ArgumentOutOfRange("value", value, SRP.ValueMustBeNonNegative); 151throw Fx.Exception.Argument(propertyName, string.Format(SRP.SecurityTokenRequirementDoesNotContainProperty, propertyName)); 166throw Fx.Exception.Argument(propertyName, string.Format(SRP.SecurityTokenRequirementHasInvalidTypeForProperty, propertyName, dictionaryValue.GetType(), typeof(TValue)));

System\IdentityModel\Selectors\SecurityTokenResolver.cs (6)

23throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SRP.Format(SRP.UnableToResolveTokenReference, keyIdentifier))); 46throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SRP.Format(SRP.UnableToResolveTokenReference, keyIdentifierClause))); 69throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SRP.Format(SRP.UnableToResolveKeyReference, keyIdentifierClause)));

System\IdentityModel\Selectors\X509CertificateValidator.cs (8)

158exception = new SecurityTokenValidationException(SRP.Format(SRP.X509InvalidUsageTime, 165exception = new SecurityTokenValidationException(SRP.Format(SRP.X509IsNotInTrustedStore, 172exception = new SecurityTokenValidationException(SRP.Format(SRP.X509IsInUntrustedStore, 218throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenValidationException(SRP.Format(SRP.X509ChainBuildFail,

System\IdentityModel\SignatureResourcePool.cs (2)

22throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(algorithm, SRP.Format(SRP.EmptyOrNullArgumentString, nameof(algorithm)));

System\IdentityModel\Tokens\BinaryKeyIdentifierClause.cs (2)

28throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(identificationData), SRP.LengthMustBeGreaterThanZero)); 66throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(offset), SRP.ValueMustBeNonNegative));

System\IdentityModel\Tokens\GenericXmlSecurityToken.cs (1)

167throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SRP.UnableToCreateTokenReference));

System\IdentityModel\Tokens\KerberosRequestorSecurityToken.cs (3)

24SRP.Format(SRP.ImpersonationLevelNotSupported, tokenImpersonationLevel))); 32throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.ProvidedNetworkCredentialsForKerberosHasInvalidUserName);

System\IdentityModel\Tokens\KeyInfoSerializer.cs (17)

System\IdentityModel\Tokens\LocalIdKeyIdentifierClause.cs (1)

44throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.LocalIdCannotBeEmpty);

System\IdentityModel\Tokens\SecurityKeyIdentifier.cs (4)

68throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly)); 86throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.KeyIdentifierCannotCreateKey)); 94throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.NoKeyIdentifierClauseFound, typeof(TClause)), "TClause"));

System\IdentityModel\Tokens\SecurityKeyIdentifierClause.cs (1)

48throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.KeyIdentifierClauseDoesNotSupportKeyCreation));

System\IdentityModel\Tokens\SecurityToken.cs (2)

31SRP.Format(SRP.TokenDoesNotSupportKeyIdentifierClauseCreation, GetType().Name, typeof(T).Name)));

System\IdentityModel\Tokens\SymmetricKey.cs (2)

29throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.SymmetricKeyLengthTooShort, symmetricKey.Length)));

System\IdentityModel\Tokens\UserNameSecurityToken.cs (1)

31throw Fx.Exception.Argument(nameof(userName), SRP.UserNameCannotBeEmpty);

System\IdentityModel\Tokens\WSSecurityJan2004.cs (5)

210throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.CannotReadKeyIdentifierClause, reader.LocalName, reader.NamespaceURI))); 247throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.StandardsManagerCannotWriteObject, keyIdentifierClause.GetType()))); 310throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityMessageSerializationException(SRP.UnknownEncodingInKeyIdentifier));

System\IdentityModel\Tokens\WSSecurityXXX2005.cs (2)

71throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.StandardsManagerCannotWriteObject, keyIdentifierClause.GetType())));

System\IdentityModel\Tokens\X509AsymmetricSecurityKey.cs (43)

System\IdentityModel\Tokens\XmlDsigSep2000.cs (3)

76throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.ErrorDeserializingKeyIdentifierClause)); 99throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityMessageSerializationException(SRP.NoKeyInfoClausesToWrite)); 140throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityMessageSerializationException(SRP.InvalidX509RawData));

System\IdentityModel\XD.cs (30)

System\ServiceModel\AuditLogLocation.cs (1)

24throw ExceptionHelper.PlatformNotSupported(SRP.SecurityAuditPlatformNotSupported);

System\ServiceModel\CallbackBehaviorAttribute.cs (4)

53SRP.Format(SRP.SFxCallbackBehaviorAttributeOnlyOnDuplex, serviceEndpoint.Contract.Name))); 70SRP.Format(SRP.SFXEndpointBehaviorUsedOnWrongSide, typeof(CallbackBehaviorAttribute).Name)));

System\ServiceModel\ChannelFactory.cs (21)

System\ServiceModel\Channels\AddressHeader.cs (2)

137throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.ExpectedElementMissing, Name, Namespace)));

System\ServiceModel\Channels\AddressHeaderCollection.cs (4)

31throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.MessageHeaderIsNull0)); 41throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.MessageHeaderIsNull0)); 121throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.MultipleMessageHeaders, name, ns)));

System\ServiceModel\Channels\BinaryMessageEncoder.cs (24)

389string excMsg = SRP.Format(SRP.MaxSentMessageSizeExceeded, maxMessageSize); 431throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SRP.BinaryEncoderSessionInvalid)); 447throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SRP.BinaryEncoderSessionMalformed)); 453throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SRP.BinaryEncoderSessionMalformed)); 459string message = SRP.Format(SRP.BinaryEncoderSessionTooLarge, _maxSessionSize); 484throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SRP.BinaryEncoderSessionMalformed)); 624SRP.ValueMustBeNonNegative)); 649SRP.ValueMustBeNonNegative)); 654string excMsg = SRP.Format(SRP.MaxSentMessageSizeExceeded, maxMessageSize); 830throw FxTrace.Exception.AsError(new ProtocolException(SRP.Format(SRP.EncoderUnrecognizedContentType, contentType, ContentType))); 849throw FxTrace.Exception.AsError(new ProtocolException(SRP.Format(SRP.EncoderUnrecognizedContentType, contentType, ContentType))); 1018SRP.Format(SRP.ValueMustBeInRange, 0, 0x4000))); 1041SRP.Format(SRP.ValueMustBeInRange, 0, 0xFF))); 1067SRP.Format(SRP.ValueMustBeInRange, 'a', 'z'))); 1111SRP.Format(SRP.ValueMustBeInRange, 1, 4)));

System\ServiceModel\Channels\BinaryMessageEncodingBindingElement.cs (7)

74string errorMsg = SRP.Format(SRP.UnsupportedEnvelopeVersion, GetType().FullName, BinaryEncoderDefaults.EnvelopeVersion, value.Envelope); 94SRP.ValueMustBePositive)); 112SRP.ValueMustBePositive)); 147SRP.ValueMustBeNonNegative)); 161throw FxTrace.Exception.AsError(new NotSupportedException(SRP.Format( 162SRP.TransportDoesNotSupportCompression,

System\ServiceModel\Channels\Binding.cs (22)

System\ServiceModel\Channels\BindingContext.cs (4)

96throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format( 97SRP.NoChannelBuilderAvailable, Binding.Name, Binding.Namespace))); 115throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.NotAllBindingElementsBuilt, builder.ToString())));

System\ServiceModel\Channels\BodyWriter.cs (4)

43SRP.ValueMustBeNonNegative)); 56throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.BodyWriterCanOnlyBeWrittenOnce)); 64throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.BodyWriterReturnedIsNotBuffered)); 121throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.BodyWriterCanOnlyBeWrittenOnce));

System\ServiceModel\Channels\BufferedMessageWriter.cs (1)

21_stream = new BufferManagerOutputStream(SRP.MaxSentMessageSizeExceeded);

System\ServiceModel\Channels\BufferManager.cs (3)

21maxBufferPoolSize, SRP.ValueMustBeNonNegative)); 27maxBufferSize, SRP.ValueMustBeNonNegative)); 59SRP.ValueMustBeNonNegative));

System\ServiceModel\Channels\BufferManagerOutputStream.cs (1)

44string excMsg = SRP.Format(_quotaExceededString, maxSizeQuota);

System\ServiceModel\Channels\ChannelBuilder.cs (1)

51throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.TransportBindingElementNotFound));

System\ServiceModel\Channels\ChannelDemuxer.cs (1)

77throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(value), SRP.ValueMustBeGreaterThanZero));

System\ServiceModel\Channels\ChannelFactoryBase.cs (2)

163throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.ChannelFactoryCannotBeUsedToCreateChannels, GetType().ToString())));

System\ServiceModel\Channels\ChannelManagerBase.cs (2)

49return new ArgumentException(SRP.Format(SRP.ChannelTypeNotSupported, type), "TChannel");

System\ServiceModel\Channels\ChannelParameterCollection.cs (8)

89text = SRP.Format(SRP.ChannelParametersCannotBeModified, 94text = SRP.Format(SRP.CommunicationObjectInInvalidState, 117text = SRP.Format(SRP.ChannelParametersCannotBePropagated, 129text = SRP.Format(SRP.CommunicationObjectInInvalidState,

System\ServiceModel\Channels\ChannelReliableSession.cs (44)

System\ServiceModel\Channels\ChannelRequirements.cs (18)

236exception = new InvalidOperationException(SRP.Format(SRP.EndpointListenerRequirementsCannotBeMetBy3, 254exception = new InvalidOperationException(SRP.Format(SRP.CouldnTCreateChannelForType2, bindingName, contractChannelTypesString)); 349return new InvalidOperationException(SRP.Format(SRP.BindingDoesnTSupportAnyChannelTypes1, bindingName)); 353return new InvalidOperationException(SRP.Format(SRP.BindingDoesnTSupportSessionButContractRequires1, bindingName)); 357return new InvalidOperationException(SRP.Format(SRP.BindingDoesntSupportDatagramButContractRequires, bindingName)); 361return new InvalidOperationException(SRP.Format(SRP.BindingDoesnTSupportDuplexButContractRequires1, bindingName)); 365return new InvalidOperationException(SRP.Format(SRP.BindingDoesnTSupportRequestReplyButContract1, bindingName)); 369return new InvalidOperationException(SRP.Format(SRP.BindingDoesnTSupportOneWayButContractRequires1, bindingName)); 373return new InvalidOperationException(SRP.Format(SRP.BindingDoesnTSupportTwoWayButContractRequires1, bindingName));

System\ServiceModel\Channels\ClientReliableChannelBinder.cs (2)

160new TimeoutException(SRP.Format(SRP.TimeoutOnRequest, timeout)));

System\ServiceModel\Channels\ClientReliableDuplexSessionChannel.cs (25)

120temp.TimeoutString1Index = SRP.TimeoutOnClose; 232string faultString = SRP.Format(SRP.ReceivedResponseBeforeRequestFaultString, request); 233string exceptionString = SRP.Format(SRP.ReceivedResponseBeforeRequestExceptionString, request); 323SRP.SequenceTerminatedSessionClosedBeforeDone, 324SRP.SessionClosedBeforeDone); 394SRP.SequenceTerminatedEarlyTerminateSequence, 395SRP.EarlyTerminateSequence); 429remoteFaultException = new ProtocolException(SRP.EarlyTerminateSequence); 463string faultString = SRP.SequenceTerminatedSmallLastMsgNumber; 464string exceptionString = SRP.SmallLastMsgNumberExceptionString; 469string faultString = SRP.SequenceTerminatedInconsistentLastMsgNumber; 470string exceptionString = SRP.InconsistentLastMsgNumberExceptionString; 486SRP.SequenceTerminatedUnsupportedTerminateSequence, 487SRP.UnsupportedTerminateSequenceExceptionString); 501string exceptionString = SRP.UnsupportedCloseExceptionString; 502string faultString = SRP.SequenceTerminatedUnsupportedClose; 706exception = new CommunicationException(SRP.EarlySecurityFaulted, exception); 777ReliableSession.OnLocalFault(null, SequenceTerminatedFault.CreateCommunicationFault(ReliableSession.OutputID, SRP.CloseOutputSessionErrorReason, null), null); 836ReliableSession.OnLocalFault(new CommunicationException(SRP.MaximumRetryCountExceeded, _maxRetryCountException), 949Exception e = new CommunicationException(SRP.EarlySecurityClose); 1030SRP.SequenceTerminatedSessionClosedBeforeDone, SRP.SessionClosedBeforeDone); 1039throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SendCannotBeCalledAfterCloseOutputSession));

System\ServiceModel\Channels\CommunicationObject.cs (14)

234new ArgumentOutOfRangeException(nameof(timeout), SRP.SFxTimeoutOutOfRange0)); 334return new InvalidOperationException(SRP.Format(SRP.CommunicationObjectCannotBeUsed, GetCommunicationObjectType().ToString(), _state.ToString())); 339return new InvalidOperationException(SRP.Format(SRP.CommunicationObjectCannotBeModifiedInState, GetCommunicationObjectType().ToString(), _state.ToString())); 344return new InvalidOperationException(SRP.Format(SRP.CommunicationObjectBaseClassMethodNotCalled, GetCommunicationObjectType().ToString(), method)); 361string message = SRP.Format(SRP.CommunicationObjectFaulted1, GetCommunicationObjectType().ToString()); 367return new CommunicationObjectAbortedException(SRP.Format(SRP.CommunicationObjectAborted1, GetCommunicationObjectType().ToString())); 480return new CommunicationException(SRP.Format(SRP.CommunicationObjectCloseInterrupted1, GetCommunicationObjectType().ToString())); 511new ArgumentOutOfRangeException(nameof(timeout), SRP.SFxTimeoutOutOfRange0));

System\ServiceModel\Channels\CreateSequence.cs (6)

77string reason = SRP.CSRefusedAcksToMustEqualEndpoint; 98string reason = SRP.CSRefusedInvalidIncompleteSequenceBehavior; 138string reason = SRP.CSRefusedRequiredSecurityElementMissing; 153string reason = SRP.CSRefusedUnexpectedElementAtEndOfCSMessage; 162string reason = SRP.Format(SRP.CouldNotParseWithAction, WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion));

System\ServiceModel\Channels\CreateSequenceResponse.cs (1)

69string reason = SRP.CSResponseWithInvalidIncompleteSequenceBehavior;

System\ServiceModel\Channels\DuplexChannel.cs (4)

33new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0)); 97new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0)); 132new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0)); 161new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0));

System\ServiceModel\Channels\FaultConverter.cs (8)

37string text = SRP.Format(SRP.FaultConverterDidNotCreateException, GetType().Name); 46string text = SRP.Format(SRP.FaultConverterCreatedException, GetType().Name); 63string text = SRP.Format(SRP.FaultConverterDidNotCreateFaultMessage, GetType().Name); 72string text = SRP.Format(SRP.FaultConverterCreatedFaultMessage, GetType().Name);

System\ServiceModel\Channels\InputChannel.cs (4)

29return new TimeoutException(SRP.Format(SRP.ReceiveTimedOut, channel.LocalAddress.Uri.AbsoluteUri, timeout)); 33return new TimeoutException(SRP.Format(SRP.ReceiveTimedOutNoLocalAddress, timeout));

System\ServiceModel\Channels\IntDecoder.cs (4)

20throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.FramingValueNotAvailable)); 41throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.FramingValueNotAvailable)); 51throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SRP.FramingSizeTooLarge)); 68throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(size), size, SRP.ValueMustBePositive));

System\ServiceModel\Channels\IntEncoder.cs (1)

28SRP.ValueMustBeNonNegative));

System\ServiceModel\Channels\LifetimeManager.cs (4)

239throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SRP.Format(SRP.SFxCloseTimedOut1, timeout))); 250throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SRP.Format(SRP.SFxCloseTimedOut1, timeout)));

System\ServiceModel\Channels\LocalClientSecuritySettings.cs (15)

System\ServiceModel\Channels\MaxMessageSizeStream.cs (4)

86string message = SRP.Format(SRP.MaxReceivedMessageSizeExceeded, maxMessageSize); 99string message = SRP.Format(SRP.MaxSentMessageSizeExceeded, maxMessageSize);

System\ServiceModel\Channels\Message.cs (41)

System\ServiceModel\Channels\MessageBuffer.cs (1)

50return new ObjectDisposedException("", SRP.MessageBufferIsClosed);

System\ServiceModel\Channels\MessageEncoder.cs (2)

245new ProtocolException(SRP.Format(SRP.EncoderMessageVersionMismatch, message.Version, MessageVersion)),

System\ServiceModel\Channels\MessageEncoderCompressionHandler.cs (2)

22using (BufferManagerOutputStream bufferedOutStream = new BufferManagerOutputStream(SRP.MaxReceivedMessageSizeExceeded, 1024, maxDecompressedSize, bufferManager)) 61using (BufferManagerOutputStream bufferedOutStream = new BufferManagerOutputStream(SRP.MaxSentMessageSizeExceeded, 1024, int.MaxValue, bufferManager))

System\ServiceModel\Channels\MessageFault.cs (10)

103throw TraceUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.EnvelopeVersionUnknown, envelopeVersion.ToString())), message); 111SRP.SFxErrorDeserializingFault, e)); 116SRP.SFxErrorDeserializingFault, e)); 121SRP.SFxErrorDeserializingFault, e)); 199throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(SRP.ExtraContentIsPresentInFaultDetail)); 209throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.FaultDoesNotHaveAnyDetail)); 318throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.EnvelopeVersionUnknown, version.ToString()))); 730throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(SRP.AtLeastOneFaultReasonMustBeSpecified));

System\ServiceModel\Channels\MessageHeader.cs (5)

400throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SFXHeaderNameCannotBeNullOrEmpty, "name")); 437throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.EnvelopeVersionUnknown, messageVersion.Envelope.ToString()))); 489throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.MessageHeaderVersionNotSupported, GetType().FullName, messageVersion.ToString()), "version"));

System\ServiceModel\Channels\MessageHeaders.cs (68)

System\ServiceModel\Channels\MessageProperties.cs (10)

57throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(string.Empty, SRP.Format(SRP.ObjectDisposed, GetType().ToString()))); 73throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.MessagePropertyNotFound, name))); 528throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.MessagePropertyReturnedNullCopy)); 721throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.DuplicateMessageProperty, name))); 822throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.MessagePropertiesArraySize0)); 828SRP.Format(SRP.ValueMustBeInRange, 0, array.Length - _propertyCount)));

System\ServiceModel\Channels\MessageVersion.cs (8)

67SRP.Format(SRP.AddressingVersionNotSupported, addressingVersion)); 87SRP.Format(SRP.AddressingVersionNotSupported, addressingVersion)); 99SRP.Format(SRP.AddressingVersionNotSupported, addressingVersion)); 105SRP.Format(SRP.EnvelopeVersionNotSupported, envelopeVersion));

System\ServiceModel\Channels\MtomMessageEncoder.cs (7)

220SRP.SFxErrorCreatingMtomReader, fe)); 225SRP.SFxErrorCreatingMtomReader, xe)); 463SRP.ValueMustBeNonNegative)); 466SRP.Format(SRP.ValueMustBeInRange, 0, maxMessageSize))); 650SRP.SFxErrorCreatingMtomReader, fe)); 655SRP.SFxErrorCreatingMtomReader, xe));

System\ServiceModel\Channels\MtomMessageEncodingBindingElement.cs (7)

28throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.MtomEncoderBadMessageVersion, messageVersion.ToString()), nameof(messageVersion))); 67SRP.ValueMustBePositive)); 85SRP.ValueMustBePositive)); 111SRP.ValueMustBePositive)); 147throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.MtomEncoderBadMessageVersion, value.ToString()), nameof(value)));

System\ServiceModel\Channels\OutputChannel.cs (3)

36new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0)); 85new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0)); 110new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0));

System\ServiceModel\Channels\ProducerConsumerStream.cs (1)

263throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly));

System\ServiceModel\Channels\ReliableChannelBinder.cs (11)

357return new CommunicationObjectAbortedException(SRP.Format( 358SRP.CommunicationObjectAborted1, GetType().ToString())); 393return new CommunicationObjectFaultedException(SRP.Format( 394SRP.CommunicationObjectFaulted1, GetType().ToString())); 515e = new InvalidOperationException(SRP.Format( 516SRP.CommunicationObjectCannotBeModifiedInState, 624new TimeoutException(SRP.Format(SRP.TimeoutOnSend, timeout))); 708new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0)); 801SRP.SFxTimeoutOutOfRange0)); 817SRP.SFxTimeoutOutOfRange0));

System\ServiceModel\Channels\ReliableMessagingHelpers.cs (39)

System\ServiceModel\Channels\ReliableOutputConnection.cs (2)

162RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(_id, SRP.SequenceTerminatedAddLastToWindowTimedOut, null)); 170RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(_id, SRP.SequenceTerminatedUnknownAddToWindowError, null));

System\ServiceModel\Channels\ReliableOutputSessionChannel.cs (16)

115temp.TimeoutString1Index = SRP.TimeoutOnClose; 234exception = new CommunicationException(SRP.EarlySecurityFaulted, exception); 285WcfEventSource.Instance.MaxRetryCyclesExceeded(SRP.MaximumRetryCountExceeded); 287_session.OnLocalFault(new CommunicationException(SRP.MaximumRetryCountExceeded, _maxRetryCountException), 517_session.OnRemoteFault(new ProtocolException(SRP.UnsupportedTerminateSequenceExceptionString)); 525string exceptionString = SRP.UnsupportedCloseExceptionString; 526string faultString = SRP.SequenceTerminatedUnsupportedClose; 706string faultString = SRP.Format(SRP.ReceivedResponseBeforeRequestFaultString, requestName); 707string exceptionString = SRP.Format(SRP.ReceivedResponseBeforeRequestExceptionString, requestName); 804string faultString = SRP.Format(SRP.ReceivedResponseBeforeRequestFaultString, requestName); 805string exceptionString = SRP.Format(SRP.ReceivedResponseBeforeRequestExceptionString, requestName); 832Exception e = new CommunicationException(SRP.EarlySecurityClose);

System\ServiceModel\Channels\ReliableRequestSessionChannel.cs (13)

112temp.TimeoutString1Index = SRP.TimeoutOnClose; 243exception = new CommunicationException(SRP.EarlySecurityFaulted, exception); 283WcfEventSource.Instance.MaxRetryCyclesExceeded(SRP.MaximumRetryCountExceeded); 285session.OnLocalFault(new CommunicationException(SRP.MaximumRetryCountExceeded, maxRetryCountException), 506SRP.SequenceTerminatedReplyMissingAcknowledgement, 507SRP.ReplyMissingAcknowledgement); 520SRP.SequenceTerminatedUnsupportedTerminateSequence, 521SRP.UnsupportedTerminateSequenceExceptionString); 534string exceptionString = SRP.UnsupportedCloseExceptionString; 535string faultString = SRP.SequenceTerminatedUnsupportedClose; 817throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SRP.Format(SRP.TimeoutOnRequest, _originalTimeout))); 830SRP.SequenceTerminatedReliableRequestThrew, null);

System\ServiceModel\Channels\ReliableSessionBindingElement.cs (14)

57SRP.TimeSpanMustbeGreaterThanTimeSpanZero)); 63SRP.SFxTimeoutOutOfRangeTooBig)); 85SRP.TimeSpanMustbeGreaterThanTimeSpanZero)); 91SRP.SFxTimeoutOutOfRangeTooBig)); 109SRP.Format(SRP.ValueMustBeInRange, 0, 16384))); 125SRP.ValueMustBePositive)); 141SRP.Format(SRP.ValueMustBeInRange, 0, 4096))); 345throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("TChannel", SRP.Format(SRP.ChannelTypeNotSupported, typeof(TChannel))); 392new InvalidOperationException(SRP.ManualAddressingNotSupported)); 412new InvalidOperationException(SRP.Format(SRP.TransferModeNotSupported,

System\ServiceModel\Channels\RequestChannel.cs (5)

251new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.SFxTimeoutOutOfRange0)); 271throw TraceUtility.ThrowHelperError(new TimeoutException(SRP.Format(SRP.RequestChannelSendTimedOut, savedTimeout), 283throw TraceUtility.ThrowHelperError(new TimeoutException(SRP.Format(SRP.RequestChannelWaitForReplyTimedOut, savedTimeout),

System\ServiceModel\Channels\RequestContextBase.cs (3)

113throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(timeout), timeout, SRP.ValueMustBeNonNegative)); 186throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationObjectAbortedException(SRP.RequestContextAborted)); 196throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ReplyAlreadySent));

System\ServiceModel\Channels\RequestReplyCorrelator.cs (2)

81throw TraceUtility.ThrowHelperError(new ArgumentException(SRP.SuppliedMessageIsNotAReplyItHasNoRelatesTo0), reply); 153throw TraceUtility.ThrowHelperError(new InvalidOperationException(SRP.MissingMessageID), reply);

System\ServiceModel\Channels\SecurityBindingElement.cs (3)

334throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.ChannelTypeNotSupported, typeof(TChannel)), nameof(TChannel))); 340throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.EncodingBindingElementDoesNotHandleReaderQuotas));

System\ServiceModel\Channels\SecurityChannelFactory.cs (4)

242SRP.Format(SRP.SecurityProtocolFactoryShouldBeSetBeforeThisOperation))); 299throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.ExtendedProtectionPolicyCustomChannelBindingNotSupported)));

System\ServiceModel\Channels\SequenceRangeCollection.cs (2)

195SRP.Format(SRP.ValueMustBeInRange, 0, _ranges.Length - 1)));

System\ServiceModel\Channels\ServiceChannel.cs (43)

System\ServiceModel\Channels\ServiceChannelFactory.cs (3)

138SRP.CantCreateChannelWithManualAddressing)); 160SRP.CantCreateChannelWithManualAddressing)); 369throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxChannelFactoryTypeMustBeInterface));

System\ServiceModel\Channels\ServiceChannelProxy.cs (10)

34throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.FailedToCreateTypedProxy, typeof(TChannel)))); 83throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.SFxMethodNotSupported1, method.Name))); 87throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.SFxMethodNotSupportedOnCallback1, method.Name))); 135throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.InvalidTypedProxyMethodHandle, _proxiedType.Name))); 346activityName = SRP.Format(SRP.ActivityClose, _serviceChannel.GetType().FullName);

System\ServiceModel\Channels\TextMessageEncoder.cs (10)

88SRP.Format(SRP.EnvelopeVersionNotSupported, version.Envelope))); 221throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SRP.EncoderBadContentType, e)); 229throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SRP.Format(SRP.EncoderUnrecognizedCharSet, charSet))); 306SRP.Format(SRP.EnvelopeVersionNotSupported, version.Envelope))); 506SRP.ValueMustBeNonNegative), message); 512SRP.Format(SRP.ValueMustBeInRange, 0, maxMessageSize)), message);

System\ServiceModel\Channels\TextMessageEncodingBindingElement.cs (2)

65SRP.ValueMustBePositive)); 83SRP.ValueMustBePositive));

System\ServiceModel\Channels\TimeoutStream.cs (1)

24throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(nameof(stream), SRP.StreamDoesNotSupportTimeout);

System\ServiceModel\Channels\TransmissionStrategy.cs (3)

76SRP.TraceCodeWsrmNegativeElapsedTimeDetected, this); 782_exception = new TimeoutException(SRP.Format(SRP.TimeoutOnAddToWindow, timeout));

System\ServiceModel\Channels\TransportBindingElement.cs (2)

61SRP.ValueMustBeNonNegative)); 79SRP.ValueMustBePositive));

System\ServiceModel\Channels\TransportChannelFactory.cs (3)

33throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.MultipleMebesInParameters)); 166throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("via", SRP.Format(SRP.InvalidUriScheme,

System\ServiceModel\Channels\TransportDefaults.cs (2)

73throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.MessageTextEncodingNotSupported, charSet), "encoding"));

System\ServiceModel\Channels\TransportSecurityBindingElement.cs (1)

117throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SecureConversationSecurityTokenParametersRequireBootstrapBinding));

System\ServiceModel\Channels\TransportSecurityHelpers.cs (3)

143throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format( 144SRP.InvalidTokenProvided, tokenProvider.GetType(), typeof(T)))); 164throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.NoUserNameTokenProvided));

System\ServiceModel\Channels\UriGenerator.cs (1)

35throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.UriGeneratorSchemeMustNotBeEmpty, "scheme"));

System\ServiceModel\Channels\WsrmFault.cs (17)

101message = SRP.Format(SRP.WsrmFaultReceived, message); 485: base(true, WsrmFeb2005Strings.InvalidAcknowledgement, SRP.InvalidAcknowledgementFaultReason, 486SRP.InvalidAcknowledgementReceived, sequenceID, true, false) 525: base(true, WsrmFeb2005Strings.LastMessageNumberExceeded, SRP.LastMessageNumberExceededFaultReason, 526SRP.LastMessageNumberExceeded, sequenceID, false, true) 541: base(true, WsrmFeb2005Strings.MessageNumberRollover, SRP.MessageNumberRolloverFaultReason, 542SRP.MessageNumberRollover, sequenceID, true, true) 565SRP.Format(SRP.InvalidSequenceNumber, maxMessageNumber))); 596: base(true, Wsrm11Strings.SequenceClosed, SRP.SequenceClosedFaultString, 629return CreateCommunicationFault(sequenceId, SRP.SequenceTerminatedMaximumRetryCountExceeded, null); 640return CreateProtocolFault(sequenceID, SRP.SequenceTerminatedQuotaExceededException, null); 647: base(true, WsrmFeb2005Strings.UnknownSequence, SRP.UnknownSequenceFaultReason, 648SRP.UnknownSequenceMessageReceived, sequenceID, true, true) 665message = SRP.Format(SRP.UnknownSequenceFaultReceived, message);

System\ServiceModel\Channels\WsrmMessageInfo.cs (58)

System\ServiceModel\ClientBase.cs (12)

55throw new PlatformNotSupportedException(SRP.ConfigurationFilesNotSupported); 162ServiceModelActivity.Start(activity, SRP.Format(SRP.ActivityOpenClientBase, typeof(TChannel).FullName), ActivityType.OpenClient); 212throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxImmutableClientBaseCacheSetting, typeof(TChannel).ToString()))); 353ServiceModelActivity.Start(activity, SRP.Format(SRP.ActivityCloseClientBase, typeof(TChannel).FullName), ActivityType.Close); 494ServiceModelActivity.Start(activity, SRP.Format(SRP.ActivityCloseClientBase, typeof(TChannel).FullName), ActivityType.Close); 906throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxChannelFactoryEndpointAddressUri)); 954throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.SFxMethodNotSupported1, methodName)));

System\ServiceModel\DeliveryRequirementsAttribute.cs (10)

89SRP.Format(SRP.SinceTheBindingForDoesnTSupportIBindingCapabilities2_1, name))); 97SRP.Format(SRP.BindingRequirementsAttributeRequiresQueuedDelivery1, name))); 102SRP.Format(SRP.BindingRequirementsAttributeDisallowsQueuedDelivery1, name))); 116SRP.Format(SRP.SinceTheBindingForDoesnTSupportIBindingCapabilities1_1, name))); 123SRP.Format(SRP.TheBindingForDoesnTSupportOrderedDelivery1, name)));

System\ServiceModel\Description\CallbackDebugBehavior.cs (2)

35SRP.Format(SRP.SFXEndpointBehaviorUsedOnWrongSide, typeof(CallbackDebugBehavior).Name)));

System\ServiceModel\Description\ClientCredentials.cs (6)

162throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(NotImplemented.ByDesignWithMessage(SRP.Format(SRP.CloneNotImplementedCorrectly, GetType(), (result != null) ? result.ToString() : "null"))); 181throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.MultipleSecurityCredentialsManagersInChannelBindingParameters, otherCredentialsManager))); 189SRP.Format(SRP.SFXEndpointBehaviorUsedOnWrongSide, typeof(ClientCredentials).Name)));

System\ServiceModel\Description\ContractDescription.cs (9)

66new ArgumentOutOfRangeException(nameof(value), SRP.SFxContractDescriptionNameCannotBeEmpty)); 202SRP.AChannelServiceEndpointSContractSNameIsNull0)); 207SRP.AChannelServiceEndpointSContractSNamespace0)); 212SRP.Format(SRP.SFxContractHasZeroOperations, Name))); 228SRP.Format(SRP.ContractIsNotSelfConsistentItHasOneOrMore2, Name))); 234SRP.Format(SRP.SFxContractHasZeroInitiatingOperations, Name)));

System\ServiceModel\Description\DispatcherBuilder.cs (3)

176throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxMultipleContractStarOperations0)); 307string text = SRP.Format(SRP.SFxBindingMustContainTransport2, binding.Name, binding.Namespace);

System\ServiceModel\Description\MessagePartDescription.cs (1)

25throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(name), SRP.SFxParameterNameCannotBeNull);

System\ServiceModel\Description\MetadataLocation.cs (2)

35throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.Format(SRP.SFxMetadataReferenceInvalidLocation, value));

System\ServiceModel\Description\OperationDescription.cs (3)

32new ArgumentOutOfRangeException(nameof(name), SRP.SFxOperationDescriptionNameCannotBeEmpty)); 178throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxOperationMustHaveOneOrTwoMessages, Name)));

System\ServiceModel\Description\ServiceEndpoint.cs (3)

123throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("value", SRP.UriMustBeAbsolute); 173throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.AChannelServiceEndpointSBindingIsNull0)); 177throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.AChannelServiceEndpointSContractIsNull0));

System\ServiceModel\Description\ServiceReflector.cs (42)

System\ServiceModel\Description\TypedMessageConverter.cs (4)

51throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.SFxMessageContractAttributeRequired, messageContract), "messageContract")); 107throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxActionMismatch, this.Action, message.Headers.Action)));

System\ServiceModel\Description\TypeLoader.cs (103)

System\ServiceModel\Description\XmlSerializerOperationBehavior.cs (33)

System\ServiceModel\Diagnostics\TraceUtility.cs (3)

381ServiceModelActivity.Start(activity, SRP.ActivityCallback, ActivityType.ExecuteUserCode); 576ServiceModelActivity.Start(activity, SRP.Format(SRP.ActivityProcessAction, message.Headers.Action), ActivityType.ProcessAction);

System\ServiceModel\Dispatcher\ChannelDispatcher.cs (7)

160SRP.ValueMustBeNonNegative)); 472return new InvalidOperationException(SRP.Format(SRP.SFxChannelDispatcherUnableToOpen1, _listener.Uri), e); 476return new InvalidOperationException(SRP.Format(SRP.SFxChannelDispatcherUnableToOpen2, _listener.Uri, endpointContractNames), e); 624Exception error = new InvalidOperationException(SRP.SFxChannelDispatcherNoMessageVersion); 668Exception error = new InvalidOperationException(SRP.SFxCollectionDoesNotSupportSet0);

System\ServiceModel\Dispatcher\ChannelHandler.cs (12)

260throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxNoEndpointMatchingAddressForConnectionOpeningMessage, message.Headers.Action, "Open"))); 513Fx.Assert(SRP.SFxNonExceptionThrown); 514throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxNonExceptionThrown)); 826string reason = SRP.Format(SRP.SFxNoEndpointMatchingAddress, request.RequestMessage.Headers.To); 840SRP.Format(SRP.SFxMissingActionHeader, addressingVersion.Namespace), AddressingStrings.Action, addressingVersion.Namespace)); 848string reason = SRP.Format(SRP.SFxNoEndpointMatchingContract, request.RequestMessage.Headers.Action); 857string reason = SRP.Format(SRP.SFxChannelTerminated0);

System\ServiceModel\Dispatcher\ClientRuntime.cs (4)

244string text = SRP.SFxSetEnableFaultsOnChannelDispatcher0; 298string text = SRP.SFxSetManualAddressingOnChannelDispatcher0; 554throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.SFxMismatchedOperationParent); 576throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.SFxMismatchedOperationParent);

System\ServiceModel\Dispatcher\DataContractSerializerOperationFormatter.cs (14)

93throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxKnownTypeNull, description.Name))); 296SRP.Format(SRP.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.Description.Name, sx.Message), sx)); 436throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SRP.Format(SRP.SFxInvalidMessageBody, messageInfo.WrapperName, messageInfo.WrapperNamespace, reader.NodeType, reader.Name, reader.NamespaceURI))); 526SRP.Format(SRP.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e)); 531SRP.Format(SRP.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e)); 537SRP.Format(SRP.SFxInvalidMessageBodyErrorDeserializingParameterMore, 545SRP.Format(SRP.SFxInvalidMessageBodyErrorDeserializingParameterMore,

System\ServiceModel\Dispatcher\DispatchOperationRuntime.cs (10)

29throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.RuntimeRequiresInvoker0)); 49throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.DispatchRuntimeRequiresFormatter0, Name))); 218throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.SFxInvalidAsyncResultState0); 258string message = SRP.Format(SRP.SFxNullReplyFromFormatter2, Formatter.GetType().ToString(), (Name ?? "")); 266string message = SRP.Format(SRP.SFxDispatchRuntimeMessageCannotBeNull, Name); 274throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxInvalidReplyAction, Name, reply.Headers.Action ?? "{NULL}", ReplyAction)));

System\ServiceModel\Dispatcher\DispatchRuntime.cs (7)

366string reasonText = SRP.Format(SRP.SFxNoEndpointMatchingContract, action); 492throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.SFxMismatchedOperationParent); 513throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.SFxMismatchedOperationParent); 525throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxCannotActivateCallbackInstace)); 530throw TraceUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxCannotActivateCallbackInstace), message); 535throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxCannotActivateCallbackInstace));

System\ServiceModel\Dispatcher\DuplexChannelBinder.cs (5)

240return new TimeoutException(SRP.Format(SRP.SFxRequestTimedOut2, address, timeout)); 244return new TimeoutException(SRP.Format(SRP.SFxRequestTimedOut1, timeout)); 404throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SPS_InvalidAsyncResult));

System\ServiceModel\Dispatcher\EndpointDispatcher.cs (2)

76Exception error = new InvalidOperationException(SRP.SFxEndpointDispatcherMultipleChannelDispatcher0); 93Exception error = new InvalidOperationException(SRP.SFxEndpointDispatcherDifferentChannelDispatcher0);

System\ServiceModel\Dispatcher\ErrorBehavior.cs (2)

100string reason = _isOnServer ? SRP.SFxInternalServerError : SRP.SFxInternalCallbackError;

System\ServiceModel\Dispatcher\FaultFormatter.cs (1)

159throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(SRP.ExtraContentIsPresentInFaultDetail));

System\ServiceModel\Dispatcher\ImmutableClientRuntime.cs (2)

172(SRP.Format(SRP.SFxNeedProxyBehaviorOperationSelector2,

System\ServiceModel\Dispatcher\ImmutableDispatchRuntime.cs (7)

155string message = SRP.Format(SRP.SFxNullReplyFromExtension2, _messageInspectors[i].GetType().ToString(), (rpc.Operation.Name ?? "")); 360throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.SFxInvalidAsyncResultState0); 496CommunicationException error = new CommunicationException(SRP.SFxOneWayMessageToTwoWayMethod0); 505CommunicationException error = new CommunicationException(SRP.SFxRequestReplyNone); 959throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxActionDemuxerDuplicate, existingOperation.Name, operation.Name, action)));

System\ServiceModel\Dispatcher\InstanceBehavior.cs (2)

72throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxNoDefaultConstructor)); 82throw TraceUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxNoDefaultConstructor), request);

System\ServiceModel\Dispatcher\ListenerBinder.cs (2)

50throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.UnknownListenerType1, listener.Uri.AbsoluteUri)));

System\ServiceModel\Dispatcher\MessageOperationFormatter.cs (5)

37throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SFxParametersMustBeEmpty)); 57throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SFxParameterMustBeArrayOfOneElement)); 67throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SFxResultMustBeMessage)); 72throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SFxParametersMustBeEmpty)); 87throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SFxParameterMustBeMessage));

System\ServiceModel\Dispatcher\MessageRpc.cs (2)

573string text = SRP.Format(SRP.SFxMultipleCallbackFromAsyncOperation,

System\ServiceModel\Dispatcher\OperationFormatter.cs (26)

System\ServiceModel\Dispatcher\PrimitiveOperationFormatter.cs (33)

System\ServiceModel\Dispatcher\ProxyOperationRuntime.cs (8)

80throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.ClientRuntimeRequiresFormatter0, Name))); 182throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SRP.Format(SRP.SFxHeaderNotUnderstood, headersNotUnderstood[0].Name, headersNotUnderstood[0].Namespace))); 235throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxProxyRuntimeMessageCannotBeNull, Name))); 241throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxInvalidRequestAction, Name, rpc.Request.Headers.Action ?? "{NULL}", Action)));

System\ServiceModel\Dispatcher\SharedRuntimeState.cs (2)

41throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxImmutableServiceHostBehavior0)); 45throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxImmutableChannelFactoryBehavior0));

System\ServiceModel\Dispatcher\StreamFormatter.cs (17)

217throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxInvalidStreamInTypedMessage, messageDescription.MessageName))); 221throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxInvalidStreamInRequest, operationName))); 225throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxInvalidStreamInResponse, operationName))); 337SRP.Format(SRP.ValueMustBeNonNegative)), _message); 343SRP.Format(SRP.ValueMustBeNonNegative)), _message); 348throw TraceUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.SFxInvalidStreamOffsetLength, offset + count)), _message); 394throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new IOException(SRP.Format(SRP.SFxStreamIOException), ex)); 402throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(SRP.Format( 403_isRequest ? SRP.SFxStreamRequestMessageClosed : SRP.SFxStreamResponseMessageClosed)));

System\ServiceModel\Dispatcher\SyncMethodInvoker.cs (8)

58throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SFxInvalidCallbackIAsyncResult)); 72throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxNoServiceObject)); 79throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxInputParametersToServiceNull, _inputParameterCount))); 84throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxInputParametersToServiceInvalid, _inputParameterCount, inputs.Length))); 138ServiceModelActivity.Start(activity, SRP.Format(SRP.ActivityExecuteMethod, Method.DeclaringType.FullName, Method.Name), ActivityType.ExecuteUserCode);

System\ServiceModel\Dispatcher\TaskMethodInvoker.cs (8)

69throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SFxInvalidCallbackIAsyncResult)); 131new InvalidOperationException(SRP.SFxNoServiceObject)); 139new InvalidOperationException(SRP.Format(SRP.SFxInputParametersToServiceNull, _inputParameterCount))); 145new InvalidOperationException(SRP.Format(SRP.SFxInputParametersToServiceInvalid, _inputParameterCount, 201SRP.Format(SRP.ActivityExecuteMethod, Method.DeclaringType.FullName, Method.Name),

System\ServiceModel\Dispatcher\ThreadBehavior.cs (2)

120string text = SRP.Format(SRP.SFxMultipleCallbackFromSynchronizationContext, _context.GetType().ToString());

System\ServiceModel\Dispatcher\XmlSerializerOperationFormatter.cs (15)

33throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxDocEncodedNotSupported, description.Name))); 140SRP.Format(SRP.SFxErrorSerializingHeader, messageDescription.MessageName, e.Message), e)); 272SRP.Format(SRP.SFxErrorDeserializingHeader, messageDescription.MessageName), e)); 338throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxBodyCannotBeNull, messageDescription.MessageName))); 364SRP.Format(SRP.SFxErrorSerializingBody, messageDescription.MessageName, e.Message), e)); 478string resourceKey = isRequest ? SRP.SFxErrorDeserializingRequestBody : SRP.SFxErrorDeserializingReplyBody; 481SRP.Format(resourceKey, OperationName), e)); 498SRP.Format(SRP.EnvelopeVersionNotSupported, version));

System\ServiceModel\DnsEndpointIdentity.cs (2)

32throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.Format(SRP.UnrecognizedClaimTypeForIdentity, identity.ClaimType, ClaimTypes.Dns));

System\ServiceModel\DuplexChannelFactory.cs (13)

56ServiceModelActivity.Start(activity, SRP.Format(SRP.ActivityConstructChannelFactory, TraceUtility.CreateSourceString(this)), ActivityType.Construct); 87ServiceModelActivity.Start(activity, SRP.Format(SRP.ActivityConstructChannelFactory, TraceUtility.CreateSourceString(this)), ActivityType.Construct); 112ServiceModelActivity.Start(activity, SRP.Format(SRP.ActivityConstructChannelFactory, TraceUtility.CreateSourceString(this)), ActivityType.Construct); 174throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxCreateDuplexChannelNoCallback1)); 178throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxCreateDuplexChannelNoCallback)); 183throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxCreateDuplexChannelNoCallbackUserObject)); 188throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SFxCreateDuplexChannel1, Endpoint.Contract.Name))); 195throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format( 196SRP.SFxCreateDuplexChannelBadCallbackUserObject, callbackType)));

System\ServiceModel\EndpointAddress.cs (29)

135throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.MultipleIdentities, nameof(extensionReader))); 168throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(nameof(uri), SRP.UriMustBeAbsolute); 289new ProtocolException(SRP.Format(SRP.AddressingVersionNotSupported, message.Version.Addressing))); 534nameof(reader), SRP.CannotDetectAddressingVersion); 539nameof(reader), SRP.Format(SRP.AddressingVersionNotSupported, reader.NamespaceURI)); 600SRP.Format(SRP.AddressingVersionNotSupported, addressingVersion)); 632throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SRP.Format(SRP.UnexpectedDuplicateElement, XD.AddressingDictionary.Identity.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value))); 639throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SRP.Format(SRP.AddressingExtensionInBadNS, reader.LocalName, reader.NamespaceURI))); 685throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SRP.Format(SRP.UnexpectedElementExpectingElement, reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing200408Dictionary.Namespace.Value))); 841throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.InvalidUriValue, address, XD.AddressingDictionary.Address.Value, AddressingVersion.WSAddressingAugust2004.Namespace))); 856throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SRP.Format(SRP.UnexpectedElementExpectingElement, reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value))); 913throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.InvalidUriValue, address, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value))); 978SRP.Format(SRP.AddressingVersionNotSupported, addressingVersion)); 997throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("addressingVersion", SRP.Format(SRP.SFxNone2004)); 1051throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SRP.Format(SRP.AddressingExtensionInBadNS, reader.LocalName, reader.NamespaceURI))); 1108throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SRP.Format(SRP.AddressingExtensionInBadNS, reader.LocalName, reader.NamespaceURI)));

System\ServiceModel\EndpointIdentity.cs (9)

151throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.UnexpectedEmptyElementExpectingClaim, XD.AddressingDictionary.Identity.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value))); 181throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.UnrecognizedIdentityType, reader.Name, reader.NamespaceURI))); 190throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.UnrecognizedIdentityType, reader.Name, reader.NamespaceURI))); 197throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.InvalidIdentityElement)); 221throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.UnrecognizedIdentityPropertyType, IdentityClaim.GetType().ToString())));

System\ServiceModel\ExceptionDetail.cs (2)

56return string.Format(CultureInfo.InvariantCulture, "{0}\n{1}", SRP.SFxExceptionDetailFormat, ToStringHelper(false)); 74sb.AppendFormat("\n {0}\n", SRP.SFxExceptionDetailEndOfInner);

System\ServiceModel\ExtensionCollection.cs (1)

123throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxCannotSetExtensionsByIndex));

System\ServiceModel\FaultContractAttribute.cs (1)

49SRP.SFxNameCannotBeEmpty));

System\ServiceModel\FaultException.cs (8)

24: base(SRP.SFxFaultReason) 134get { return new FaultReason(SRP.SFxFaultReason); } 231return SRP.SFxUnknownFaultNullReason0; 242return SRP.SFxUnknownFaultZeroReasons0; 246return SRP.Format(SRP.SFxUnknownFaultNoMatchingTranslation1, reason.Translations[0].Text); 425return SRP.Format(SRP.SFxFaultExceptionToString3, GetType(), Message, Detail != null ? Detail.ToString() : string.Empty);

System\ServiceModel\FaultReason.cs (3)

57throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.AtLeastOneFaultReasonMustBeSpecified, "translations")); 64array[index++] = faultReasonText ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("translations", SRP.NoNullTranslations); 110throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.NoMatchingTranslationFoundForFaultText));

System\ServiceModel\InstanceContext.cs (1)

183Exception error = new InvalidOperationException(SRP.SFxInstanceNotInitialized);

System\ServiceModel\KeyedByTypeCollection.cs (2)

110throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("item", SRP.Format(SRP.DuplicateBehavior1, item.GetType().FullName));

System\ServiceModel\MessageBodyMemberAttribute.cs (1)

21SRP.ValueMustBeNonNegative));

System\ServiceModel\MessageContractAttribute.cs (1)

57SRP.SFxWrapperNameCannotBeEmpty));

System\ServiceModel\MessageContractMemberAttribute.cs (1)

56SRP.SFxNameCannotBeEmpty));

System\ServiceModel\MessageParameterAttribute.cs (1)

25SRP.SFxNameCannotBeEmpty));

System\ServiceModel\MustUnderstandSoapException.cs (2)

37FaultReason reason = new FaultReason(SRP.Format(SRP.SFxHeaderNotUnderstood, name, ns), CultureInfo.CurrentCulture);

System\ServiceModel\OperationContext.cs (1)

63throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxInvalidChannelToOperationContext));

System\ServiceModel\OperationContextScope.cs (2)

65throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxInterleavedContextScopes0)); 70throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SFxContextModifiedInsideScope0));

System\ServiceModel\OperationContractAttribute.cs (3)

34SRP.SFxNameCannotBeEmpty)); 111SRP.Format(SRP.ContractIsNotSelfConsistentWhenIsSessionOpenNotificationEnabled, operationName, "Action", OperationDescription.SessionOpenedAction, "IsOneWay", "IsInitiating")));

System\ServiceModel\ProtocolException.cs (12)

29string text = SRP.Format(SRP.ReceiveShutdownReturnedFault, reason.Text); 34string text = SRP.Format(SRP.ReceiveShutdownReturnedLargeFault, message.Headers.Action); 40string text = SRP.Format(SRP.ReceiveShutdownReturnedMessage, message.Headers.Action); 53string text = SRP.Format(SRP.OneWayOperationReturnedFault, reason.Text); 58string text = SRP.Format(SRP.OneWayOperationReturnedLargeFault, message.Headers.Action); 64string text = SRP.Format(SRP.OneWayOperationReturnedMessage, message.Headers.Action);

System\ServiceModel\ReliableSession.cs (1)

46SRP.ValueMustBePositive));

System\ServiceModel\RsaEndpointIdentity.cs (4)

28throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.PublicKeyNotRSA))); 39throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.Format(SRP.UnrecognizedClaimTypeForIdentity, identity.ClaimType, ClaimTypes.Rsa));

System\ServiceModel\Security\AcceleratedTokenProvider.cs (9)

93throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.BootstrapSecurityBindingElementNotSet, GetType()))); 104throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.BootstrapSecurityBindingElementNotSet, GetType()))); 130throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.EncodingBindingElementDoesNotHandleReaderQuotas)); 192throw TraceUtility.ThrowHelperError(new SecurityNegotiationException(SRP.Format(SRP.InvalidActionForNegotiationMessage, incomingMessage.Headers.Action)), incomingMessage); 222throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.MoreThanOneRSTRInRSTRC)); 236throw TraceUtility.ThrowHelperError(new SecurityNegotiationException(SRP.BadSecurityNegotiationContext), incomingMessage);

System\ServiceModel\Security\BinaryNegotiation.cs (2)

37throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(SRP.Format(SRP.IncorrectBinaryNegotiationValueType, ValueTypeUri)));

System\ServiceModel\Security\ChannelProtectionRequirements.cs (1)

266throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.OnlyBodyReturnValuesSupported));

System\ServiceModel\Security\ClientCredentialsSecurityTokenManager.cs (18)

System\ServiceModel\Security\HttpDigestClientCredential.cs (1)

48throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly));

System\ServiceModel\Security\IdentityVerifier.cs (15)

System\ServiceModel\Security\InitiatorSessionSymmetricTransportSecurityProtocol.cs (2)

26throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.ProtocolMustBeInitiator, nameof(InitiatorSessionSymmetricTransportSecurityProtocol))));

System\ServiceModel\Security\InMemoryNonceCache.cs (2)

75throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.NonceLengthTooShort); 91throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.NonceLengthTooShort);

System\ServiceModel\Security\IssuanceTokenProviderBase.cs (23)

System\ServiceModel\Security\IssuanceTokenProviderState.cs (2)

38throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.NegotiationIsCompleted)); 48throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.NegotiationIsNotCompleted));

System\ServiceModel\Security\MessagePartSpecification.cs (3)

54throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly)); 81throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly)); 96throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly));

System\ServiceModel\Security\NegotiationTokenProvider.cs (2)

102throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.IssuerBuildContextNotSet, GetType())));

System\ServiceModel\Security\NonceCache.cs (3)

29SRP.SFxTimeoutOutOfRange0)); 35SRP.SFxTimeoutOutOfRangeTooBig)); 56SRP.ValueMustBeNonNegative));

System\ServiceModel\Security\ReceiveSecurityHeader.cs (26)

System\ServiceModel\Security\ReceiveSecurityHeaderElementManager.cs (2)

109new MessageSecurityException(SRP.Format(SRP.DuplicateIdInMessageToBeVerified, id)), _securityHeader.SecurityVerifiedMessage);

System\ServiceModel\Security\RequestSecurityToken.cs (20)

System\ServiceModel\Security\RequestSecurityTokenResponse.cs (37)

System\ServiceModel\Security\ScopedMessagePartSpecification.cs (1)

220throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly));

System\ServiceModel\Security\SecureConversationDriver.cs (4)

16throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SecureConversationDriverVersionDoesNotSupportSession)); 24throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SecureConversationDriverVersionDoesNotSupportSession)); 44throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SecureConversationDriverVersionDoesNotSupportSession)); 52throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.SecureConversationDriverVersionDoesNotSupportSession));

System\ServiceModel\Security\SecurityAlgorithmSuite.cs (4)

102throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SigningTokenHasNoKeys, token))); 123throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SigningTokenHasNoKeysSupportingTheAlgorithmSuite, token, this)));

System\ServiceModel\Security\SecurityAppliedMessage.cs (4)

45return new InvalidOperationException(SRP.Format(SRP.MessageBodyOperationNotValidInBodyState, operation, _state)); 52throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.DelayedSecurityApplicationAlreadyCompleted)); 327BufferedOutputStream fullBodyFragment = new BufferManagerOutputStream(SRP.XmlBufferQuotaExceeded, 1024, int.MaxValue, _securityHeader.StreamBufferManager);

System\ServiceModel\Security\SecurityHeader.cs (1)

117throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.OperationCannotBeDoneAfterProcessingIsStarted));

System\ServiceModel\Security\SecurityHeaderTokenResolver.cs (5)

51throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.ResolvingExternalTokensRequireSecurityTokenParameters); 186throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.Format(SRP.UnableToDeriveKeyFromKeyInfoClause, keyIdentifierClause, resolvedToken))); 192throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.Format(SRP.DerivedKeyLengthSpecifiedInImplicitDerivedKeyClauseTooLong, keyIdentifierClause.ToString(), derivationLength, _securityHeader.MaxDerivedKeyLength)));

System\ServiceModel\Security\SecurityProtocol.cs (9)

485throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.SenderSideSupportingTokensMustSpecifySecurityTokenParameters)); 581throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.UnknownTokenAttachmentMode, supportingTokens[i].SecurityTokenAttachmentMode.ToString()))); 591throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.Format(SRP.TokenProviderCannotGetTokensForTarget, target))); 602throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.Format(SRP.TokenProviderCannotGetTokensForTarget, target), exception)); 606throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(SRP.Format(SRP.TokenProviderCannotGetTokensForTarget, target), sne));

System\ServiceModel\Security\SecurityProtocolFactory.cs (8)

280throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(value), SRP.TimeSpanMustbeGreaterThanTimeSpanZero)); 371throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(value), SRP.TimeSpanMustbeGreaterThanTimeSpanZero)); 427throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.ProtocolFactoryCouldNotCreateProtocol)); 492throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(nameof(DetectReplays), SRP.Format(SRP.SecurityProtocolCannotDoReplayDetection, this)); 496throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.NoncesCachedInfinitely)); 535SRP.Format(SRP.PropertySettingErrorOnProtocolFactory, propertyName, this),

System\ServiceModel\Security\SecuritySessionClientSettings.cs (39)

System\ServiceModel\Security\SecuritySessionSecurityTokenProvider.cs (26)

System\ServiceModel\Security\SecurityStandardsManager.cs (1)

51throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(messageSecurityVersion), SRP.MessageSecurityVersionOutOfRange));

System\ServiceModel\Security\SecurityTimestamp.cs (9)

System\ServiceModel\Security\SecurityUtils.cs (23)

230throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.Format(SRP.CannotDetermineSPNBasedOnAddress, target))); 326throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(SRP.Format(SRP.MultipleMatchingCryptosFound, typeof(T).ToString()))); 345throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(SRP.Format(SRP.CannotFindMatchingCrypto, derivationAlgorithm))); 849throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.CannotFindCert, storeName, storeLocation, findType, findValue))); 905return new InvalidOperationException(SRP.Format(SRP.CannotFindCert, storeName, storeLocation, findType, findValue)); 907return new InvalidOperationException(SRP.Format(SRP.CannotFindCertForTarget, storeName, storeLocation, findType, findValue, target)); 911return new InvalidOperationException(SRP.Format(SRP.FoundMultipleCerts, storeName, storeLocation, findType, findValue)); 913return new InvalidOperationException(SRP.Format(SRP.FoundMultipleCertsForTarget, storeName, storeLocation, findType, findValue, target)); 927throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.Format(SRP.IssuerBindingNotPresentInTokenRequirement, requirement)); 976throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ServerTooBusyException(SRP.Format(SRP.SecurityServerTooBusy, target), faultException)); 980throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new EndpointNotFoundException(SRP.Format(SRP.SecurityEndpointNotFound, target), faultException)); 1008return new MessageSecurityException(SRP.UnsecuredMessageFaultReceived, faultException);

System\ServiceModel\Security\SecurityVerifiedMessage.cs (2)

112return new InvalidOperationException(SRP.Format(SRP.MessageBodyOperationNotValidInBodyState,

System\ServiceModel\Security\SecurityVersion.cs (2)

100SRP.SignatureConfirmationNotSupported)); 130SRP.SignatureConfirmationNotSupported));

System\ServiceModel\Security\SendSecurityHeader.cs (11)

397throw TraceUtility.ThrowHelperError(new InvalidOperationException(SRP.TimestampAlreadySetForSecurityHeader), Message); 430SRP.SignatureConfirmationNotSupported)); 521throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.UnsupportedTokenInclusionMode, parameters.InclusionMode))); 542throw TraceUtility.ThrowHelperError(new MessageSecurityException(SRP.TokenManagerCannotCreateTokenReference), Message); 611throw TraceUtility.ThrowHelperError(new MessageSecurityException(SRP.TokenManagerCannotCreateTokenReference), Message); 618SRP.SigningWithoutPrimarySignatureRequiresTimestamp), Message); 626SRP.PrimarySignatureMustBeComputedBeforeSupportingTokenSignatures), Message); 631SRP.SupportingTokenSignaturesNotExpected), Message); 662throw TraceUtility.ThrowHelperError(new MessageSecurityException(SRP.TokenManagerCannotCreateTokenReference), Message); 690throw TraceUtility.ThrowHelperError(new MessageSecurityException(SRP.TokenManagerCannotCreateTokenReference), Message);

System\ServiceModel\Security\TimeBoundedCache.cs (2)

397string message = SRP.Format(SRP.CacheQuotaReached, Capacity);

System\ServiceModel\Security\Tokens\BinarySecretSecurityToken.cs (4)

32throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(keySizeInBits), SRP.Format(SRP.ValueMustBeInRange, 0, 512))); 37throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(keySizeInBits), SRP.Format(SRP.KeyLengthMustBeMultipleOfEight, keySizeInBits)));

System\ServiceModel\Security\Tokens\ClaimTypeRequirement.cs (1)

26throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("claimType", SRP.ClaimTypeCannotBeEmpty);

System\ServiceModel\Security\Tokens\DerivedKeySecurityToken.cs (11)

System\ServiceModel\Security\Tokens\IssuedSecurityTokenParameters.cs (1)

118throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(value), SRP.ValueMustBeNonNegative));

System\ServiceModel\Security\Tokens\SecurityContextSecurityToken.cs (3)

141throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("validFrom", SRP.EffectiveGreaterThanExpiration); 150throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("keyEffectiveTime", SRP.EffectiveGreaterThanExpiration); 154throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.KeyLifetimeNotWithinTokenLifetime);

System\ServiceModel\Security\Tokens\SecurityTokenParameters.cs (7)

61throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.SecurityTokenParametersCloneInvalidResult, GetType().ToString()))); 86SRP.Format(SRP.TokenDoesNotSupportKeyIdentifierClauseCreation, token.GetType().Name, referenceStyle))); 114throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.UnableToCreateTokenReference)); 135SRP.Format(SRP.TokenDoesNotSupportKeyIdentifierClauseCreation, token.GetType().Name, referenceStyle)));

System\ServiceModel\Security\TransportSecurityProtocol.cs (4)

92throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.MessageSecurityVerificationFailed, e)); 129SRP.UnableToFindSecurityHeaderInMessageNoActor), message); 134SRP.Format(SRP.UnableToFindSecurityHeaderInMessage, actor)), message);

System\ServiceModel\Security\TrustDriver.cs (4)

35throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.TrustDriverVersionDoesNotSupportIssuedTokens)); 44throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.TrustDriverVersionDoesNotSupportIssuedTokens)); 68throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.TrustDriverVersionDoesNotSupportSession)); 79throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.TrustDriverVersionDoesNotSupportSession));

System\ServiceModel\Security\UserNamePasswordClientCredential.cs (1)

61throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly));

System\ServiceModel\Security\WindowsClientCredential.cs (3)

48throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.UnsupportedTokenImpersonationLevel, "AllowedImpersonationLevel", value.ToString()))); 96throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ObjectIsReadOnly));

System\ServiceModel\Security\WSKeyInfoSerializer.cs (1)

32throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(securityVersion), SRP.MessageSecurityVersionOutOfRange));

System\ServiceModel\Security\WSSecureConversation.cs (15)

System\ServiceModel\Security\WSSecurityJan2004.cs (7)

122throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.UnknownEncodingInBinarySecurityToken)); 150throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.UnknownEncodingInBinarySecurityToken)); 321throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.Format(SRP.UnsupportedPasswordType, type))); 384throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.CantInferReferenceForToken, ValueTypeAbsoluteUri))); 392throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.InvalidX509RawData));

System\ServiceModel\Security\WSSecurityOneDotZeroSendSecurityHeader.cs (14)

101throw TraceUtility.ThrowHelperError(new MessageSecurityException(SRP.ElementToSignMustHaveId), Message); 259throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SRP.TransportSecuredMessageHasMoreThanOneToHeader)); 371throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.TimestampToSignHasNoId)); 391throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.TransportSecurityRequireToHeader)); 408throw TraceUtility.ThrowHelperError(new MessageSecurityException(SRP.NoPartsOfMessageMatchedPartsToSign), Message); 504new MessageSecurityException(SRP.Format(SRP.UnsupportedCanonicalizationAlgorithm, suite.DefaultCanonicalizationAlgorithm))); 551SRP.Format(SRP.UnableToCreateKeyedHashAlgorithm, symmetricKey, algorithmName))); 560SRP.Format(SRP.UnknownICryptoType, _signingKey))); 567SRP.Format(SRP.UnableToCreateHashAlgorithmFromAsymmetricCrypto, algorithmName, 593throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.ElementToSignMustHaveId));

System\ServiceModel\Security\WSSecurityTokenSerializer.cs (16)

System\ServiceModel\Security\WSTrust.cs (40)

System\ServiceModel\Security\WSTrustFeb2005.cs (2)

136throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.TrustDriverIsUnableToCreatedNecessaryAttachedOrUnattachedReferences, issuedTokenXml.ToString())));

System\ServiceModel\Security\X509CertificateInitiatorClientCredential.cs (2)

84throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.ObjectIsReadOnly)));

System\ServiceModel\Security\X509CertificateRecipientClientCredential.cs (2)

132throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.ObjectIsReadOnly)));

System\ServiceModel\Security\X509ServiceCertificateAuthentication.cs (5)

71throw ExceptionHelper.PlatformNotSupported(SRP.PeerTrustNotSupportedOnOSX); 157throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.MissingCustomCertificateValidator))); 171throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRP.Format(SRP.ObjectIsReadOnly)));

System\ServiceModel\Security\XmlHelper.cs (32)

System\ServiceModel\ServiceChannelManager.cs (2)

95throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SRP.SfxCloseTimedOutWaitingForDispatchToComplete)); 129throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SRP.SfxCloseTimedOutWaitingForDispatchToComplete));

System\ServiceModel\ServiceContractAttribute.cs (2)

33SRP.SFxConfigurationNameCannotBeEmpty)); 51SRP.SFxNameCannotBeEmpty));

System\ServiceModel\SpnEndpointIdentity.cs (4)

33throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.Format(SRP.UnrecognizedClaimTypeForIdentity, identity.ClaimType, ClaimTypes.Spn)); 50new ArgumentOutOfRangeException(nameof(value), value.Ticks, SRP.Format(SRP.ValueMustBeNonNegative)));

System\ServiceModel\SynchronizedCollection.cs (9)

83SRP.Format(SRP.ValueMustBeInRange, 0, Items.Count - 1))); 147SRP.Format(SRP.ValueMustBeInRange, 0, Items.Count))); 190SRP.Format(SRP.ValueMustBeInRange, 0, Items.Count - 1))); 309throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.SynchronizedCollectionWrongTypeNull)); 314throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.Format(SRP.SynchronizedCollectionWrongType1, value.GetType().FullName)));

System\ServiceModel\SynchronizedKeyedCollection.cs (4)

48SRP.Format(SRP.ValueMustBeInRange, -1, int.MaxValue))); 112throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.CannotAddTwoItemsWithTheSameKeyToSynchronizedKeyedCollection0)); 124throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SRP.ItemDoesNotExistInSynchronizedKeyedCollection0));

System\ServiceModel\SynchronizedReadOnlyCollection.cs (4)

119throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.SFxCollectionReadOnly)); 180throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SRP.SFxCopyToRequiresICollection)); 273string message = SRP.Format(SRP.SFxCollectionWrongType2, type.ToString(), typeof(T).ToString());

System\ServiceModel\UpnEndpointIdentity.cs (2)

36throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SRP.Format(SRP.UnrecognizedClaimTypeForIdentity, identity.ClaimType, ClaimTypes.Upn));

System\ServiceModel\UriSchemeKeyedCollection.cs (8)

40throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("item", SRP.Format(SRP.BaseAddressDuplicateScheme, item.Scheme)); 53throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("item", SRP.Format(SRP.BaseAddressDuplicateScheme, item.Scheme)); 68throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(argumentName, SRP.BaseAddressMustBeAbsolute); 73throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(argumentName, SRP.BaseAddressCannotHaveUserInfo); 78throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(argumentName, SRP.BaseAddressCannotHaveQuery); 83throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(argumentName, SRP.BaseAddressCannotHaveFragment);

System\ServiceModel\X509CertificateEndpointIdentity.cs (4)

58throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.UnexpectedEmptyElementExpectingClaim, XD.AddressingDictionary.X509v3Certificate.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value))); 80throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.UnexpectedEmptyElementExpectingClaim, XD.AddressingDictionary.X509v3Certificate.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value)));

System\ServiceModel\XmlBuffer.cs (3)

55SRP.ValueMustBeNonNegative)); 59_stream = new BufferManagerOutputStream(SRP.XmlBufferQuotaExceeded, initialBufferSize, maxBufferSize, 131return new InvalidOperationException(SRP.XmlBufferInInvalidState);

System\ServiceModel\XmlUtil.cs (9)

30throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.XmlLangAttributeMissing)); 130throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.InvalidXmlQualifiedName, qname))); 139throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SRP.Format(SRP.UnboundPrefixInQName, qname))); 158throw new XmlException(SRP.Format(SRP.XmlInvalidConversion, string.Empty, "DateTime"), exception); 162throw new XmlException(SRP.Format(SRP.XmlInvalidConversion, string.Empty, "DateTime"), exception);