PR feedback. Return null instead of throwing an exception

GeoK · GeoK · commit 440128cbdea7 · 2018-12-31T14:54:15.000-08:00
diff --git a/src/Microsoft.IdentityModel.Tokens.Saml/Saml2/Saml2Assertion.cs b/src/Microsoft.IdentityModel.Tokens.Saml/Saml2/Saml2Assertion.cs
@@ -64,14 +64,14 @@ public Saml2Assertion(Saml2NameIdentifier issuer)
 
         /// <summary>
         /// Gets or sets the <see cref="Signature"/> on the Assertion.
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         public Signature Signature
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Signature))));
+                    return null;
 
                 return _signature;
             }
@@ -82,14 +82,14 @@ public Signature Signature
         /// Gets or sets additional information related to the assertion that assists processing in certain
         /// situations but which may be ignored by applications that do not understand the 
         /// advice or do not wish to make use of it. [Saml2Core, 2.3.3]
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         public Saml2Advice Advice
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Advice))));
+                    return null;
 
                 return _advice;
             }
@@ -99,14 +99,14 @@ public Saml2Advice Advice
         /// <summary>
         /// Gets or sets conditions that must be evaluated when assessing the validity of and/or
         /// when using the assertion. [Saml2Core 2.3.3]
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         public Saml2Conditions Conditions
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Conditions))));
+                    return null;
 
                 return _conditions;
             }
@@ -115,15 +115,15 @@ public Saml2Conditions Conditions
 
         /// <summary>
         /// Gets or sets the <see cref="Saml2Id"/> identifier for this assertion. [Saml2Core, 2.3.3]
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         /// <exception cref="ArgumentNullException">if 'value' if null.</exception>
         public Saml2Id Id
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Id))));
+                    return null;
 
                 return _id;
             }
@@ -132,15 +132,15 @@ public Saml2Id Id
 
         /// <summary>
         /// Gets or sets the time instant of issue in UTC. [Saml2Core, 2.3.3]
+        /// Returns <see cref="DateTime.MinValue"/> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         /// <exception cref="ArgumentNullException">if 'value' if null.</exception>
         public DateTime IssueInstant
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(IssueInstant))));
+                    return DateTime.MinValue;
 
                 return _issueInstant;
             }
@@ -155,15 +155,15 @@ public DateTime IssueInstant
 
         /// <summary>
         /// Gets or sets the <see cref="Saml2NameIdentifier"/> as the authority that is making the claim(s) in the assertion. [Saml2Core, 2.3.3]
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         /// <exception cref="ArgumentNullException">if 'value' if null.</exception>
         public Saml2NameIdentifier Issuer
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Issuer))));
+                    return null;
 
                 return _issuer;
             }
@@ -172,14 +172,14 @@ public Saml2NameIdentifier Issuer
 
         /// <summary>
         /// Gets or sets the a PrefixList to use when there is a need to include InclusiveNamespaces writing token.
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         public string InclusiveNamespacesPrefixList
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(InclusiveNamespacesPrefixList))));
+                    return null;
 
                 return _inclusiveNamespacesPrefixList;
             }
@@ -188,14 +188,14 @@ public string InclusiveNamespacesPrefixList
 
         /// <summary>
         /// Gets or sets the <see cref="SigningCredentials"/> used by the issuer to protect the integrity of the assertion.
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         public SigningCredentials SigningCredentials
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(SigningCredentials))));
+                    return null;
 
                 return _signingCredentials;
             }
@@ -204,14 +204,14 @@ public SigningCredentials SigningCredentials
 
         /// <summary>
         /// Gets or sets the <see cref="Saml2Subject"/> of the statement(s) in the assertion. [Saml2Core, 2.3.3]
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         public Saml2Subject Subject
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Subject))));
+                    return null;
 
                 return _subject;
             }
@@ -221,14 +221,14 @@ public Saml2Subject Subject
 
         /// <summary>
         /// Gets the <see cref="Saml2Statement"/>(s) regarding the subject.
+        /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.
         /// </summary>
-        /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>
         public ICollection<Saml2Statement> Statements
         {
             get
             {
                 if (Encrypted)
-                    throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Statements))));
+                    return null;
 
                 return _statements;
             }
