9 files changed, 257 insertions, 366 deletions

diff --git a/crypto/src/asn1/esf/CertificateValues.cs b/crypto/src/asn1/esf/CertificateValues.cs
index ee0d2830c..8329e45f8 100644
--- a/crypto/src/asn1/esf/CertificateValues.cs
+++ b/crypto/src/asn1/esf/CertificateValues.cs
@@ -15,69 +15,58 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class CertificateValues
 		: Asn1Encodable
 	{
-		private readonly Asn1Sequence certificates;
+		private readonly Asn1Sequence m_certificates;
 
-		public static CertificateValues GetInstance(
-			object obj)
+		public static CertificateValues GetInstance(object obj)
 		{
-			if (obj == null || obj is CertificateValues)
-				return (CertificateValues) obj;
+			if (obj == null)
+				return null;
 
-			if (obj is Asn1Sequence)
-				return new CertificateValues((Asn1Sequence) obj);
+			if (obj is CertificateValues certificateValues)
+				return certificateValues;
 
-			throw new ArgumentException(
-				"Unknown object in 'CertificateValues' factory: "
-                    + Platform.GetTypeName(obj),
-				"obj");
+			if (obj is Asn1Sequence asn1Sequence)
+				return new CertificateValues(asn1Sequence);
+
+			throw new ArgumentException("Unknown object in 'CertificateValues' factory: " + Platform.GetTypeName(obj),
+				nameof(obj));
 		}
 
-		private CertificateValues(
-			Asn1Sequence seq)
+		private CertificateValues(Asn1Sequence seq)
 		{
 			if (seq == null)
-				throw new ArgumentNullException("seq");
+				throw new ArgumentNullException(nameof(seq));
 
-			foreach (Asn1Encodable ae in seq)
-			{
-				X509CertificateStructure.GetInstance(ae.ToAsn1Object());
-			}
+			// Validate
+            seq.MapElements(element => X509CertificateStructure.GetInstance(element.ToAsn1Object()));
 
-			this.certificates = seq;
+			m_certificates = seq;
 		}
 
-		public CertificateValues(
-			params X509CertificateStructure[] certificates)
+		public CertificateValues(params X509CertificateStructure[] certificates)
 		{
 			if (certificates == null)
-				throw new ArgumentNullException("certificates");
+				throw new ArgumentNullException(nameof(certificates));
 
-			this.certificates = new DerSequence(certificates);
+			m_certificates = new DerSequence(certificates);
 		}
 
-		public CertificateValues(
-			IEnumerable<X509CertificateStructure> certificates)
+		public CertificateValues(IEnumerable<X509CertificateStructure> certificates)
 		{
 			if (certificates == null)
-				throw new ArgumentNullException("certificates");
+                throw new ArgumentNullException(nameof(certificates));
 
-			this.certificates = new DerSequence(
-				Asn1EncodableVector.FromEnumerable(certificates));
+            m_certificates = new DerSequence(Asn1EncodableVector.FromEnumerable(certificates));
 		}
 
 		public X509CertificateStructure[] GetCertificates()
 		{
-			X509CertificateStructure[] result = new X509CertificateStructure[certificates.Count];
-			for (int i = 0; i < certificates.Count; ++i)
-			{
-				result[i] = X509CertificateStructure.GetInstance(certificates[i]);
-			}
-			return result;
+			return m_certificates.MapElements(element => X509CertificateStructure.GetInstance(element.ToAsn1Object()));
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
-			return certificates;
+			return m_certificates;
 		}
  	}
 }
