internal static void WriteSecurityKeyIdentifier(XmlWriter writer, SecurityKeyIdentifier ski, SecurityTokenSerializer tokenSerializer)
        {
            if (tokenSerializer == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("tokenSerializer", SR.GetString(SR.SamlSerializerRequiresExternalSerializers));

            bool keyWritten = false;
            if (tokenSerializer.CanWriteKeyIdentifier(ski))
            {
                tokenSerializer.WriteKeyIdentifier(writer, ski);
                keyWritten = true;
            }

            if (!keyWritten)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SamlSerializerUnableToWriteSecurityKeyIdentifier, ski.ToString())));
        }
        /// <summary>
        /// Writes the EncryptedData element
        /// </summary>
        /// <param name="writer"></param>
        /// <param name="securityTokenSerializer"></param>
        /// <exception cref="ArgumentNullException">When securityTokenSerializer is null</exception>
        /// <exception cref="InvalidOperationException">When KeyIdentifier is null</exception>
        public virtual void WriteXml( XmlWriter writer, SecurityTokenSerializer securityTokenSerializer )
        {
            if ( writer == null )
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "writer" );
            }

            if ( securityTokenSerializer == null )
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "securityTokenSerializer" );
            }

            if ( KeyIdentifier == null )
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR.GetString( SR.ID6001 ) ) );
            }

            // <EncryptedData>
            writer.WriteStartElement( XmlEncryptionConstants.Prefix, XmlEncryptionConstants.Elements.EncryptedData, XmlEncryptionConstants.Namespace );

            if ( !string.IsNullOrEmpty( Id ) )
            {
                writer.WriteAttributeString( XmlEncryptionConstants.Attributes.Id, null, Id );
            }

            if ( !string.IsNullOrEmpty( Type ) )
            {
                writer.WriteAttributeString( XmlEncryptionConstants.Attributes.Type, null, Type );
            }

            if ( EncryptionMethod != null )
            {
                EncryptionMethod.WriteXml( writer );
            }

            if ( KeyIdentifier != null )
            {
                securityTokenSerializer.WriteKeyIdentifier( XmlDictionaryWriter.CreateDictionaryWriter( writer ), KeyIdentifier );
            }

            CipherData.WriteXml( writer );

            // <EncryptedData> 
            writer.WriteEndElement();
        }
 internal static void WriteSecurityKeyIdentifier(XmlWriter writer, SecurityKeyIdentifier ski, SecurityTokenSerializer tokenSerializer)
 {
     if (tokenSerializer == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("tokenSerializer", System.IdentityModel.SR.GetString("SamlSerializerRequiresExternalSerializers"));
     }
     bool flag = false;
     if (tokenSerializer.CanWriteKeyIdentifier(ski))
     {
         tokenSerializer.WriteKeyIdentifier(writer, ski);
         flag = true;
     }
     if (!flag)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.IdentityModel.SR.GetString("SamlSerializerUnableToWriteSecurityKeyIdentifier", new object[] { ski.ToString() })));
     }
 }