diff --git a/test/Microsoft.IdentityModel.Tokens.Saml.Tests/Saml2SecurityTokenHandlerTests.cs b/test/Microsoft.IdentityModel.Tokens.Saml.Tests/Saml2SecurityTokenHandlerTests.cs
@@ -1069,96 +1069,84 @@ public static TheoryData<Saml2TheoryData> AccessEncryptedAssertionTheoryData
                 {
                     First = true,
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Advice" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'Advice'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Advice" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_Advice",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Conditions" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'Conditions'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Conditions" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_Conditions",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Id" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'Id'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Id" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_Id",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "IssueInstant" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'IssueInstant'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "IssueInstant" }, { "AssertionPropertyExpectedValue", DateTime.MinValue } },
                     TestId = "EncryptedAssertion_Access_IssueInstantConditions",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Issuer" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'Issuer'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Issuer" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_Issuer",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "InclusiveNamespacesPrefixList" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'InclusiveNamespacesPrefixList'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "InclusiveNamespacesPrefixList" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_InclusiveNamespacesPrefixList",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "SigningCredentials" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'SigningCredentials'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "SigningCredentials" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_SigningCredentials",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Subject" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'Subject'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Subject" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_Subject",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Statements" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'Statements'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Statements" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_Statements",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
-                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Signature" } },
-                    ExpectedException = new ExpectedException(typeof(Saml2SecurityTokenEncryptedAssertionException), "IDX13608: Saml2Assertion is encrypted. Unable to get 'Signature'"),
+                    PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Signature" }, { "AssertionPropertyExpectedValue", null } },
                     TestId = "EncryptedAssertion_Access_Signature",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
                     PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "Version" }, { "AssertionPropertyExpectedValue", "2.0" } },
-                    ExpectedException = ExpectedException.NoExceptionExpected,
                     TestId = "EncryptedAssertion_Access_Version",
                 });
 
                 theoryData.Add(new Saml2TheoryData
                 {
                     Token = ReferenceTokens.Saml2Token_EncryptedAssertion_SessionKey_Valid,
                     PropertyBag = new Dictionary<string, object> { { "AssertionPropertyName", "EncryptingCredentials" }, { "AssertionPropertyExpectedValue", null} },
-                    ExpectedException = ExpectedException.NoExceptionExpected,
                     TestId = "EncryptedAssertion_Access_EncryptingCredentials",
                 });
 

Original file line number	Diff line number	Diff line change
`@@ -64,14 +64,14 @@ public Saml2Assertion(Saml2NameIdentifier issuer)`
`64`	`64`
`65`	`65`	`/// <summary>`
`66`	`66`	`/// Gets or sets the <see cref="Signature"/> on the Assertion.`
	`67`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`67`	`68`	`/// </summary>`
`68`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`69`	`69`	`public Signature Signature`
`70`	`70`	`{`
`71`	`71`	`get`
`72`	`72`	`{`
`73`	`73`	`if (Encrypted)`
`74`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Signature))));`
	`74`	`+ return null;`
`75`	`75`
`76`	`76`	`return _signature;`
`77`	`77`	`}`
`@@ -82,14 +82,14 @@ public Signature Signature`
`82`	`82`	`/// Gets or sets additional information related to the assertion that assists processing in certain`
`83`	`83`	`/// situations but which may be ignored by applications that do not understand the`
`84`	`84`	`/// advice or do not wish to make use of it. [Saml2Core, 2.3.3]`
	`85`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`85`	`86`	`/// </summary>`
`86`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`87`	`87`	`public Saml2Advice Advice`
`88`	`88`	`{`
`89`	`89`	`get`
`90`	`90`	`{`
`91`	`91`	`if (Encrypted)`
`92`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Advice))));`
	`92`	`+ return null;`
`93`	`93`
`94`	`94`	`return _advice;`
`95`	`95`	`}`
`@@ -99,14 +99,14 @@ public Saml2Advice Advice`
`99`	`99`	`/// <summary>`
`100`	`100`	`/// Gets or sets conditions that must be evaluated when assessing the validity of and/or`
`101`	`101`	`/// when using the assertion. [Saml2Core 2.3.3]`
	`102`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`102`	`103`	`/// </summary>`
`103`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`104`	`104`	`public Saml2Conditions Conditions`
`105`	`105`	`{`
`106`	`106`	`get`
`107`	`107`	`{`
`108`	`108`	`if (Encrypted)`
`109`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Conditions))));`
	`109`	`+ return null;`
`110`	`110`
`111`	`111`	`return _conditions;`
`112`	`112`	`}`
`@@ -115,15 +115,15 @@ public Saml2Conditions Conditions`
`115`	`115`
`116`	`116`	`/// <summary>`
`117`	`117`	`/// Gets or sets the <see cref="Saml2Id"/> identifier for this assertion. [Saml2Core, 2.3.3]`
	`118`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`118`	`119`	`/// </summary>`
`119`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`120`	`120`	`/// <exception cref="ArgumentNullException">if 'value' if null.</exception>`
`121`	`121`	`public Saml2Id Id`
`122`	`122`	`{`
`123`	`123`	`get`
`124`	`124`	`{`
`125`	`125`	`if (Encrypted)`
`126`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Id))));`
	`126`	`+ return null;`
`127`	`127`
`128`	`128`	`return _id;`
`129`	`129`	`}`
`@@ -132,15 +132,15 @@ public Saml2Id Id`
`132`	`132`
`133`	`133`	`/// <summary>`
`134`	`134`	`/// Gets or sets the time instant of issue in UTC. [Saml2Core, 2.3.3]`
	`135`	`+ /// Returns <see cref="DateTime.MinValue"/> if the <see cref="Saml2Assertion"/> is encrypted.`