diff --git a/crypto/src/asn1/esf/CompleteCertificateRefs.cs b/crypto/src/asn1/esf/CompleteCertificateRefs.cs
index 2ed66e3dc..24727dc25 100644
--- a/crypto/src/asn1/esf/CompleteCertificateRefs.cs
+++ b/crypto/src/asn1/esf/CompleteCertificateRefs.cs
@@ -14,69 +14,58 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class CompleteCertificateRefs
 		: Asn1Encodable
 	{
-		private readonly Asn1Sequence otherCertIDs;
+		private readonly Asn1Sequence m_otherCertIDs;
 
-		public static CompleteCertificateRefs GetInstance(
-			object obj)
+		public static CompleteCertificateRefs GetInstance(object obj)
 		{
-			if (obj == null || obj is CompleteCertificateRefs)
-				return (CompleteCertificateRefs) obj;
+			if (obj == null)
+				return null;
 
-			if (obj is Asn1Sequence)
-				return new CompleteCertificateRefs((Asn1Sequence) obj);
+            if (obj is CompleteCertificateRefs completeCertificateRefs)
+				return completeCertificateRefs;
 
-			throw new ArgumentException(
-				"Unknown object in 'CompleteCertificateRefs' factory: "
-                    + Platform.GetTypeName(obj),
-				"obj");
+			if (obj is Asn1Sequence asn1Sequence)
+				return new CompleteCertificateRefs(asn1Sequence);
+
+			throw new ArgumentException("Unknown object in 'CompleteCertificateRefs' factory: " + Platform.GetTypeName(obj),
+				nameof(obj));
 		}
 
-		private CompleteCertificateRefs(
-			Asn1Sequence seq)
+		private CompleteCertificateRefs(Asn1Sequence seq)
 		{
 			if (seq == null)
-				throw new ArgumentNullException("seq");
+				throw new ArgumentNullException(nameof(seq));
 
-			foreach (Asn1Encodable ae in seq)
-			{
-				OtherCertID.GetInstance(ae.ToAsn1Object());
-			}
+            // Validate
+            seq.MapElements(element => OtherCertID.GetInstance(element.ToAsn1Object()));
 
-			this.otherCertIDs = seq;
+            m_otherCertIDs = seq;
 		}
 
-		public CompleteCertificateRefs(
-			params OtherCertID[] otherCertIDs)
+		public CompleteCertificateRefs(params OtherCertID[] otherCertIDs)
 		{
 			if (otherCertIDs == null)
-				throw new ArgumentNullException("otherCertIDs");
+				throw new ArgumentNullException(nameof(otherCertIDs));
 
-			this.otherCertIDs = new DerSequence(otherCertIDs);
+			m_otherCertIDs = new DerSequence(otherCertIDs);
 		}
 
-		public CompleteCertificateRefs(
-			IEnumerable<OtherCertID> otherCertIDs)
+		public CompleteCertificateRefs(IEnumerable<OtherCertID> otherCertIDs)
 		{
 			if (otherCertIDs == null)
-				throw new ArgumentNullException("otherCertIDs");
+                throw new ArgumentNullException(nameof(otherCertIDs));
 
-			this.otherCertIDs = new DerSequence(
-				Asn1EncodableVector.FromEnumerable(otherCertIDs));
+            m_otherCertIDs = new DerSequence(Asn1EncodableVector.FromEnumerable(otherCertIDs));
 		}
 
 		public OtherCertID[] GetOtherCertIDs()
 		{
-			OtherCertID[] result = new OtherCertID[otherCertIDs.Count];
-			for (int i = 0; i < otherCertIDs.Count; ++i)
-			{
-				result[i] = OtherCertID.GetInstance(otherCertIDs[i].ToAsn1Object());
-			}
-			return result;
+            return m_otherCertIDs.MapElements(element => OtherCertID.GetInstance(element.ToAsn1Object()));
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
-			return otherCertIDs;
+			return m_otherCertIDs;
 		}
 	}
 }
diff --git a/crypto/src/asn1/esf/CompleteRevocationRefs.cs b/crypto/src/asn1/esf/CompleteRevocationRefs.cs
index 9942cec8f..2c120f0f9 100644
--- a/crypto/src/asn1/esf/CompleteRevocationRefs.cs
+++ b/crypto/src/asn1/esf/CompleteRevocationRefs.cs
@@ -14,69 +14,58 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class CompleteRevocationRefs
 		: Asn1Encodable
 	{
-		private readonly Asn1Sequence crlOcspRefs;
+		private readonly Asn1Sequence m_crlOcspRefs;
 
-		public static CompleteRevocationRefs GetInstance(
-			object obj)
+		public static CompleteRevocationRefs GetInstance(object obj)
 		{
-			if (obj == null || obj is CompleteRevocationRefs)
-				return (CompleteRevocationRefs) obj;
+			if (obj == null)
+				return null;
 
-			if (obj is Asn1Sequence)
-				return new CompleteRevocationRefs((Asn1Sequence) obj);
+			if (obj is CompleteRevocationRefs completeRevocationRefs)
+				return completeRevocationRefs;
 
-			throw new ArgumentException(
-				"Unknown object in 'CompleteRevocationRefs' factory: "
-                    + Platform.GetTypeName(obj),
-				"obj");
+			if (obj is Asn1Sequence asn1Sequence)
+				return new CompleteRevocationRefs(asn1Sequence);
+
+			throw new ArgumentException("Unknown object in 'CompleteRevocationRefs' factory: " + Platform.GetTypeName(obj),
+				nameof(obj));
 		}
 
-		private CompleteRevocationRefs(
-			Asn1Sequence seq)
+		private CompleteRevocationRefs(Asn1Sequence seq)
 		{
 			if (seq == null)
-				throw new ArgumentNullException("seq");
+				throw new ArgumentNullException(nameof(seq));
 
-			foreach (Asn1Encodable ae in seq)
-			{
-				CrlOcspRef.GetInstance(ae.ToAsn1Object());
-			}
+            // Validate
+            seq.MapElements(element => CrlOcspRef.GetInstance(element.ToAsn1Object()));
 
-			this.crlOcspRefs = seq;
+			m_crlOcspRefs = seq;
 		}
 
-		public CompleteRevocationRefs(
-			params CrlOcspRef[] crlOcspRefs)
+		public CompleteRevocationRefs(params CrlOcspRef[] crlOcspRefs)
 		{
 			if (crlOcspRefs == null)
-				throw new ArgumentNullException("crlOcspRefs");
+				throw new ArgumentNullException(nameof(crlOcspRefs));
 
-			this.crlOcspRefs = new DerSequence(crlOcspRefs);
+			m_crlOcspRefs = new DerSequence(crlOcspRefs);
 		}
 
-		public CompleteRevocationRefs(
-			IEnumerable<CrlOcspRef> crlOcspRefs)
+		public CompleteRevocationRefs(IEnumerable<CrlOcspRef> crlOcspRefs)
 		{
 			if (crlOcspRefs == null)
-				throw new ArgumentNullException("crlOcspRefs");
+                throw new ArgumentNullException(nameof(crlOcspRefs));
 
-			this.crlOcspRefs = new DerSequence(
-				Asn1EncodableVector.FromEnumerable(crlOcspRefs));
+            m_crlOcspRefs = new DerSequence(Asn1EncodableVector.FromEnumerable(crlOcspRefs));
 		}
 
 		public CrlOcspRef[] GetCrlOcspRefs()
 		{
-			CrlOcspRef[] result = new CrlOcspRef[crlOcspRefs.Count];
-			for (int i = 0; i < crlOcspRefs.Count; ++i)
-			{
-				result[i] = CrlOcspRef.GetInstance(crlOcspRefs[i].ToAsn1Object());
-			}
-			return result;
+            return m_crlOcspRefs.MapElements(element => CrlOcspRef.GetInstance(element.ToAsn1Object()));
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
-			return crlOcspRefs;
+			return m_crlOcspRefs;
 		}
 	}
 }
diff --git a/crypto/src/asn1/esf/CrlIdentifier.cs b/crypto/src/asn1/esf/CrlIdentifier.cs
index 54e930acc..29003260a 100644
--- a/crypto/src/asn1/esf/CrlIdentifier.cs
+++ b/crypto/src/asn1/esf/CrlIdentifier.cs
@@ -20,9 +20,9 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class CrlIdentifier
 		: Asn1Encodable
 	{
-		private readonly X509Name crlIssuer;
-		private readonly Asn1UtcTime crlIssuedTime;
-		private readonly DerInteger crlNumber;
+		private readonly X509Name m_crlIssuer;
+		private readonly Asn1UtcTime m_crlIssuedTime;
+		private readonly DerInteger m_crlNumber;
 
 		public static CrlIdentifier GetInstance(object obj)
 		{
@@ -46,15 +46,15 @@ namespace Org.BouncyCastle.Asn1.Esf
 			if (seq.Count < 2 || seq.Count > 3)
 				throw new ArgumentException("Bad sequence size: " + seq.Count, nameof(seq));
 
-			this.crlIssuer = X509Name.GetInstance(seq[0]);
-			this.crlIssuedTime = Asn1UtcTime.GetInstance(seq[1]);
+			this.m_crlIssuer = X509Name.GetInstance(seq[0]);
+			this.m_crlIssuedTime = Asn1UtcTime.GetInstance(seq[1]);
 
             // Validate crlIssuedTime is in the appropriate year range
-            crlIssuedTime.ToDateTime(2049);
+            m_crlIssuedTime.ToDateTime(2049);
 
 			if (seq.Count > 2)
 			{
-				this.crlNumber = DerInteger.GetInstance(seq[2]);
+				this.m_crlNumber = DerInteger.GetInstance(seq[2]);
 			}
 		}
 
@@ -75,37 +75,37 @@ namespace Org.BouncyCastle.Asn1.Esf
 
         public CrlIdentifier(X509Name crlIssuer, Asn1UtcTime crlIssuedTime, BigInteger crlNumber)
         {
-            this.crlIssuer = crlIssuer ?? throw new ArgumentNullException(nameof(crlIssuer));
-            this.crlIssuedTime = crlIssuedTime ?? throw new ArgumentNullException(nameof(crlIssuedTime));
+            m_crlIssuer = crlIssuer ?? throw new ArgumentNullException(nameof(crlIssuer));
+            m_crlIssuedTime = crlIssuedTime ?? throw new ArgumentNullException(nameof(crlIssuedTime));
 
             if (null != crlNumber)
             {
-                this.crlNumber = new DerInteger(crlNumber);
+                m_crlNumber = new DerInteger(crlNumber);
             }
 
             // Validate crlIssuedTime is in the appropriate year range
-            this.crlIssuedTime.ToDateTime(2049);
+            m_crlIssuedTime.ToDateTime(2049);
         }
 
         public X509Name CrlIssuer
 		{
-			get { return crlIssuer; }
+			get { return m_crlIssuer; }
 		}
 
 		public DateTime CrlIssuedTime
 		{
-			get { return crlIssuedTime.ToDateTime(2049); }
+			get { return m_crlIssuedTime.ToDateTime(2049); }
 		}
 
 		public BigInteger CrlNumber
 		{
-			get { return crlNumber?.Value; }
+			get { return m_crlNumber?.Value; }
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
-			var v = new Asn1EncodableVector(crlIssuer.ToAsn1Object(), crlIssuedTime);
-            v.AddOptional(crlNumber);
+			var v = new Asn1EncodableVector(m_crlIssuer.ToAsn1Object(), m_crlIssuedTime);
+            v.AddOptional(m_crlNumber);
 			return new DerSequence(v);
 		}
 	}