`135`	`136`	`/// </summary>`
`136`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`137`	`137`	`/// <exception cref="ArgumentNullException">if 'value' if null.</exception>`
`138`	`138`	`public DateTime IssueInstant`
`139`	`139`	`{`
`140`	`140`	`get`
`141`	`141`	`{`
`142`	`142`	`if (Encrypted)`
`143`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(IssueInstant))));`
	`143`	`+ return DateTime.MinValue;`
`144`	`144`
`145`	`145`	`return _issueInstant;`
`146`	`146`	`}`
`@@ -155,15 +155,15 @@ public DateTime IssueInstant`
`155`	`155`
`156`	`156`	`/// <summary>`
`157`	`157`	`/// Gets or sets the <see cref="Saml2NameIdentifier"/> as the authority that is making the claim(s) in the assertion. [Saml2Core, 2.3.3]`
	`158`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`158`	`159`	`/// </summary>`
`159`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`160`	`160`	`/// <exception cref="ArgumentNullException">if 'value' if null.</exception>`
`161`	`161`	`public Saml2NameIdentifier Issuer`
`162`	`162`	`{`
`163`	`163`	`get`
`164`	`164`	`{`
`165`	`165`	`if (Encrypted)`
`166`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Issuer))));`
	`166`	`+ return null;`
`167`	`167`
`168`	`168`	`return _issuer;`
`169`	`169`	`}`
`@@ -172,14 +172,14 @@ public Saml2NameIdentifier Issuer`
`172`	`172`
`173`	`173`	`/// <summary>`
`174`	`174`	`/// Gets or sets the a PrefixList to use when there is a need to include InclusiveNamespaces writing token.`
	`175`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`175`	`176`	`/// </summary>`
`176`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`177`	`177`	`public string InclusiveNamespacesPrefixList`
`178`	`178`	`{`
`179`	`179`	`get`
`180`	`180`	`{`
`181`	`181`	`if (Encrypted)`
`182`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(InclusiveNamespacesPrefixList))));`
	`182`	`+ return null;`
`183`	`183`
`184`	`184`	`return _inclusiveNamespacesPrefixList;`
`185`	`185`	`}`
`@@ -188,14 +188,14 @@ public string InclusiveNamespacesPrefixList`
`188`	`188`
`189`	`189`	`/// <summary>`
`190`	`190`	`/// Gets or sets the <see cref="SigningCredentials"/> used by the issuer to protect the integrity of the assertion.`
	`191`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`191`	`192`	`/// </summary>`
`192`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`193`	`193`	`public SigningCredentials SigningCredentials`
`194`	`194`	`{`
`195`	`195`	`get`
`196`	`196`	`{`
`197`	`197`	`if (Encrypted)`
`198`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(SigningCredentials))));`
	`198`	`+ return null;`
`199`	`199`
`200`	`200`	`return _signingCredentials;`
`201`	`201`	`}`
`@@ -204,14 +204,14 @@ public SigningCredentials SigningCredentials`
`204`	`204`
`205`	`205`	`/// <summary>`
`206`	`206`	`/// Gets or sets the <see cref="Saml2Subject"/> of the statement(s) in the assertion. [Saml2Core, 2.3.3]`
	`207`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`207`	`208`	`/// </summary>`
`208`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`209`	`209`	`public Saml2Subject Subject`
`210`	`210`	`{`
`211`	`211`	`get`
`212`	`212`	`{`
`213`	`213`	`if (Encrypted)`
`214`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Subject))));`
	`214`	`+ return null;`
`215`	`215`
`216`	`216`	`return _subject;`
`217`	`217`	`}`
`@@ -221,14 +221,14 @@ public Saml2Subject Subject`
`221`	`221`
`222`	`222`	`/// <summary>`
`223`	`223`	`/// Gets the <see cref="Saml2Statement"/>(s) regarding the subject.`
	`224`	`+ /// Returns <c>null</c> if the <see cref="Saml2Assertion"/> is encrypted.`
`224`	`225`	`/// </summary>`
`225`		`- /// <exception cref="Saml2SecurityTokenEncryptedAssertionException"> If this assertion is encrypted.</exception>`
`226`	`226`	`public ICollection<Saml2Statement> Statements`
`227`	`227`	`{`
`228`	`228`	`get`
`229`	`229`	`{`
`230`	`230`	`if (Encrypted)`
`231`		`- throw LogExceptionMessage(new Saml2SecurityTokenEncryptedAssertionException(FormatInvariant(LogMessages.IDX13608, nameof(Statements))));`
	`231`	`+ return null;`
`232`	`232`
`233`	`233`	`return _statements;`
`234`	`234`	`}`