diff --git a/crypto/src/asn1/esf/CrlListID.cs b/crypto/src/asn1/esf/CrlListID.cs
index d3c4365c5..1ee58aebc 100644
--- a/crypto/src/asn1/esf/CrlListID.cs
+++ b/crypto/src/asn1/esf/CrlListID.cs
@@ -17,71 +17,60 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class CrlListID
 		: Asn1Encodable
 	{
-		private readonly Asn1Sequence crls;
+		private readonly Asn1Sequence m_crls;
 
-		public static CrlListID GetInstance(
-			object obj)
+		public static CrlListID GetInstance(object obj)
 		{
-			if (obj == null || obj is CrlListID)
-				return (CrlListID) obj;
+			if (obj == null)
+				return null;
 
-			if (obj is Asn1Sequence)
-				return new CrlListID((Asn1Sequence) obj);
+			if (obj is CrlListID crlListID)
+				return crlListID;
 
-			throw new ArgumentException(
-				"Unknown object in 'CrlListID' factory: "
-                    + Platform.GetTypeName(obj),
-				"obj");
+			if (obj is Asn1Sequence asn1Sequence)
+				return new CrlListID(asn1Sequence);
+
+			throw new ArgumentException("Unknown object in 'CrlListID' factory: " + Platform.GetTypeName(obj),
+				nameof(obj));
 		}
 
-		private CrlListID(
-			Asn1Sequence seq)
+		private CrlListID(Asn1Sequence seq)
 		{
 			if (seq == null)
-				throw new ArgumentNullException("seq");
+				throw new ArgumentNullException(nameof(seq));
 			if (seq.Count != 1)
-				throw new ArgumentException("Bad sequence size: " + seq.Count, "seq");
+				throw new ArgumentException("Bad sequence size: " + seq.Count, nameof(seq));
 
-			this.crls = (Asn1Sequence) seq[0].ToAsn1Object();
+			m_crls = (Asn1Sequence)seq[0].ToAsn1Object();
 
-			foreach (Asn1Encodable ae in this.crls)
-			{
-				CrlValidatedID.GetInstance(ae.ToAsn1Object());
-			}
+			// Validate
+			m_crls.MapElements(element => CrlValidatedID.GetInstance(element.ToAsn1Object()));
 		}
 
-		public CrlListID(
-			params CrlValidatedID[] crls)
+		public CrlListID(params CrlValidatedID[] crls)
 		{
 			if (crls == null)
-				throw new ArgumentNullException("crls");
+				throw new ArgumentNullException(nameof(crls));
 
-			this.crls = new DerSequence(crls);
+			this.m_crls = new DerSequence(crls);
 		}
 
-		public CrlListID(
-			IEnumerable<CrlValidatedID> crls)
+		public CrlListID(IEnumerable<CrlValidatedID> crls)
 		{
 			if (crls == null)
-				throw new ArgumentNullException("crls");
+                throw new ArgumentNullException(nameof(crls));
 
-			this.crls = new DerSequence(
-				Asn1EncodableVector.FromEnumerable(crls));
+            this.m_crls = new DerSequence(Asn1EncodableVector.FromEnumerable(crls));
 		}
 
 		public CrlValidatedID[] GetCrls()
 		{
-			CrlValidatedID[] result = new CrlValidatedID[crls.Count];
-			for (int i = 0; i < crls.Count; ++i)
-			{
-				result[i] = CrlValidatedID.GetInstance(crls[i].ToAsn1Object());
-			}
-			return result;
+            return m_crls.MapElements(element => CrlValidatedID.GetInstance(element.ToAsn1Object()));
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
-			return new DerSequence(crls);
+			return new DerSequence(m_crls);
 		}
 	}
 }
diff --git a/crypto/src/asn1/esf/OcspListID.cs b/crypto/src/asn1/esf/OcspListID.cs
index 3918dfd42..974962571 100644
--- a/crypto/src/asn1/esf/OcspListID.cs
+++ b/crypto/src/asn1/esf/OcspListID.cs
@@ -16,71 +16,60 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class OcspListID
 		: Asn1Encodable
 	{
-		private readonly Asn1Sequence ocspResponses;
+		private readonly Asn1Sequence m_ocspResponses;
 
-		public static OcspListID GetInstance(
-			object obj)
+		public static OcspListID GetInstance(object obj)
 		{
-			if (obj == null || obj is OcspListID)
-				return (OcspListID) obj;
+			if (obj == null)
+				return null;
 
-			if (obj is Asn1Sequence)
-				return new OcspListID((Asn1Sequence) obj);
+			if (obj is OcspListID ocspListID)
+				return ocspListID;
 
-			throw new ArgumentException(
-				"Unknown object in 'OcspListID' factory: "
-                    + Platform.GetTypeName(obj),
-				"obj");
+			if (obj is Asn1Sequence asn1Sequence)
+				return new OcspListID(asn1Sequence);
+
+			throw new ArgumentException("Unknown object in 'OcspListID' factory: " + Platform.GetTypeName(obj),
+				nameof(obj));
 		}
 
-		private OcspListID(
-			Asn1Sequence seq)
+		private OcspListID(Asn1Sequence seq)
 		{
 			if (seq == null)
-				throw new ArgumentNullException("seq");
+				throw new ArgumentNullException(nameof(seq));
 			if (seq.Count != 1)
-				throw new ArgumentException("Bad sequence size: " + seq.Count, "seq");
+				throw new ArgumentException("Bad sequence size: " + seq.Count, nameof(seq));
 
-			this.ocspResponses = (Asn1Sequence) seq[0].ToAsn1Object();
+			m_ocspResponses = (Asn1Sequence)seq[0].ToAsn1Object();
 
-			foreach (Asn1Encodable ae in this.ocspResponses)
-			{
-				OcspResponsesID.GetInstance(ae.ToAsn1Object());
-			}
+            // Validate
+            m_ocspResponses.MapElements(element => OcspResponsesID.GetInstance(element.ToAsn1Object()));
 		}
 
-		public OcspListID(
-			params OcspResponsesID[] ocspResponses)
+		public OcspListID(params OcspResponsesID[] ocspResponses)
 		{
 			if (ocspResponses == null)
-				throw new ArgumentNullException("ocspResponses");
+				throw new ArgumentNullException(nameof(ocspResponses));
 
-			this.ocspResponses = new DerSequence(ocspResponses);
+			m_ocspResponses = new DerSequence(ocspResponses);
 		}
 
-		public OcspListID(
-			IEnumerable<OcspResponsesID> ocspResponses)
+		public OcspListID(IEnumerable<OcspResponsesID> ocspResponses)
 		{
 			if (ocspResponses == null)
-				throw new ArgumentNullException("ocspResponses");
+                throw new ArgumentNullException(nameof(ocspResponses));
 
-			this.ocspResponses = new DerSequence(
-				Asn1EncodableVector.FromEnumerable(ocspResponses));
+            m_ocspResponses = new DerSequence(Asn1EncodableVector.FromEnumerable(ocspResponses));
 		}
 
 		public OcspResponsesID[] GetOcspResponses()
 		{
-			OcspResponsesID[] result = new OcspResponsesID[ocspResponses.Count];
-			for (int i = 0; i < ocspResponses.Count; ++i)
-			{
-				result[i] = OcspResponsesID.GetInstance(ocspResponses[i].ToAsn1Object());
-			}
-			return result;
+            return m_ocspResponses.MapElements(element => OcspResponsesID.GetInstance(element.ToAsn1Object()));
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
-			return new DerSequence(ocspResponses);
+			return new DerSequence(m_ocspResponses);
 		}
 	}
 }
diff --git a/crypto/src/asn1/esf/OtherSigningCertificate.cs b/crypto/src/asn1/esf/OtherSigningCertificate.cs
index a4f4a0727..aa1dcbf99 100644
--- a/crypto/src/asn1/esf/OtherSigningCertificate.cs
+++ b/crypto/src/asn1/esf/OtherSigningCertificate.cs
@@ -17,111 +17,89 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class OtherSigningCertificate
 		: Asn1Encodable
 	{
-		private readonly Asn1Sequence	certs;
-		private readonly Asn1Sequence	policies;
+		private readonly Asn1Sequence m_certs;
+		private readonly Asn1Sequence m_policies;
 
-		public static OtherSigningCertificate GetInstance(
-			object obj)
+		public static OtherSigningCertificate GetInstance(object obj)
 		{
-			if (obj == null || obj is OtherSigningCertificate)
-				return (OtherSigningCertificate) obj;
+			if (obj == null)
+				return null;
+
+			if (obj is OtherSigningCertificate otherSigningCertificate)
+				return otherSigningCertificate;
 
-			if (obj is Asn1Sequence)
-				return new OtherSigningCertificate((Asn1Sequence) obj);
+			if (obj is Asn1Sequence asn1Sequence)
+				return new OtherSigningCertificate(asn1Sequence);
 
-			throw new ArgumentException(
-				"Unknown object in 'OtherSigningCertificate' factory: "
-                    + Platform.GetTypeName(obj),
-				"obj");
+			throw new ArgumentException("Unknown object in 'OtherSigningCertificate' factory: " + Platform.GetTypeName(obj),
+				nameof(obj));
 		}
 
-		private OtherSigningCertificate(
-			Asn1Sequence seq)
+		private OtherSigningCertificate(Asn1Sequence seq)
 		{
 			if (seq == null)
-				throw new ArgumentNullException("seq");
+				throw new ArgumentNullException(nameof(seq));
 			if (seq.Count < 1 || seq.Count > 2)
-				throw new ArgumentException("Bad sequence size: " + seq.Count, "seq");
+				throw new ArgumentException("Bad sequence size: " + seq.Count, nameof(seq));
 
-			this.certs = Asn1Sequence.GetInstance(seq[0].ToAsn1Object());
+			m_certs = Asn1Sequence.GetInstance(seq[0].ToAsn1Object());
 
 			if (seq.Count > 1)
 			{
-				this.policies = Asn1Sequence.GetInstance(seq[1].ToAsn1Object());
+				m_policies = Asn1Sequence.GetInstance(seq[1].ToAsn1Object());
 			}
 		}
 
-		public OtherSigningCertificate(
-			params OtherCertID[] certs)
+		public OtherSigningCertificate(params OtherCertID[] certs)
 			: this(certs, null)
 		{
 		}
 
-		public OtherSigningCertificate(
-			OtherCertID[]				certs,
-			params PolicyInformation[]	policies)
+		public OtherSigningCertificate(OtherCertID[] certs, params PolicyInformation[] policies)
 		{
 			if (certs == null)
-				throw new ArgumentNullException("certs");
+                throw new ArgumentNullException(nameof(certs));
 
-			this.certs = new DerSequence(certs);
+            m_certs = new DerSequence(certs);
 
 			if (policies != null)
 			{
-				this.policies = new DerSequence(policies);
+				m_policies = new DerSequence(policies);
 			}
 		}
 
-		public OtherSigningCertificate(
-			IEnumerable<OtherCertID> certs)
+		public OtherSigningCertificate(IEnumerable<OtherCertID> certs)
 			: this(certs, null)
 		{
 		}
 
-		public OtherSigningCertificate(
-			IEnumerable<OtherCertID> certs,
-			IEnumerable<PolicyInformation> policies)
+		public OtherSigningCertificate(IEnumerable<OtherCertID> certs, IEnumerable<PolicyInformation> policies)
 		{
 			if (certs == null)
-				throw new ArgumentNullException("certs");
+                throw new ArgumentNullException(nameof(certs));
 
-			this.certs = new DerSequence(
-				Asn1EncodableVector.FromEnumerable(certs));
+            m_certs = new DerSequence(Asn1EncodableVector.FromEnumerable(certs));
 
 			if (policies != null)
 			{
-				this.policies = new DerSequence(
-					Asn1EncodableVector.FromEnumerable(policies));
+				m_policies = new DerSequence(Asn1EncodableVector.FromEnumerable(policies));
 			}
 		}
 
 		public OtherCertID[] GetCerts()
 		{
-			OtherCertID[] cs = new OtherCertID[certs.Count];
-			for (int i = 0; i < certs.Count; ++i)
-			{
-				cs[i] = OtherCertID.GetInstance(certs[i].ToAsn1Object());
-			}
-			return cs;
+			return m_certs.MapElements(element => OtherCertID.GetInstance(element.ToAsn1Object()));
 		}
 
 		public PolicyInformation[] GetPolicies()
 		{
-			if (policies == null)
-				return null;
-
-			PolicyInformation[] ps = new PolicyInformation[policies.Count];
-			for (int i = 0; i < policies.Count; ++i)
-			{
-				ps[i] = PolicyInformation.GetInstance(policies[i].ToAsn1Object());
-			}
-			return ps;
+            return m_policies?.MapElements(element => PolicyInformation.GetInstance(element.ToAsn1Object()));
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
-			Asn1EncodableVector v = new Asn1EncodableVector(certs);
-            v.AddOptional(policies);
+			Asn1EncodableVector v = new Asn1EncodableVector(m_certs);
+            v.AddOptional(m_policies);
 			return new DerSequence(v);
 		}
 	}
diff --git a/crypto/src/asn1/esf/RevocationValues.cs b/crypto/src/asn1/esf/RevocationValues.cs
index 682728dde..61bfd0be1 100644
--- a/crypto/src/asn1/esf/RevocationValues.cs
+++ b/crypto/src/asn1/esf/RevocationValues.cs
@@ -19,129 +19,113 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class RevocationValues
 		: Asn1Encodable
 	{
-		private readonly Asn1Sequence	crlVals;
-		private readonly Asn1Sequence	ocspVals;
-		private readonly OtherRevVals	otherRevVals;
+		private readonly Asn1Sequence m_crlVals;
+		private readonly Asn1Sequence m_ocspVals;
+		private readonly OtherRevVals m_otherRevVals;
 
-		public static RevocationValues GetInstance(
-			object obj)
+		public static RevocationValues GetInstance(object obj)
 		{
-			if (obj == null || obj is RevocationValues)
-				return (RevocationValues) obj;
+            if (obj == null)
+                return null;
+
+            if (obj is RevocationValues revocationValues)
+				return revocationValues;
 
 			return new RevocationValues(Asn1Sequence.GetInstance(obj));
 		}
 
-		private RevocationValues(
-			Asn1Sequence seq)
+		private RevocationValues(Asn1Sequence seq)
 		{
 			if (seq == null)
-				throw new ArgumentNullException("seq");
+				throw new ArgumentNullException(nameof(seq));
 			if (seq.Count > 3)
-				throw new ArgumentException("Bad sequence size: " + seq.Count, "seq");
+				throw new ArgumentException("Bad sequence size: " + seq.Count, nameof(seq));
 
 			foreach (Asn1TaggedObject taggedObj in seq)
 			{
 				Asn1Object asn1Obj = taggedObj.GetObject();
 				switch (taggedObj.TagNo)
 				{
-					case 0:
-						Asn1Sequence crlValsSeq = (Asn1Sequence) asn1Obj;
-						foreach (Asn1Encodable ae in crlValsSeq)
-						{
-							CertificateList.GetInstance(ae.ToAsn1Object());
-						}
-						this.crlVals = crlValsSeq;
-						break;
-					case 1:
-						Asn1Sequence ocspValsSeq = (Asn1Sequence) asn1Obj;
-						foreach (Asn1Encodable ae in ocspValsSeq)
-						{
-							BasicOcspResponse.GetInstance(ae.ToAsn1Object());
-						}
-						this.ocspVals = ocspValsSeq;
-						break;
-					case 2:
-						this.otherRevVals = OtherRevVals.GetInstance(asn1Obj);
-						break;
-					default:
-						throw new ArgumentException("Illegal tag in RevocationValues", "seq");
+				case 0:
+					Asn1Sequence crlValsSeq = (Asn1Sequence)asn1Obj;
+
+					// Validate
+					crlValsSeq.MapElements(element => CertificateList.GetInstance(element.ToAsn1Object()));
+
+					m_crlVals = crlValsSeq;
+					break;
+				case 1:
+					Asn1Sequence ocspValsSeq = (Asn1Sequence)asn1Obj;
+
+					// Validate
+					ocspValsSeq.MapElements(element => BasicOcspResponse.GetInstance(element.ToAsn1Object()));
+
+					m_ocspVals = ocspValsSeq;
+					break;
+				case 2:
+					m_otherRevVals = OtherRevVals.GetInstance(asn1Obj);
+					break;
+				default:
+					throw new ArgumentException("Illegal tag in RevocationValues", nameof(seq));
 				}
 			}
 		}
 
-		public RevocationValues(
-			CertificateList[]	crlVals,
-			BasicOcspResponse[]	ocspVals,
-			OtherRevVals		otherRevVals)
+		public RevocationValues(CertificateList[] crlVals, BasicOcspResponse[] ocspVals, OtherRevVals otherRevVals)
 		{
 			if (crlVals != null)
 			{
-				this.crlVals = new DerSequence(crlVals);
+				m_crlVals = new DerSequence(crlVals);
 			}
 
 			if (ocspVals != null)
 			{
-				this.ocspVals = new DerSequence(ocspVals);
+				m_ocspVals = new DerSequence(ocspVals);
 			}
 
-			this.otherRevVals = otherRevVals;
+			m_otherRevVals = otherRevVals;
 		}
 
-		public RevocationValues(
-			IEnumerable<CertificateList> crlVals,
-			IEnumerable<BasicOcspResponse> ocspVals,
+		public RevocationValues(IEnumerable<CertificateList> crlVals, IEnumerable<BasicOcspResponse> ocspVals,
 			OtherRevVals otherRevVals)
 		{
 			if (crlVals != null)
 			{
-				this.crlVals = new DerSequence(
-					Asn1EncodableVector.FromEnumerable(crlVals));
+				m_crlVals = new DerSequence(Asn1EncodableVector.FromEnumerable(crlVals));
 			}
 
 			if (ocspVals != null)
 			{
-				this.ocspVals = new DerSequence(
-					Asn1EncodableVector.FromEnumerable(ocspVals));
+				m_ocspVals = new DerSequence(Asn1EncodableVector.FromEnumerable(ocspVals));
 			}
 
-			this.otherRevVals = otherRevVals;
+			m_otherRevVals = otherRevVals;
 		}
 
 		public CertificateList[] GetCrlVals()
 		{
-			CertificateList[] result = new CertificateList[crlVals.Count];
-			for (int i = 0; i < crlVals.Count; ++i)
-			{
-				result[i] = CertificateList.GetInstance(crlVals[i].ToAsn1Object());
-			}
-			return result;
+			return m_crlVals.MapElements(element => CertificateList.GetInstance(element.ToAsn1Object()));
 		}
 
 		public BasicOcspResponse[] GetOcspVals()
 		{
-			BasicOcspResponse[] result = new BasicOcspResponse[ocspVals.Count];
-			for (int i = 0; i < ocspVals.Count; ++i)
-			{
-				result[i] = BasicOcspResponse.GetInstance(ocspVals[i].ToAsn1Object());
-			}
-			return result;
+            return m_ocspVals.MapElements(element => BasicOcspResponse.GetInstance(element.ToAsn1Object()));
 		}
 
 		public OtherRevVals OtherRevVals
 		{
-			get { return otherRevVals; }
+			get { return m_otherRevVals; }
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
 			Asn1EncodableVector v = new Asn1EncodableVector();
-            v.AddOptionalTagged(true, 0, crlVals);
-            v.AddOptionalTagged(true, 1, ocspVals);
+            v.AddOptionalTagged(true, 0, m_crlVals);
+            v.AddOptionalTagged(true, 1, m_ocspVals);
 
-            if (otherRevVals != null)
+            if (m_otherRevVals != null)
 			{
-				v.Add(new DerTaggedObject(true, 2, otherRevVals.ToAsn1Object()));
+				v.Add(new DerTaggedObject(true, 2, m_otherRevVals.ToAsn1Object()));
 			}
 
             return new DerSequence(v);
diff --git a/crypto/src/asn1/esf/SignaturePolicyId.cs b/crypto/src/asn1/esf/SignaturePolicyId.cs
index 21bb40560..84e9f8c62 100644
--- a/crypto/src/asn1/esf/SignaturePolicyId.cs
+++ b/crypto/src/asn1/esf/SignaturePolicyId.cs
@@ -21,119 +21,103 @@ namespace Org.BouncyCastle.Asn1.Esf
 	public class SignaturePolicyId
 		: Asn1Encodable
 	{
-		private readonly DerObjectIdentifier	sigPolicyIdentifier;
-		private readonly OtherHashAlgAndValue	sigPolicyHash;
-		private readonly Asn1Sequence			sigPolicyQualifiers;
+		private readonly DerObjectIdentifier m_sigPolicyIdentifier;
+		private readonly OtherHashAlgAndValue m_sigPolicyHash;
+		private readonly Asn1Sequence m_sigPolicyQualifiers;
 
-		public static SignaturePolicyId GetInstance(
-			object obj)
+		public static SignaturePolicyId GetInstance(object obj)
 		{
-			if (obj == null || obj is SignaturePolicyId)
-				return (SignaturePolicyId) obj;
+			if (obj == null)
+				return null;
+
+			if (obj is SignaturePolicyId signaturePolicyId)
+				return signaturePolicyId;
 
-			if (obj is Asn1Sequence)
-				return new SignaturePolicyId((Asn1Sequence) obj);
+			if (obj is Asn1Sequence asn1Sequence)
+				return new SignaturePolicyId(asn1Sequence);
 
-			throw new ArgumentException(
-				"Unknown object in 'SignaturePolicyId' factory: "
-                    + Platform.GetTypeName(obj),
-				"obj");
+			throw new ArgumentException("Unknown object in 'SignaturePolicyId' factory: " + Platform.GetTypeName(obj),
+				nameof(obj));
 		}
 
-		private SignaturePolicyId(
-			Asn1Sequence seq)
+		private SignaturePolicyId(Asn1Sequence seq)
 		{
 			if (seq == null)
-				throw new ArgumentNullException("seq");
+				throw new ArgumentNullException(nameof(seq));
 			if (seq.Count < 2 || seq.Count > 3)
-				throw new ArgumentException("Bad sequence size: " + seq.Count, "seq");
+				throw new ArgumentException("Bad sequence size: " + seq.Count, nameof(seq));
 
-			this.sigPolicyIdentifier = (DerObjectIdentifier) seq[0].ToAsn1Object();
-			this.sigPolicyHash = OtherHashAlgAndValue.GetInstance(seq[1].ToAsn1Object());
+			m_sigPolicyIdentifier = (DerObjectIdentifier)seq[0].ToAsn1Object();
+			m_sigPolicyHash = OtherHashAlgAndValue.GetInstance(seq[1].ToAsn1Object());
 
 			if (seq.Count > 2)
 			{
-				this.sigPolicyQualifiers = (Asn1Sequence) seq[2].ToAsn1Object();
+				m_sigPolicyQualifiers = (Asn1Sequence)seq[2].ToAsn1Object();
 			}
 		}
 
-		public SignaturePolicyId(
-			DerObjectIdentifier		sigPolicyIdentifier,
-			OtherHashAlgAndValue	sigPolicyHash)
+		public SignaturePolicyId(DerObjectIdentifier sigPolicyIdentifier, OtherHashAlgAndValue sigPolicyHash)
 			: this(sigPolicyIdentifier, sigPolicyHash, null)
 		{
 		}
 
-		public SignaturePolicyId(
-			DerObjectIdentifier				sigPolicyIdentifier,
-			OtherHashAlgAndValue			sigPolicyHash,
+		public SignaturePolicyId(DerObjectIdentifier sigPolicyIdentifier, OtherHashAlgAndValue sigPolicyHash,
 			params SigPolicyQualifierInfo[]	sigPolicyQualifiers)
 		{
 			if (sigPolicyIdentifier == null)
-				throw new ArgumentNullException("sigPolicyIdentifier");
+				throw new ArgumentNullException(nameof(sigPolicyIdentifier));
 			if (sigPolicyHash == null)
-				throw new ArgumentNullException("sigPolicyHash");
+				throw new ArgumentNullException(nameof(sigPolicyHash));
 
-			this.sigPolicyIdentifier = sigPolicyIdentifier;
-			this.sigPolicyHash = sigPolicyHash;
+			m_sigPolicyIdentifier = sigPolicyIdentifier;
+			m_sigPolicyHash = sigPolicyHash;
 
 			if (sigPolicyQualifiers != null)
 			{
-				this.sigPolicyQualifiers = new DerSequence(sigPolicyQualifiers);
+				m_sigPolicyQualifiers = new DerSequence(sigPolicyQualifiers);
 			}
 		}
 
-		public SignaturePolicyId(
-			DerObjectIdentifier sigPolicyIdentifier,
-			OtherHashAlgAndValue sigPolicyHash,
+		public SignaturePolicyId(DerObjectIdentifier sigPolicyIdentifier, OtherHashAlgAndValue sigPolicyHash,
 			IEnumerable<SigPolicyQualifierInfo> sigPolicyQualifiers)
 		{
-			if (sigPolicyIdentifier == null)
-				throw new ArgumentNullException("sigPolicyIdentifier");
-			if (sigPolicyHash == null)
-				throw new ArgumentNullException("sigPolicyHash");
+            if (sigPolicyIdentifier == null)
+                throw new ArgumentNullException(nameof(sigPolicyIdentifier));
+            if (sigPolicyHash == null)
+                throw new ArgumentNullException(nameof(sigPolicyHash));
 
-			this.sigPolicyIdentifier = sigPolicyIdentifier;
-			this.sigPolicyHash = sigPolicyHash;
+			m_sigPolicyIdentifier = sigPolicyIdentifier;
+			m_sigPolicyHash = sigPolicyHash;
 
 			if (sigPolicyQualifiers != null)
 			{
-				this.sigPolicyQualifiers = new DerSequence(
-					Asn1EncodableVector.FromEnumerable(sigPolicyQualifiers));
+				m_sigPolicyQualifiers = new DerSequence(Asn1EncodableVector.FromEnumerable(sigPolicyQualifiers));
 			}
 		}
 
 		public DerObjectIdentifier SigPolicyIdentifier
 		{
-			get { return sigPolicyIdentifier; }
+			get { return m_sigPolicyIdentifier; }
 		}
 
 		public OtherHashAlgAndValue SigPolicyHash
 		{
-			get { return sigPolicyHash; }
+			get { return m_sigPolicyHash; }
 		}
 
 		public SigPolicyQualifierInfo[] GetSigPolicyQualifiers()
 		{
-			if (sigPolicyQualifiers == null)
-				return null;
-
-			SigPolicyQualifierInfo[] infos = new SigPolicyQualifierInfo[sigPolicyQualifiers.Count];
-			for (int i = 0; i < sigPolicyQualifiers.Count; ++i)
-			{
-				infos[i] = SigPolicyQualifierInfo.GetInstance(sigPolicyQualifiers[i]);
-			}
-			return infos;
+			return m_sigPolicyQualifiers?.MapElements(SigPolicyQualifierInfo.GetInstance);
 		}
 
 		public override Asn1Object ToAsn1Object()
 		{
 			Asn1EncodableVector v = new Asn1EncodableVector(
-				sigPolicyIdentifier, sigPolicyHash.ToAsn1Object());
+				m_sigPolicyIdentifier, m_sigPolicyHash.ToAsn1Object());
 
-			if (sigPolicyQualifiers != null)
+			if (m_sigPolicyQualifiers != null)
 			{
-				v.Add(sigPolicyQualifiers.ToAsn1Object());
+				v.Add(m_sigPolicyQualifiers.ToAsn1Object());
 			}
 
 			return new DerSequence(v);