From cef5f11fce55d1591649f4cb6eed96281d0bd949 Mon Sep 17 00:00:00 2001
From: Alexander van Delft <a.vandelft@rheagroup.com>
Date: Wed, 18 Sep 2024 11:57:41 +0200
Subject: [PATCH] [FIX] error while creating new EngineeringModelSetup from
 source EngineeringModelSetup

---
 CometServer/AutoGenServices/ActionItemService.cs                | 2 +-
 CometServer/AutoGenServices/ActualFiniteStateListService.cs     | 2 +-
 CometServer/AutoGenServices/ArrayParameterTypeService.cs        | 2 +-
 CometServer/AutoGenServices/BinaryRelationshipRuleService.cs    | 2 +-
 CometServer/AutoGenServices/BinaryRelationshipService.cs        | 2 +-
 CometServer/AutoGenServices/BookService.cs                      | 2 +-
 CometServer/AutoGenServices/BooleanParameterTypeService.cs      | 2 +-
 CometServer/AutoGenServices/BuiltInRuleVerificationService.cs   | 2 +-
 CometServer/AutoGenServices/CategoryService.cs                  | 2 +-
 CometServer/AutoGenServices/ChangeProposalService.cs            | 2 +-
 CometServer/AutoGenServices/ChangeRequestService.cs             | 2 +-
 CometServer/AutoGenServices/CommonFileStoreService.cs           | 2 +-
 CometServer/AutoGenServices/CompoundParameterTypeService.cs     | 2 +-
 CometServer/AutoGenServices/ConstantService.cs                  | 2 +-
 CometServer/AutoGenServices/ContractChangeNoticeService.cs      | 2 +-
 CometServer/AutoGenServices/CyclicRatioScaleService.cs          | 2 +-
 CometServer/AutoGenServices/DateParameterTypeService.cs         | 2 +-
 CometServer/AutoGenServices/DateTimeParameterTypeService.cs     | 2 +-
 CometServer/AutoGenServices/DecompositionRuleService.cs         | 2 +-
 CometServer/AutoGenServices/DefinitionService.cs                | 2 +-
 CometServer/AutoGenServices/DerivedQuantityKindService.cs       | 2 +-
 CometServer/AutoGenServices/DerivedUnitService.cs               | 2 +-
 CometServer/AutoGenServices/DiagramCanvasService.cs             | 2 +-
 CometServer/AutoGenServices/DiagramEdgeService.cs               | 2 +-
 CometServer/AutoGenServices/DiagramObjectService.cs             | 2 +-
 CometServer/AutoGenServices/DomainFileStoreService.cs           | 2 +-
 CometServer/AutoGenServices/DomainOfExpertiseGroupService.cs    | 2 +-
 CometServer/AutoGenServices/DomainOfExpertiseService.cs         | 2 +-
 CometServer/AutoGenServices/ElementDefinitionService.cs         | 2 +-
 CometServer/AutoGenServices/ElementUsageService.cs              | 2 +-
 CometServer/AutoGenServices/EngineeringModelDataNoteService.cs  | 2 +-
 CometServer/AutoGenServices/EngineeringModelService.cs          | 2 +-
 CometServer/AutoGenServices/EngineeringModelSetupService.cs     | 2 +-
 CometServer/AutoGenServices/EnumerationParameterTypeService.cs  | 2 +-
 .../AutoGenServices/EnumerationValueDefinitionService.cs        | 2 +-
 CometServer/AutoGenServices/ExternalIdentifierMapService.cs     | 2 +-
 CometServer/AutoGenServices/FileService.cs                      | 2 +-
 CometServer/AutoGenServices/FileTypeService.cs                  | 2 +-
 CometServer/AutoGenServices/GlossaryService.cs                  | 2 +-
 CometServer/AutoGenServices/GoalService.cs                      | 2 +-
 CometServer/AutoGenServices/IntervalScaleService.cs             | 2 +-
 CometServer/AutoGenServices/IterationService.cs                 | 2 +-
 CometServer/AutoGenServices/LinearConversionUnitService.cs      | 2 +-
 CometServer/AutoGenServices/LogarithmicScaleService.cs          | 2 +-
 CometServer/AutoGenServices/ModelLogEntryService.cs             | 2 +-
 CometServer/AutoGenServices/ModelReferenceDataLibraryService.cs | 2 +-
 CometServer/AutoGenServices/MultiRelationshipRuleService.cs     | 2 +-
 CometServer/AutoGenServices/MultiRelationshipService.cs         | 2 +-
 CometServer/AutoGenServices/NestedElementService.cs             | 2 +-
 CometServer/AutoGenServices/OptionService.cs                    | 2 +-
 CometServer/AutoGenServices/OrdinalScaleService.cs              | 2 +-
 CometServer/AutoGenServices/OwnedStyleService.cs                | 2 +-
 CometServer/AutoGenServices/PageService.cs                      | 2 +-
 CometServer/AutoGenServices/ParameterOverrideService.cs         | 2 +-
 CometServer/AutoGenServices/ParameterService.cs                 | 2 +-
 CometServer/AutoGenServices/ParameterSubscriptionService.cs     | 2 +-
 CometServer/AutoGenServices/ParameterizedCategoryRuleService.cs | 2 +-
 CometServer/AutoGenServices/ParametricConstraintService.cs      | 2 +-
 CometServer/AutoGenServices/ParticipantRoleService.cs           | 2 +-
 CometServer/AutoGenServices/PersonRoleService.cs                | 2 +-
 CometServer/AutoGenServices/PersonService.cs                    | 2 +-
 CometServer/AutoGenServices/PossibleFiniteStateListService.cs   | 2 +-
 CometServer/AutoGenServices/PossibleFiniteStateService.cs       | 2 +-
 CometServer/AutoGenServices/PrefixedUnitService.cs              | 2 +-
 CometServer/AutoGenServices/RatioScaleService.cs                | 2 +-
 CometServer/AutoGenServices/ReferenceSourceService.cs           | 2 +-
 CometServer/AutoGenServices/ReferencerRuleService.cs            | 2 +-
 CometServer/AutoGenServices/RequestForDeviationService.cs       | 2 +-
 CometServer/AutoGenServices/RequestForWaiverService.cs          | 2 +-
 CometServer/AutoGenServices/RequirementService.cs               | 2 +-
 CometServer/AutoGenServices/RequirementsGroupService.cs         | 2 +-
 CometServer/AutoGenServices/RequirementsSpecificationService.cs | 2 +-
 CometServer/AutoGenServices/ReviewItemDiscrepancyService.cs     | 2 +-
 CometServer/AutoGenServices/RuleVerificationListService.cs      | 2 +-
 .../AutoGenServices/SampledFunctionParameterTypeService.cs      | 2 +-
 CometServer/AutoGenServices/ScaleValueDefinitionService.cs      | 2 +-
 CometServer/AutoGenServices/SectionService.cs                   | 2 +-
 CometServer/AutoGenServices/SharedStyleService.cs               | 2 +-
 CometServer/AutoGenServices/SimpleQuantityKindService.cs        | 2 +-
 CometServer/AutoGenServices/SimpleUnitService.cs                | 2 +-
 .../AutoGenServices/SiteDirectoryDataAnnotationService.cs       | 2 +-
 CometServer/AutoGenServices/SiteDirectoryService.cs             | 2 +-
 CometServer/AutoGenServices/SiteLogEntryService.cs              | 2 +-
 CometServer/AutoGenServices/SiteReferenceDataLibraryService.cs  | 2 +-
 CometServer/AutoGenServices/SpecializedQuantityKindService.cs   | 2 +-
 CometServer/AutoGenServices/StakeHolderValueMapService.cs       | 2 +-
 CometServer/AutoGenServices/StakeholderService.cs               | 2 +-
 CometServer/AutoGenServices/StakeholderValueService.cs          | 2 +-
 CometServer/AutoGenServices/TermService.cs                      | 2 +-
 CometServer/AutoGenServices/TextParameterTypeService.cs         | 2 +-
 CometServer/AutoGenServices/TimeOfDayParameterTypeService.cs    | 2 +-
 CometServer/AutoGenServices/UnitPrefixService.cs                | 2 +-
 CometServer/AutoGenServices/UserRuleVerificationService.cs      | 2 +-
 CometServer/AutoGenServices/ValueGroupService.cs                | 2 +-
 94 files changed, 94 insertions(+), 94 deletions(-)

diff --git a/CometServer/AutoGenServices/ActionItemService.cs b/CometServer/AutoGenServices/ActionItemService.cs
index 30743989..90787979 100644
--- a/CometServer/AutoGenServices/ActionItemService.cs
+++ b/CometServer/AutoGenServices/ActionItemService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var actionItemColl = results.Where(i => i.GetType() == typeof(ActionItem)).Cast<ActionItem>().ToList();
+            var actionItemColl = results.OfType<ActionItem>().ToList();
 
             results.AddRange(this.ApprovedByService.GetDeep(transaction, partition, actionItemColl.SelectMany(x => x.ApprovedBy), containerSecurityContext));
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, actionItemColl.SelectMany(x => x.Discussion), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ActualFiniteStateListService.cs b/CometServer/AutoGenServices/ActualFiniteStateListService.cs
index cb994a06..3274c59d 100644
--- a/CometServer/AutoGenServices/ActualFiniteStateListService.cs
+++ b/CometServer/AutoGenServices/ActualFiniteStateListService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var actualFiniteStateListColl = results.Where(i => i.GetType() == typeof(ActualFiniteStateList)).Cast<ActualFiniteStateList>().ToList();
+            var actualFiniteStateListColl = results.OfType<ActualFiniteStateList>().ToList();
 
             results.AddRange(this.ActualStateService.GetDeep(transaction, partition, actualFiniteStateListColl.SelectMany(x => x.ActualState), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/ArrayParameterTypeService.cs b/CometServer/AutoGenServices/ArrayParameterTypeService.cs
index 8fb85806..4ffc79f8 100644
--- a/CometServer/AutoGenServices/ArrayParameterTypeService.cs
+++ b/CometServer/AutoGenServices/ArrayParameterTypeService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var arrayParameterTypeColl = results.Where(i => i.GetType() == typeof(ArrayParameterType)).Cast<ArrayParameterType>().ToList();
+            var arrayParameterTypeColl = results.OfType<ArrayParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, arrayParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.ComponentService.GetDeep(transaction, partition, arrayParameterTypeColl.SelectMany(x => x.Component).ToIdList(), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/BinaryRelationshipRuleService.cs b/CometServer/AutoGenServices/BinaryRelationshipRuleService.cs
index 25a6e167..a3b0b90d 100644
--- a/CometServer/AutoGenServices/BinaryRelationshipRuleService.cs
+++ b/CometServer/AutoGenServices/BinaryRelationshipRuleService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var binaryRelationshipRuleColl = results.Where(i => i.GetType() == typeof(BinaryRelationshipRule)).Cast<BinaryRelationshipRule>().ToList();
+            var binaryRelationshipRuleColl = results.OfType<BinaryRelationshipRule>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, binaryRelationshipRuleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, binaryRelationshipRuleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/BinaryRelationshipService.cs b/CometServer/AutoGenServices/BinaryRelationshipService.cs
index 50a91529..a2b6ad65 100644
--- a/CometServer/AutoGenServices/BinaryRelationshipService.cs
+++ b/CometServer/AutoGenServices/BinaryRelationshipService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var binaryRelationshipColl = results.Where(i => i.GetType() == typeof(BinaryRelationship)).Cast<BinaryRelationship>().ToList();
+            var binaryRelationshipColl = results.OfType<BinaryRelationship>().ToList();
 
             results.AddRange(this.ParameterValueService.GetDeep(transaction, partition, binaryRelationshipColl.SelectMany(x => x.ParameterValue), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/BookService.cs b/CometServer/AutoGenServices/BookService.cs
index 0040249d..a6c5b9d2 100644
--- a/CometServer/AutoGenServices/BookService.cs
+++ b/CometServer/AutoGenServices/BookService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var bookColl = results.Where(i => i.GetType() == typeof(Book)).Cast<Book>().ToList();
+            var bookColl = results.OfType<Book>().ToList();
 
             results.AddRange(this.SectionService.GetDeep(transaction, partition, bookColl.SelectMany(x => x.Section).ToIdList(), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/BooleanParameterTypeService.cs b/CometServer/AutoGenServices/BooleanParameterTypeService.cs
index eab6dda8..a5a28ee9 100644
--- a/CometServer/AutoGenServices/BooleanParameterTypeService.cs
+++ b/CometServer/AutoGenServices/BooleanParameterTypeService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var booleanParameterTypeColl = results.Where(i => i.GetType() == typeof(BooleanParameterType)).Cast<BooleanParameterType>().ToList();
+            var booleanParameterTypeColl = results.OfType<BooleanParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, booleanParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, booleanParameterTypeColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/BuiltInRuleVerificationService.cs b/CometServer/AutoGenServices/BuiltInRuleVerificationService.cs
index 78051291..abae7af9 100644
--- a/CometServer/AutoGenServices/BuiltInRuleVerificationService.cs
+++ b/CometServer/AutoGenServices/BuiltInRuleVerificationService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var builtInRuleVerificationColl = results.Where(i => i.GetType() == typeof(BuiltInRuleVerification)).Cast<BuiltInRuleVerification>().ToList();
+            var builtInRuleVerificationColl = results.OfType<BuiltInRuleVerification>().ToList();
 
             results.AddRange(this.ViolationService.GetDeep(transaction, partition, builtInRuleVerificationColl.SelectMany(x => x.Violation), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/CategoryService.cs b/CometServer/AutoGenServices/CategoryService.cs
index 6405f942..2b137b83 100644
--- a/CometServer/AutoGenServices/CategoryService.cs
+++ b/CometServer/AutoGenServices/CategoryService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var categoryColl = results.Where(i => i.GetType() == typeof(Category)).Cast<Category>().ToList();
+            var categoryColl = results.OfType<Category>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, categoryColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, categoryColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ChangeProposalService.cs b/CometServer/AutoGenServices/ChangeProposalService.cs
index eebaf204..c1f226ed 100644
--- a/CometServer/AutoGenServices/ChangeProposalService.cs
+++ b/CometServer/AutoGenServices/ChangeProposalService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var changeProposalColl = results.Where(i => i.GetType() == typeof(ChangeProposal)).Cast<ChangeProposal>().ToList();
+            var changeProposalColl = results.OfType<ChangeProposal>().ToList();
 
             results.AddRange(this.ApprovedByService.GetDeep(transaction, partition, changeProposalColl.SelectMany(x => x.ApprovedBy), containerSecurityContext));
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, changeProposalColl.SelectMany(x => x.Discussion), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ChangeRequestService.cs b/CometServer/AutoGenServices/ChangeRequestService.cs
index 813aadbf..984ee95d 100644
--- a/CometServer/AutoGenServices/ChangeRequestService.cs
+++ b/CometServer/AutoGenServices/ChangeRequestService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var changeRequestColl = results.Where(i => i.GetType() == typeof(ChangeRequest)).Cast<ChangeRequest>().ToList();
+            var changeRequestColl = results.OfType<ChangeRequest>().ToList();
 
             results.AddRange(this.ApprovedByService.GetDeep(transaction, partition, changeRequestColl.SelectMany(x => x.ApprovedBy), containerSecurityContext));
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, changeRequestColl.SelectMany(x => x.Discussion), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/CommonFileStoreService.cs b/CometServer/AutoGenServices/CommonFileStoreService.cs
index d215b366..ae46d2e8 100644
--- a/CometServer/AutoGenServices/CommonFileStoreService.cs
+++ b/CometServer/AutoGenServices/CommonFileStoreService.cs
@@ -388,7 +388,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var commonFileStoreColl = results.Where(i => i.GetType() == typeof(CommonFileStore)).Cast<CommonFileStore>().ToList();
+            var commonFileStoreColl = results.OfType<CommonFileStore>().ToList();
 
             results.AddRange(this.FileService.GetDeep(transaction, partition, commonFileStoreColl.SelectMany(x => x.File), containerSecurityContext));
             results.AddRange(this.FolderService.GetDeep(transaction, partition, commonFileStoreColl.SelectMany(x => x.Folder), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/CompoundParameterTypeService.cs b/CometServer/AutoGenServices/CompoundParameterTypeService.cs
index 6009ba8e..739b4994 100644
--- a/CometServer/AutoGenServices/CompoundParameterTypeService.cs
+++ b/CometServer/AutoGenServices/CompoundParameterTypeService.cs
@@ -422,7 +422,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var compoundParameterTypeColl = results.Where(i => i.GetType() == typeof(CompoundParameterType)).Cast<CompoundParameterType>().ToList();
+            var compoundParameterTypeColl = results.OfType<CompoundParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, compoundParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.ComponentService.GetDeep(transaction, partition, compoundParameterTypeColl.SelectMany(x => x.Component).ToIdList(), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ConstantService.cs b/CometServer/AutoGenServices/ConstantService.cs
index 12c8aeb2..3cc31d81 100644
--- a/CometServer/AutoGenServices/ConstantService.cs
+++ b/CometServer/AutoGenServices/ConstantService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var constantColl = results.Where(i => i.GetType() == typeof(Constant)).Cast<Constant>().ToList();
+            var constantColl = results.OfType<Constant>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, constantColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, constantColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ContractChangeNoticeService.cs b/CometServer/AutoGenServices/ContractChangeNoticeService.cs
index a2f92b83..b5f43ded 100644
--- a/CometServer/AutoGenServices/ContractChangeNoticeService.cs
+++ b/CometServer/AutoGenServices/ContractChangeNoticeService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var contractChangeNoticeColl = results.Where(i => i.GetType() == typeof(ContractChangeNotice)).Cast<ContractChangeNotice>().ToList();
+            var contractChangeNoticeColl = results.OfType<ContractChangeNotice>().ToList();
 
             results.AddRange(this.ApprovedByService.GetDeep(transaction, partition, contractChangeNoticeColl.SelectMany(x => x.ApprovedBy), containerSecurityContext));
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, contractChangeNoticeColl.SelectMany(x => x.Discussion), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/CyclicRatioScaleService.cs b/CometServer/AutoGenServices/CyclicRatioScaleService.cs
index 47353eec..52416875 100644
--- a/CometServer/AutoGenServices/CyclicRatioScaleService.cs
+++ b/CometServer/AutoGenServices/CyclicRatioScaleService.cs
@@ -403,7 +403,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var cyclicRatioScaleColl = results.Where(i => i.GetType() == typeof(CyclicRatioScale)).Cast<CyclicRatioScale>().ToList();
+            var cyclicRatioScaleColl = results.OfType<CyclicRatioScale>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, cyclicRatioScaleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, cyclicRatioScaleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DateParameterTypeService.cs b/CometServer/AutoGenServices/DateParameterTypeService.cs
index 9dd1660e..5db2db06 100644
--- a/CometServer/AutoGenServices/DateParameterTypeService.cs
+++ b/CometServer/AutoGenServices/DateParameterTypeService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var dateParameterTypeColl = results.Where(i => i.GetType() == typeof(DateParameterType)).Cast<DateParameterType>().ToList();
+            var dateParameterTypeColl = results.OfType<DateParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, dateParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, dateParameterTypeColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DateTimeParameterTypeService.cs b/CometServer/AutoGenServices/DateTimeParameterTypeService.cs
index 6980d576..7335f85e 100644
--- a/CometServer/AutoGenServices/DateTimeParameterTypeService.cs
+++ b/CometServer/AutoGenServices/DateTimeParameterTypeService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var dateTimeParameterTypeColl = results.Where(i => i.GetType() == typeof(DateTimeParameterType)).Cast<DateTimeParameterType>().ToList();
+            var dateTimeParameterTypeColl = results.OfType<DateTimeParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, dateTimeParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, dateTimeParameterTypeColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DecompositionRuleService.cs b/CometServer/AutoGenServices/DecompositionRuleService.cs
index e8fd236b..fe428db0 100644
--- a/CometServer/AutoGenServices/DecompositionRuleService.cs
+++ b/CometServer/AutoGenServices/DecompositionRuleService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var decompositionRuleColl = results.Where(i => i.GetType() == typeof(DecompositionRule)).Cast<DecompositionRule>().ToList();
+            var decompositionRuleColl = results.OfType<DecompositionRule>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, decompositionRuleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, decompositionRuleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DefinitionService.cs b/CometServer/AutoGenServices/DefinitionService.cs
index f8fdeed9..7c97fbd5 100644
--- a/CometServer/AutoGenServices/DefinitionService.cs
+++ b/CometServer/AutoGenServices/DefinitionService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var definitionColl = results.Where(i => i.GetType() == typeof(Definition)).Cast<Definition>().ToList();
+            var definitionColl = results.OfType<Definition>().ToList();
 
             results.AddRange(this.CitationService.GetDeep(transaction, partition, definitionColl.SelectMany(x => x.Citation), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/DerivedQuantityKindService.cs b/CometServer/AutoGenServices/DerivedQuantityKindService.cs
index 5b58c2d3..5bddc4fe 100644
--- a/CometServer/AutoGenServices/DerivedQuantityKindService.cs
+++ b/CometServer/AutoGenServices/DerivedQuantityKindService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var derivedQuantityKindColl = results.Where(i => i.GetType() == typeof(DerivedQuantityKind)).Cast<DerivedQuantityKind>().ToList();
+            var derivedQuantityKindColl = results.OfType<DerivedQuantityKind>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, derivedQuantityKindColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, derivedQuantityKindColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DerivedUnitService.cs b/CometServer/AutoGenServices/DerivedUnitService.cs
index 14ea5cdb..52b28243 100644
--- a/CometServer/AutoGenServices/DerivedUnitService.cs
+++ b/CometServer/AutoGenServices/DerivedUnitService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var derivedUnitColl = results.Where(i => i.GetType() == typeof(DerivedUnit)).Cast<DerivedUnit>().ToList();
+            var derivedUnitColl = results.OfType<DerivedUnit>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, derivedUnitColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, derivedUnitColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DiagramCanvasService.cs b/CometServer/AutoGenServices/DiagramCanvasService.cs
index 0dd96848..ff284ce9 100644
--- a/CometServer/AutoGenServices/DiagramCanvasService.cs
+++ b/CometServer/AutoGenServices/DiagramCanvasService.cs
@@ -388,7 +388,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var diagramCanvasColl = results.Where(i => i.GetType() == typeof(DiagramCanvas)).Cast<DiagramCanvas>().ToList();
+            var diagramCanvasColl = results.OfType<DiagramCanvas>().ToList();
 
             results.AddRange(this.BoundsService.GetDeep(transaction, partition, diagramCanvasColl.SelectMany(x => x.Bounds), containerSecurityContext));
             results.AddRange(this.DiagramElementService.GetDeep(transaction, partition, diagramCanvasColl.SelectMany(x => x.DiagramElement), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DiagramEdgeService.cs b/CometServer/AutoGenServices/DiagramEdgeService.cs
index 541b8384..af8c3a98 100644
--- a/CometServer/AutoGenServices/DiagramEdgeService.cs
+++ b/CometServer/AutoGenServices/DiagramEdgeService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var diagramEdgeColl = results.Where(i => i.GetType() == typeof(DiagramEdge)).Cast<DiagramEdge>().ToList();
+            var diagramEdgeColl = results.OfType<DiagramEdge>().ToList();
 
             results.AddRange(this.BoundsService.GetDeep(transaction, partition, diagramEdgeColl.SelectMany(x => x.Bounds), containerSecurityContext));
             results.AddRange(this.DiagramElementService.GetDeep(transaction, partition, diagramEdgeColl.SelectMany(x => x.DiagramElement), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DiagramObjectService.cs b/CometServer/AutoGenServices/DiagramObjectService.cs
index 83bb00e3..b5d7e590 100644
--- a/CometServer/AutoGenServices/DiagramObjectService.cs
+++ b/CometServer/AutoGenServices/DiagramObjectService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var diagramObjectColl = results.Where(i => i.GetType() == typeof(DiagramObject)).Cast<DiagramObject>().ToList();
+            var diagramObjectColl = results.OfType<DiagramObject>().ToList();
 
             results.AddRange(this.BoundsService.GetDeep(transaction, partition, diagramObjectColl.SelectMany(x => x.Bounds), containerSecurityContext));
             results.AddRange(this.DiagramElementService.GetDeep(transaction, partition, diagramObjectColl.SelectMany(x => x.DiagramElement), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DomainFileStoreService.cs b/CometServer/AutoGenServices/DomainFileStoreService.cs
index 9f1fce53..e23627a6 100644
--- a/CometServer/AutoGenServices/DomainFileStoreService.cs
+++ b/CometServer/AutoGenServices/DomainFileStoreService.cs
@@ -388,7 +388,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var domainFileStoreColl = results.Where(i => i.GetType() == typeof(DomainFileStore)).Cast<DomainFileStore>().ToList();
+            var domainFileStoreColl = results.OfType<DomainFileStore>().ToList();
 
             results.AddRange(this.FileService.GetDeep(transaction, partition, domainFileStoreColl.SelectMany(x => x.File), containerSecurityContext));
             results.AddRange(this.FolderService.GetDeep(transaction, partition, domainFileStoreColl.SelectMany(x => x.Folder), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DomainOfExpertiseGroupService.cs b/CometServer/AutoGenServices/DomainOfExpertiseGroupService.cs
index 283b0199..f84e748c 100644
--- a/CometServer/AutoGenServices/DomainOfExpertiseGroupService.cs
+++ b/CometServer/AutoGenServices/DomainOfExpertiseGroupService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var domainOfExpertiseGroupColl = results.Where(i => i.GetType() == typeof(DomainOfExpertiseGroup)).Cast<DomainOfExpertiseGroup>().ToList();
+            var domainOfExpertiseGroupColl = results.OfType<DomainOfExpertiseGroup>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, domainOfExpertiseGroupColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, domainOfExpertiseGroupColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/DomainOfExpertiseService.cs b/CometServer/AutoGenServices/DomainOfExpertiseService.cs
index 69bb94d8..7b28ecd7 100644
--- a/CometServer/AutoGenServices/DomainOfExpertiseService.cs
+++ b/CometServer/AutoGenServices/DomainOfExpertiseService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var domainOfExpertiseColl = results.Where(i => i.GetType() == typeof(DomainOfExpertise)).Cast<DomainOfExpertise>().ToList();
+            var domainOfExpertiseColl = results.OfType<DomainOfExpertise>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, domainOfExpertiseColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, domainOfExpertiseColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ElementDefinitionService.cs b/CometServer/AutoGenServices/ElementDefinitionService.cs
index 983cfc15..798de961 100644
--- a/CometServer/AutoGenServices/ElementDefinitionService.cs
+++ b/CometServer/AutoGenServices/ElementDefinitionService.cs
@@ -408,7 +408,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var elementDefinitionColl = results.Where(i => i.GetType() == typeof(ElementDefinition)).Cast<ElementDefinition>().ToList();
+            var elementDefinitionColl = results.OfType<ElementDefinition>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, elementDefinitionColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.ContainedElementService.GetDeep(transaction, partition, elementDefinitionColl.SelectMany(x => x.ContainedElement), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ElementUsageService.cs b/CometServer/AutoGenServices/ElementUsageService.cs
index 2d1d874a..408a1de8 100644
--- a/CometServer/AutoGenServices/ElementUsageService.cs
+++ b/CometServer/AutoGenServices/ElementUsageService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var elementUsageColl = results.Where(i => i.GetType() == typeof(ElementUsage)).Cast<ElementUsage>().ToList();
+            var elementUsageColl = results.OfType<ElementUsage>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, elementUsageColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, elementUsageColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/EngineeringModelDataNoteService.cs b/CometServer/AutoGenServices/EngineeringModelDataNoteService.cs
index 0402f357..0893b7ba 100644
--- a/CometServer/AutoGenServices/EngineeringModelDataNoteService.cs
+++ b/CometServer/AutoGenServices/EngineeringModelDataNoteService.cs
@@ -388,7 +388,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var engineeringModelDataNoteColl = results.Where(i => i.GetType() == typeof(EngineeringModelDataNote)).Cast<EngineeringModelDataNote>().ToList();
+            var engineeringModelDataNoteColl = results.OfType<EngineeringModelDataNote>().ToList();
 
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, engineeringModelDataNoteColl.SelectMany(x => x.Discussion), containerSecurityContext));
             results.AddRange(this.RelatedThingService.GetDeep(transaction, partition, engineeringModelDataNoteColl.SelectMany(x => x.RelatedThing), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/EngineeringModelService.cs b/CometServer/AutoGenServices/EngineeringModelService.cs
index 12946c21..41785a7e 100644
--- a/CometServer/AutoGenServices/EngineeringModelService.cs
+++ b/CometServer/AutoGenServices/EngineeringModelService.cs
@@ -427,7 +427,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var engineeringModelColl = results.Where(i => i.GetType() == typeof(EngineeringModel)).Cast<EngineeringModel>().ToList();
+            var engineeringModelColl = results.OfType<EngineeringModel>().ToList();
 
             results.AddRange(this.BookService.GetDeep(transaction, partition, engineeringModelColl.SelectMany(x => x.Book).ToIdList(), containerSecurityContext));
             results.AddRange(this.CommonFileStoreService.GetDeep(transaction, partition, engineeringModelColl.SelectMany(x => x.CommonFileStore), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/EngineeringModelSetupService.cs b/CometServer/AutoGenServices/EngineeringModelSetupService.cs
index a4166bf2..8bbd7226 100644
--- a/CometServer/AutoGenServices/EngineeringModelSetupService.cs
+++ b/CometServer/AutoGenServices/EngineeringModelSetupService.cs
@@ -415,7 +415,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var engineeringModelSetupColl = results.Where(i => i.GetType() == typeof(EngineeringModelSetup)).Cast<EngineeringModelSetup>().ToList();
+            var engineeringModelSetupColl = results.OfType<EngineeringModelSetup>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, engineeringModelSetupColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, engineeringModelSetupColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/EnumerationParameterTypeService.cs b/CometServer/AutoGenServices/EnumerationParameterTypeService.cs
index cbedf0b8..f382e8de 100644
--- a/CometServer/AutoGenServices/EnumerationParameterTypeService.cs
+++ b/CometServer/AutoGenServices/EnumerationParameterTypeService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var enumerationParameterTypeColl = results.Where(i => i.GetType() == typeof(EnumerationParameterType)).Cast<EnumerationParameterType>().ToList();
+            var enumerationParameterTypeColl = results.OfType<EnumerationParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, enumerationParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, enumerationParameterTypeColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/EnumerationValueDefinitionService.cs b/CometServer/AutoGenServices/EnumerationValueDefinitionService.cs
index 80cfec1d..33d8535c 100644
--- a/CometServer/AutoGenServices/EnumerationValueDefinitionService.cs
+++ b/CometServer/AutoGenServices/EnumerationValueDefinitionService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var enumerationValueDefinitionColl = results.Where(i => i.GetType() == typeof(EnumerationValueDefinition)).Cast<EnumerationValueDefinition>().ToList();
+            var enumerationValueDefinitionColl = results.OfType<EnumerationValueDefinition>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, enumerationValueDefinitionColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, enumerationValueDefinitionColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ExternalIdentifierMapService.cs b/CometServer/AutoGenServices/ExternalIdentifierMapService.cs
index b0f4978a..978a89c8 100644
--- a/CometServer/AutoGenServices/ExternalIdentifierMapService.cs
+++ b/CometServer/AutoGenServices/ExternalIdentifierMapService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var externalIdentifierMapColl = results.Where(i => i.GetType() == typeof(ExternalIdentifierMap)).Cast<ExternalIdentifierMap>().ToList();
+            var externalIdentifierMapColl = results.OfType<ExternalIdentifierMap>().ToList();
 
             results.AddRange(this.CorrespondenceService.GetDeep(transaction, partition, externalIdentifierMapColl.SelectMany(x => x.Correspondence), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/FileService.cs b/CometServer/AutoGenServices/FileService.cs
index 1ea84328..5ca76b19 100644
--- a/CometServer/AutoGenServices/FileService.cs
+++ b/CometServer/AutoGenServices/FileService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var fileColl = results.Where(i => i.GetType() == typeof(File)).Cast<File>().ToList();
+            var fileColl = results.OfType<File>().ToList();
 
             results.AddRange(this.FileRevisionService.GetDeep(transaction, partition, fileColl.SelectMany(x => x.FileRevision), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/FileTypeService.cs b/CometServer/AutoGenServices/FileTypeService.cs
index 4cdd5033..312da86d 100644
--- a/CometServer/AutoGenServices/FileTypeService.cs
+++ b/CometServer/AutoGenServices/FileTypeService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var fileTypeColl = results.Where(i => i.GetType() == typeof(FileType)).Cast<FileType>().ToList();
+            var fileTypeColl = results.OfType<FileType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, fileTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, fileTypeColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/GlossaryService.cs b/CometServer/AutoGenServices/GlossaryService.cs
index ccfd94ed..39aadd64 100644
--- a/CometServer/AutoGenServices/GlossaryService.cs
+++ b/CometServer/AutoGenServices/GlossaryService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var glossaryColl = results.Where(i => i.GetType() == typeof(Glossary)).Cast<Glossary>().ToList();
+            var glossaryColl = results.OfType<Glossary>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, glossaryColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, glossaryColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/GoalService.cs b/CometServer/AutoGenServices/GoalService.cs
index c09d803f..f6d94eb2 100644
--- a/CometServer/AutoGenServices/GoalService.cs
+++ b/CometServer/AutoGenServices/GoalService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var goalColl = results.Where(i => i.GetType() == typeof(Goal)).Cast<Goal>().ToList();
+            var goalColl = results.OfType<Goal>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, goalColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, goalColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/IntervalScaleService.cs b/CometServer/AutoGenServices/IntervalScaleService.cs
index a9531e18..9f497661 100644
--- a/CometServer/AutoGenServices/IntervalScaleService.cs
+++ b/CometServer/AutoGenServices/IntervalScaleService.cs
@@ -403,7 +403,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var intervalScaleColl = results.Where(i => i.GetType() == typeof(IntervalScale)).Cast<IntervalScale>().ToList();
+            var intervalScaleColl = results.OfType<IntervalScale>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, intervalScaleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, intervalScaleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/IterationService.cs b/CometServer/AutoGenServices/IterationService.cs
index dbc22f16..2774a077 100644
--- a/CometServer/AutoGenServices/IterationService.cs
+++ b/CometServer/AutoGenServices/IterationService.cs
@@ -463,7 +463,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var iterationColl = results.Where(i => i.GetType() == typeof(Iteration)).Cast<Iteration>().ToList();
+            var iterationColl = results.OfType<Iteration>().ToList();
 
             var iterationPartition = partition.Replace("EngineeringModel", "Iteration");
             results.AddRange(this.ActualFiniteStateListService.GetDeep(transaction, iterationPartition, iterationColl.SelectMany(x => x.ActualFiniteStateList), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/LinearConversionUnitService.cs b/CometServer/AutoGenServices/LinearConversionUnitService.cs
index df3a81a3..d5cd35fa 100644
--- a/CometServer/AutoGenServices/LinearConversionUnitService.cs
+++ b/CometServer/AutoGenServices/LinearConversionUnitService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var linearConversionUnitColl = results.Where(i => i.GetType() == typeof(LinearConversionUnit)).Cast<LinearConversionUnit>().ToList();
+            var linearConversionUnitColl = results.OfType<LinearConversionUnit>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, linearConversionUnitColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, linearConversionUnitColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/LogarithmicScaleService.cs b/CometServer/AutoGenServices/LogarithmicScaleService.cs
index 9e3100df..0aa2fbea 100644
--- a/CometServer/AutoGenServices/LogarithmicScaleService.cs
+++ b/CometServer/AutoGenServices/LogarithmicScaleService.cs
@@ -408,7 +408,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var logarithmicScaleColl = results.Where(i => i.GetType() == typeof(LogarithmicScale)).Cast<LogarithmicScale>().ToList();
+            var logarithmicScaleColl = results.OfType<LogarithmicScale>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, logarithmicScaleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, logarithmicScaleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ModelLogEntryService.cs b/CometServer/AutoGenServices/ModelLogEntryService.cs
index 2e3a7516..8e9ae51a 100644
--- a/CometServer/AutoGenServices/ModelLogEntryService.cs
+++ b/CometServer/AutoGenServices/ModelLogEntryService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var modelLogEntryColl = results.Where(i => i.GetType() == typeof(ModelLogEntry)).Cast<ModelLogEntry>().ToList();
+            var modelLogEntryColl = results.OfType<ModelLogEntry>().ToList();
 
             results.AddRange(this.LogEntryChangelogItemService.GetDeep(transaction, partition, modelLogEntryColl.SelectMany(x => x.LogEntryChangelogItem), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/ModelReferenceDataLibraryService.cs b/CometServer/AutoGenServices/ModelReferenceDataLibraryService.cs
index 3b47238d..edd492b3 100644
--- a/CometServer/AutoGenServices/ModelReferenceDataLibraryService.cs
+++ b/CometServer/AutoGenServices/ModelReferenceDataLibraryService.cs
@@ -449,7 +449,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
                 // eventhough extent=deep retrieve mode is requested this has to be e includeRference data needs to be set to true as well to get the deep result 
                 return results;
             }
-            var modelReferenceDataLibraryColl = results.Where(i => i.GetType() == typeof(ModelReferenceDataLibrary)).Cast<ModelReferenceDataLibrary>().ToList();
+            var modelReferenceDataLibraryColl = results.OfType<ModelReferenceDataLibrary>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, modelReferenceDataLibraryColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.ConstantService.GetDeep(transaction, partition, modelReferenceDataLibraryColl.SelectMany(x => x.Constant), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/MultiRelationshipRuleService.cs b/CometServer/AutoGenServices/MultiRelationshipRuleService.cs
index f1f5bb6c..f69d9a79 100644
--- a/CometServer/AutoGenServices/MultiRelationshipRuleService.cs
+++ b/CometServer/AutoGenServices/MultiRelationshipRuleService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var multiRelationshipRuleColl = results.Where(i => i.GetType() == typeof(MultiRelationshipRule)).Cast<MultiRelationshipRule>().ToList();
+            var multiRelationshipRuleColl = results.OfType<MultiRelationshipRule>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, multiRelationshipRuleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, multiRelationshipRuleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/MultiRelationshipService.cs b/CometServer/AutoGenServices/MultiRelationshipService.cs
index 74c77ceb..3c2a3aca 100644
--- a/CometServer/AutoGenServices/MultiRelationshipService.cs
+++ b/CometServer/AutoGenServices/MultiRelationshipService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var multiRelationshipColl = results.Where(i => i.GetType() == typeof(MultiRelationship)).Cast<MultiRelationship>().ToList();
+            var multiRelationshipColl = results.OfType<MultiRelationship>().ToList();
 
             results.AddRange(this.ParameterValueService.GetDeep(transaction, partition, multiRelationshipColl.SelectMany(x => x.ParameterValue), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/NestedElementService.cs b/CometServer/AutoGenServices/NestedElementService.cs
index 39fd9ef3..deada0dd 100644
--- a/CometServer/AutoGenServices/NestedElementService.cs
+++ b/CometServer/AutoGenServices/NestedElementService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var nestedElementColl = results.Where(i => i.GetType() == typeof(NestedElement)).Cast<NestedElement>().ToList();
+            var nestedElementColl = results.OfType<NestedElement>().ToList();
 
             results.AddRange(this.NestedParameterService.GetDeep(transaction, partition, nestedElementColl.SelectMany(x => x.NestedParameter), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/OptionService.cs b/CometServer/AutoGenServices/OptionService.cs
index 28d4360f..1140ef06 100644
--- a/CometServer/AutoGenServices/OptionService.cs
+++ b/CometServer/AutoGenServices/OptionService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var optionColl = results.Where(i => i.GetType() == typeof(Option)).Cast<Option>().ToList();
+            var optionColl = results.OfType<Option>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, optionColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, optionColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/OrdinalScaleService.cs b/CometServer/AutoGenServices/OrdinalScaleService.cs
index 938131bf..72743017 100644
--- a/CometServer/AutoGenServices/OrdinalScaleService.cs
+++ b/CometServer/AutoGenServices/OrdinalScaleService.cs
@@ -403,7 +403,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var ordinalScaleColl = results.Where(i => i.GetType() == typeof(OrdinalScale)).Cast<OrdinalScale>().ToList();
+            var ordinalScaleColl = results.OfType<OrdinalScale>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, ordinalScaleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, ordinalScaleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/OwnedStyleService.cs b/CometServer/AutoGenServices/OwnedStyleService.cs
index 2992f633..0e4ed638 100644
--- a/CometServer/AutoGenServices/OwnedStyleService.cs
+++ b/CometServer/AutoGenServices/OwnedStyleService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var ownedStyleColl = results.Where(i => i.GetType() == typeof(OwnedStyle)).Cast<OwnedStyle>().ToList();
+            var ownedStyleColl = results.OfType<OwnedStyle>().ToList();
 
             results.AddRange(this.UsedColorService.GetDeep(transaction, partition, ownedStyleColl.SelectMany(x => x.UsedColor), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/PageService.cs b/CometServer/AutoGenServices/PageService.cs
index f6d929d0..61029e45 100644
--- a/CometServer/AutoGenServices/PageService.cs
+++ b/CometServer/AutoGenServices/PageService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var pageColl = results.Where(i => i.GetType() == typeof(Page)).Cast<Page>().ToList();
+            var pageColl = results.OfType<Page>().ToList();
 
             results.AddRange(this.NoteService.GetDeep(transaction, partition, pageColl.SelectMany(x => x.Note).ToIdList(), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/ParameterOverrideService.cs b/CometServer/AutoGenServices/ParameterOverrideService.cs
index d61314f3..1306bbba 100644
--- a/CometServer/AutoGenServices/ParameterOverrideService.cs
+++ b/CometServer/AutoGenServices/ParameterOverrideService.cs
@@ -388,7 +388,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var parameterOverrideColl = results.Where(i => i.GetType() == typeof(ParameterOverride)).Cast<ParameterOverride>().ToList();
+            var parameterOverrideColl = results.OfType<ParameterOverride>().ToList();
 
             results.AddRange(this.ParameterSubscriptionService.GetDeep(transaction, partition, parameterOverrideColl.SelectMany(x => x.ParameterSubscription), containerSecurityContext));
             results.AddRange(this.ValueSetService.GetDeep(transaction, partition, parameterOverrideColl.SelectMany(x => x.ValueSet), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ParameterService.cs b/CometServer/AutoGenServices/ParameterService.cs
index af7ded10..d33bfa6d 100644
--- a/CometServer/AutoGenServices/ParameterService.cs
+++ b/CometServer/AutoGenServices/ParameterService.cs
@@ -388,7 +388,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var parameterColl = results.Where(i => i.GetType() == typeof(Parameter)).Cast<Parameter>().ToList();
+            var parameterColl = results.OfType<Parameter>().ToList();
 
             results.AddRange(this.ParameterSubscriptionService.GetDeep(transaction, partition, parameterColl.SelectMany(x => x.ParameterSubscription), containerSecurityContext));
             results.AddRange(this.ValueSetService.GetDeep(transaction, partition, parameterColl.SelectMany(x => x.ValueSet), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ParameterSubscriptionService.cs b/CometServer/AutoGenServices/ParameterSubscriptionService.cs
index 764f377d..759f69eb 100644
--- a/CometServer/AutoGenServices/ParameterSubscriptionService.cs
+++ b/CometServer/AutoGenServices/ParameterSubscriptionService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var parameterSubscriptionColl = results.Where(i => i.GetType() == typeof(ParameterSubscription)).Cast<ParameterSubscription>().ToList();
+            var parameterSubscriptionColl = results.OfType<ParameterSubscription>().ToList();
 
             results.AddRange(this.ValueSetService.GetDeep(transaction, partition, parameterSubscriptionColl.SelectMany(x => x.ValueSet), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/ParameterizedCategoryRuleService.cs b/CometServer/AutoGenServices/ParameterizedCategoryRuleService.cs
index df8f2fff..00a8106b 100644
--- a/CometServer/AutoGenServices/ParameterizedCategoryRuleService.cs
+++ b/CometServer/AutoGenServices/ParameterizedCategoryRuleService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var parameterizedCategoryRuleColl = results.Where(i => i.GetType() == typeof(ParameterizedCategoryRule)).Cast<ParameterizedCategoryRule>().ToList();
+            var parameterizedCategoryRuleColl = results.OfType<ParameterizedCategoryRule>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, parameterizedCategoryRuleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, parameterizedCategoryRuleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ParametricConstraintService.cs b/CometServer/AutoGenServices/ParametricConstraintService.cs
index 101f1ac3..0ab4f326 100644
--- a/CometServer/AutoGenServices/ParametricConstraintService.cs
+++ b/CometServer/AutoGenServices/ParametricConstraintService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var parametricConstraintColl = results.Where(i => i.GetType() == typeof(ParametricConstraint)).Cast<ParametricConstraint>().ToList();
+            var parametricConstraintColl = results.OfType<ParametricConstraint>().ToList();
 
             results.AddRange(this.ExpressionService.GetDeep(transaction, partition, parametricConstraintColl.SelectMany(x => x.Expression), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/ParticipantRoleService.cs b/CometServer/AutoGenServices/ParticipantRoleService.cs
index d84d031f..6ada76e9 100644
--- a/CometServer/AutoGenServices/ParticipantRoleService.cs
+++ b/CometServer/AutoGenServices/ParticipantRoleService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var participantRoleColl = results.Where(i => i.GetType() == typeof(ParticipantRole)).Cast<ParticipantRole>().ToList();
+            var participantRoleColl = results.OfType<ParticipantRole>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, participantRoleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, participantRoleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/PersonRoleService.cs b/CometServer/AutoGenServices/PersonRoleService.cs
index d050bd9e..23ec97b8 100644
--- a/CometServer/AutoGenServices/PersonRoleService.cs
+++ b/CometServer/AutoGenServices/PersonRoleService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var personRoleColl = results.Where(i => i.GetType() == typeof(PersonRole)).Cast<PersonRole>().ToList();
+            var personRoleColl = results.OfType<PersonRole>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, personRoleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, personRoleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/PersonService.cs b/CometServer/AutoGenServices/PersonService.cs
index 240b0566..59c0a7cd 100644
--- a/CometServer/AutoGenServices/PersonService.cs
+++ b/CometServer/AutoGenServices/PersonService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var personColl = results.Where(i => i.GetType() == typeof(Person)).Cast<Person>().ToList();
+            var personColl = results.OfType<Person>().ToList();
 
             results.AddRange(this.EmailAddressService.GetDeep(transaction, partition, personColl.SelectMany(x => x.EmailAddress), containerSecurityContext));
             results.AddRange(this.TelephoneNumberService.GetDeep(transaction, partition, personColl.SelectMany(x => x.TelephoneNumber), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/PossibleFiniteStateListService.cs b/CometServer/AutoGenServices/PossibleFiniteStateListService.cs
index 1bad193d..e9768d5b 100644
--- a/CometServer/AutoGenServices/PossibleFiniteStateListService.cs
+++ b/CometServer/AutoGenServices/PossibleFiniteStateListService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var possibleFiniteStateListColl = results.Where(i => i.GetType() == typeof(PossibleFiniteStateList)).Cast<PossibleFiniteStateList>().ToList();
+            var possibleFiniteStateListColl = results.OfType<PossibleFiniteStateList>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, possibleFiniteStateListColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, possibleFiniteStateListColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/PossibleFiniteStateService.cs b/CometServer/AutoGenServices/PossibleFiniteStateService.cs
index 0abadba7..a7e8b515 100644
--- a/CometServer/AutoGenServices/PossibleFiniteStateService.cs
+++ b/CometServer/AutoGenServices/PossibleFiniteStateService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var possibleFiniteStateColl = results.Where(i => i.GetType() == typeof(PossibleFiniteState)).Cast<PossibleFiniteState>().ToList();
+            var possibleFiniteStateColl = results.OfType<PossibleFiniteState>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, possibleFiniteStateColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, possibleFiniteStateColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/PrefixedUnitService.cs b/CometServer/AutoGenServices/PrefixedUnitService.cs
index 5d2566b1..b64c1308 100644
--- a/CometServer/AutoGenServices/PrefixedUnitService.cs
+++ b/CometServer/AutoGenServices/PrefixedUnitService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var prefixedUnitColl = results.Where(i => i.GetType() == typeof(PrefixedUnit)).Cast<PrefixedUnit>().ToList();
+            var prefixedUnitColl = results.OfType<PrefixedUnit>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, prefixedUnitColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, prefixedUnitColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/RatioScaleService.cs b/CometServer/AutoGenServices/RatioScaleService.cs
index f400ae6c..96ed00a6 100644
--- a/CometServer/AutoGenServices/RatioScaleService.cs
+++ b/CometServer/AutoGenServices/RatioScaleService.cs
@@ -427,7 +427,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var ratioScaleColl = results.Where(i => i.GetType() == typeof(RatioScale)).Cast<RatioScale>().ToList();
+            var ratioScaleColl = results.OfType<RatioScale>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, ratioScaleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, ratioScaleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ReferenceSourceService.cs b/CometServer/AutoGenServices/ReferenceSourceService.cs
index 7dd59931..1c8ab1b8 100644
--- a/CometServer/AutoGenServices/ReferenceSourceService.cs
+++ b/CometServer/AutoGenServices/ReferenceSourceService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var referenceSourceColl = results.Where(i => i.GetType() == typeof(ReferenceSource)).Cast<ReferenceSource>().ToList();
+            var referenceSourceColl = results.OfType<ReferenceSource>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, referenceSourceColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, referenceSourceColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ReferencerRuleService.cs b/CometServer/AutoGenServices/ReferencerRuleService.cs
index 3927fef5..fe667826 100644
--- a/CometServer/AutoGenServices/ReferencerRuleService.cs
+++ b/CometServer/AutoGenServices/ReferencerRuleService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var referencerRuleColl = results.Where(i => i.GetType() == typeof(ReferencerRule)).Cast<ReferencerRule>().ToList();
+            var referencerRuleColl = results.OfType<ReferencerRule>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, referencerRuleColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, referencerRuleColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/RequestForDeviationService.cs b/CometServer/AutoGenServices/RequestForDeviationService.cs
index 74280b4f..db9e4e77 100644
--- a/CometServer/AutoGenServices/RequestForDeviationService.cs
+++ b/CometServer/AutoGenServices/RequestForDeviationService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var requestForDeviationColl = results.Where(i => i.GetType() == typeof(RequestForDeviation)).Cast<RequestForDeviation>().ToList();
+            var requestForDeviationColl = results.OfType<RequestForDeviation>().ToList();
 
             results.AddRange(this.ApprovedByService.GetDeep(transaction, partition, requestForDeviationColl.SelectMany(x => x.ApprovedBy), containerSecurityContext));
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, requestForDeviationColl.SelectMany(x => x.Discussion), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/RequestForWaiverService.cs b/CometServer/AutoGenServices/RequestForWaiverService.cs
index 87e5347b..c260ea39 100644
--- a/CometServer/AutoGenServices/RequestForWaiverService.cs
+++ b/CometServer/AutoGenServices/RequestForWaiverService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var requestForWaiverColl = results.Where(i => i.GetType() == typeof(RequestForWaiver)).Cast<RequestForWaiver>().ToList();
+            var requestForWaiverColl = results.OfType<RequestForWaiver>().ToList();
 
             results.AddRange(this.ApprovedByService.GetDeep(transaction, partition, requestForWaiverColl.SelectMany(x => x.ApprovedBy), containerSecurityContext));
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, requestForWaiverColl.SelectMany(x => x.Discussion), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/RequirementService.cs b/CometServer/AutoGenServices/RequirementService.cs
index 050bbe78..b724c9e0 100644
--- a/CometServer/AutoGenServices/RequirementService.cs
+++ b/CometServer/AutoGenServices/RequirementService.cs
@@ -403,7 +403,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var requirementColl = results.Where(i => i.GetType() == typeof(Requirement)).Cast<Requirement>().ToList();
+            var requirementColl = results.OfType<Requirement>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, requirementColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, requirementColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/RequirementsGroupService.cs b/CometServer/AutoGenServices/RequirementsGroupService.cs
index cddaef6c..6e878cf3 100644
--- a/CometServer/AutoGenServices/RequirementsGroupService.cs
+++ b/CometServer/AutoGenServices/RequirementsGroupService.cs
@@ -403,7 +403,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var requirementsGroupColl = results.Where(i => i.GetType() == typeof(RequirementsGroup)).Cast<RequirementsGroup>().ToList();
+            var requirementsGroupColl = results.OfType<RequirementsGroup>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, requirementsGroupColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, requirementsGroupColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/RequirementsSpecificationService.cs b/CometServer/AutoGenServices/RequirementsSpecificationService.cs
index 78810552..5445ca72 100644
--- a/CometServer/AutoGenServices/RequirementsSpecificationService.cs
+++ b/CometServer/AutoGenServices/RequirementsSpecificationService.cs
@@ -408,7 +408,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var requirementsSpecificationColl = results.Where(i => i.GetType() == typeof(RequirementsSpecification)).Cast<RequirementsSpecification>().ToList();
+            var requirementsSpecificationColl = results.OfType<RequirementsSpecification>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, requirementsSpecificationColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, requirementsSpecificationColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ReviewItemDiscrepancyService.cs b/CometServer/AutoGenServices/ReviewItemDiscrepancyService.cs
index 6c02b004..dbecaff0 100644
--- a/CometServer/AutoGenServices/ReviewItemDiscrepancyService.cs
+++ b/CometServer/AutoGenServices/ReviewItemDiscrepancyService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var reviewItemDiscrepancyColl = results.Where(i => i.GetType() == typeof(ReviewItemDiscrepancy)).Cast<ReviewItemDiscrepancy>().ToList();
+            var reviewItemDiscrepancyColl = results.OfType<ReviewItemDiscrepancy>().ToList();
 
             results.AddRange(this.ApprovedByService.GetDeep(transaction, partition, reviewItemDiscrepancyColl.SelectMany(x => x.ApprovedBy), containerSecurityContext));
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, reviewItemDiscrepancyColl.SelectMany(x => x.Discussion), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/RuleVerificationListService.cs b/CometServer/AutoGenServices/RuleVerificationListService.cs
index 9f074849..b5f24f2a 100644
--- a/CometServer/AutoGenServices/RuleVerificationListService.cs
+++ b/CometServer/AutoGenServices/RuleVerificationListService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var ruleVerificationListColl = results.Where(i => i.GetType() == typeof(RuleVerificationList)).Cast<RuleVerificationList>().ToList();
+            var ruleVerificationListColl = results.OfType<RuleVerificationList>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, ruleVerificationListColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, ruleVerificationListColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/SampledFunctionParameterTypeService.cs b/CometServer/AutoGenServices/SampledFunctionParameterTypeService.cs
index c33fa5c7..02d29d51 100644
--- a/CometServer/AutoGenServices/SampledFunctionParameterTypeService.cs
+++ b/CometServer/AutoGenServices/SampledFunctionParameterTypeService.cs
@@ -403,7 +403,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var sampledFunctionParameterTypeColl = results.Where(i => i.GetType() == typeof(SampledFunctionParameterType)).Cast<SampledFunctionParameterType>().ToList();
+            var sampledFunctionParameterTypeColl = results.OfType<SampledFunctionParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, sampledFunctionParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, sampledFunctionParameterTypeColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/ScaleValueDefinitionService.cs b/CometServer/AutoGenServices/ScaleValueDefinitionService.cs
index 1647ecbc..12f97781 100644
--- a/CometServer/AutoGenServices/ScaleValueDefinitionService.cs
+++ b/CometServer/AutoGenServices/ScaleValueDefinitionService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var scaleValueDefinitionColl = results.Where(i => i.GetType() == typeof(ScaleValueDefinition)).Cast<ScaleValueDefinition>().ToList();
+            var scaleValueDefinitionColl = results.OfType<ScaleValueDefinition>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, scaleValueDefinitionColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, scaleValueDefinitionColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/SectionService.cs b/CometServer/AutoGenServices/SectionService.cs
index 28b8e6bb..4c387633 100644
--- a/CometServer/AutoGenServices/SectionService.cs
+++ b/CometServer/AutoGenServices/SectionService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var sectionColl = results.Where(i => i.GetType() == typeof(Section)).Cast<Section>().ToList();
+            var sectionColl = results.OfType<Section>().ToList();
 
             results.AddRange(this.PageService.GetDeep(transaction, partition, sectionColl.SelectMany(x => x.Page).ToIdList(), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/SharedStyleService.cs b/CometServer/AutoGenServices/SharedStyleService.cs
index 3d7eb3a4..50c5f780 100644
--- a/CometServer/AutoGenServices/SharedStyleService.cs
+++ b/CometServer/AutoGenServices/SharedStyleService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var sharedStyleColl = results.Where(i => i.GetType() == typeof(SharedStyle)).Cast<SharedStyle>().ToList();
+            var sharedStyleColl = results.OfType<SharedStyle>().ToList();
 
             results.AddRange(this.UsedColorService.GetDeep(transaction, partition, sharedStyleColl.SelectMany(x => x.UsedColor), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/SimpleQuantityKindService.cs b/CometServer/AutoGenServices/SimpleQuantityKindService.cs
index ef34c6e6..57219497 100644
--- a/CometServer/AutoGenServices/SimpleQuantityKindService.cs
+++ b/CometServer/AutoGenServices/SimpleQuantityKindService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var simpleQuantityKindColl = results.Where(i => i.GetType() == typeof(SimpleQuantityKind)).Cast<SimpleQuantityKind>().ToList();
+            var simpleQuantityKindColl = results.OfType<SimpleQuantityKind>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, simpleQuantityKindColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, simpleQuantityKindColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/SimpleUnitService.cs b/CometServer/AutoGenServices/SimpleUnitService.cs
index 3bda2090..da9c91dc 100644
--- a/CometServer/AutoGenServices/SimpleUnitService.cs
+++ b/CometServer/AutoGenServices/SimpleUnitService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var simpleUnitColl = results.Where(i => i.GetType() == typeof(SimpleUnit)).Cast<SimpleUnit>().ToList();
+            var simpleUnitColl = results.OfType<SimpleUnit>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, simpleUnitColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, simpleUnitColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/SiteDirectoryDataAnnotationService.cs b/CometServer/AutoGenServices/SiteDirectoryDataAnnotationService.cs
index 56b25bb7..8defb096 100644
--- a/CometServer/AutoGenServices/SiteDirectoryDataAnnotationService.cs
+++ b/CometServer/AutoGenServices/SiteDirectoryDataAnnotationService.cs
@@ -388,7 +388,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var siteDirectoryDataAnnotationColl = results.Where(i => i.GetType() == typeof(SiteDirectoryDataAnnotation)).Cast<SiteDirectoryDataAnnotation>().ToList();
+            var siteDirectoryDataAnnotationColl = results.OfType<SiteDirectoryDataAnnotation>().ToList();
 
             results.AddRange(this.DiscussionService.GetDeep(transaction, partition, siteDirectoryDataAnnotationColl.SelectMany(x => x.Discussion), containerSecurityContext));
             results.AddRange(this.RelatedThingService.GetDeep(transaction, partition, siteDirectoryDataAnnotationColl.SelectMany(x => x.RelatedThing), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/SiteDirectoryService.cs b/CometServer/AutoGenServices/SiteDirectoryService.cs
index c0bf0e20..4d6e21a4 100644
--- a/CometServer/AutoGenServices/SiteDirectoryService.cs
+++ b/CometServer/AutoGenServices/SiteDirectoryService.cs
@@ -457,7 +457,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var siteDirectoryColl = results.Where(i => i.GetType() == typeof(SiteDirectory)).Cast<SiteDirectory>().ToList();
+            var siteDirectoryColl = results.OfType<SiteDirectory>().ToList();
 
             results.AddRange(this.AnnotationService.GetDeep(transaction, partition, siteDirectoryColl.SelectMany(x => x.Annotation), containerSecurityContext));
             results.AddRange(this.DomainService.GetDeep(transaction, partition, siteDirectoryColl.SelectMany(x => x.Domain), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/SiteLogEntryService.cs b/CometServer/AutoGenServices/SiteLogEntryService.cs
index e5f81748..40cb3908 100644
--- a/CometServer/AutoGenServices/SiteLogEntryService.cs
+++ b/CometServer/AutoGenServices/SiteLogEntryService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var siteLogEntryColl = results.Where(i => i.GetType() == typeof(SiteLogEntry)).Cast<SiteLogEntry>().ToList();
+            var siteLogEntryColl = results.OfType<SiteLogEntry>().ToList();
 
             results.AddRange(this.LogEntryChangelogItemService.GetDeep(transaction, partition, siteLogEntryColl.SelectMany(x => x.LogEntryChangelogItem), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/SiteReferenceDataLibraryService.cs b/CometServer/AutoGenServices/SiteReferenceDataLibraryService.cs
index 31e0396c..375e8177 100644
--- a/CometServer/AutoGenServices/SiteReferenceDataLibraryService.cs
+++ b/CometServer/AutoGenServices/SiteReferenceDataLibraryService.cs
@@ -449,7 +449,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
                 // eventhough extent=deep retrieve mode is requested this has to be e includeRference data needs to be set to true as well to get the deep result 
                 return results;
             }
-            var siteReferenceDataLibraryColl = results.Where(i => i.GetType() == typeof(SiteReferenceDataLibrary)).Cast<SiteReferenceDataLibrary>().ToList();
+            var siteReferenceDataLibraryColl = results.OfType<SiteReferenceDataLibrary>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, siteReferenceDataLibraryColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.ConstantService.GetDeep(transaction, partition, siteReferenceDataLibraryColl.SelectMany(x => x.Constant), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/SpecializedQuantityKindService.cs b/CometServer/AutoGenServices/SpecializedQuantityKindService.cs
index f60ddb5f..59e4d912 100644
--- a/CometServer/AutoGenServices/SpecializedQuantityKindService.cs
+++ b/CometServer/AutoGenServices/SpecializedQuantityKindService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var specializedQuantityKindColl = results.Where(i => i.GetType() == typeof(SpecializedQuantityKind)).Cast<SpecializedQuantityKind>().ToList();
+            var specializedQuantityKindColl = results.OfType<SpecializedQuantityKind>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, specializedQuantityKindColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, specializedQuantityKindColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/StakeHolderValueMapService.cs b/CometServer/AutoGenServices/StakeHolderValueMapService.cs
index 92f954d1..33580241 100644
--- a/CometServer/AutoGenServices/StakeHolderValueMapService.cs
+++ b/CometServer/AutoGenServices/StakeHolderValueMapService.cs
@@ -398,7 +398,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var stakeHolderValueMapColl = results.Where(i => i.GetType() == typeof(StakeHolderValueMap)).Cast<StakeHolderValueMap>().ToList();
+            var stakeHolderValueMapColl = results.OfType<StakeHolderValueMap>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, stakeHolderValueMapColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, stakeHolderValueMapColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/StakeholderService.cs b/CometServer/AutoGenServices/StakeholderService.cs
index 0d532060..87036536 100644
--- a/CometServer/AutoGenServices/StakeholderService.cs
+++ b/CometServer/AutoGenServices/StakeholderService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var stakeholderColl = results.Where(i => i.GetType() == typeof(Stakeholder)).Cast<Stakeholder>().ToList();
+            var stakeholderColl = results.OfType<Stakeholder>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, stakeholderColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, stakeholderColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/StakeholderValueService.cs b/CometServer/AutoGenServices/StakeholderValueService.cs
index 713bfe5b..cd8e2c41 100644
--- a/CometServer/AutoGenServices/StakeholderValueService.cs
+++ b/CometServer/AutoGenServices/StakeholderValueService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var stakeholderValueColl = results.Where(i => i.GetType() == typeof(StakeholderValue)).Cast<StakeholderValue>().ToList();
+            var stakeholderValueColl = results.OfType<StakeholderValue>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, stakeholderValueColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, stakeholderValueColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/TermService.cs b/CometServer/AutoGenServices/TermService.cs
index e083f0fc..71b1d62d 100644
--- a/CometServer/AutoGenServices/TermService.cs
+++ b/CometServer/AutoGenServices/TermService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var termColl = results.Where(i => i.GetType() == typeof(Term)).Cast<Term>().ToList();
+            var termColl = results.OfType<Term>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, termColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, termColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/TextParameterTypeService.cs b/CometServer/AutoGenServices/TextParameterTypeService.cs
index 35d257a0..befecbfd 100644
--- a/CometServer/AutoGenServices/TextParameterTypeService.cs
+++ b/CometServer/AutoGenServices/TextParameterTypeService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var textParameterTypeColl = results.Where(i => i.GetType() == typeof(TextParameterType)).Cast<TextParameterType>().ToList();
+            var textParameterTypeColl = results.OfType<TextParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, textParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, textParameterTypeColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/TimeOfDayParameterTypeService.cs b/CometServer/AutoGenServices/TimeOfDayParameterTypeService.cs
index 8121c839..c82ca752 100644
--- a/CometServer/AutoGenServices/TimeOfDayParameterTypeService.cs
+++ b/CometServer/AutoGenServices/TimeOfDayParameterTypeService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var timeOfDayParameterTypeColl = results.Where(i => i.GetType() == typeof(TimeOfDayParameterType)).Cast<TimeOfDayParameterType>().ToList();
+            var timeOfDayParameterTypeColl = results.OfType<TimeOfDayParameterType>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, timeOfDayParameterTypeColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, timeOfDayParameterTypeColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/UnitPrefixService.cs b/CometServer/AutoGenServices/UnitPrefixService.cs
index e5c7db03..d06f2f57 100644
--- a/CometServer/AutoGenServices/UnitPrefixService.cs
+++ b/CometServer/AutoGenServices/UnitPrefixService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var unitPrefixColl = results.Where(i => i.GetType() == typeof(UnitPrefix)).Cast<UnitPrefix>().ToList();
+            var unitPrefixColl = results.OfType<UnitPrefix>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, unitPrefixColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, unitPrefixColl.SelectMany(x => x.Definition), containerSecurityContext));
diff --git a/CometServer/AutoGenServices/UserRuleVerificationService.cs b/CometServer/AutoGenServices/UserRuleVerificationService.cs
index 61757c90..1ac12664 100644
--- a/CometServer/AutoGenServices/UserRuleVerificationService.cs
+++ b/CometServer/AutoGenServices/UserRuleVerificationService.cs
@@ -383,7 +383,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var userRuleVerificationColl = results.Where(i => i.GetType() == typeof(UserRuleVerification)).Cast<UserRuleVerification>().ToList();
+            var userRuleVerificationColl = results.OfType<UserRuleVerification>().ToList();
 
             results.AddRange(this.ViolationService.GetDeep(transaction, partition, userRuleVerificationColl.SelectMany(x => x.Violation), containerSecurityContext));
 
diff --git a/CometServer/AutoGenServices/ValueGroupService.cs b/CometServer/AutoGenServices/ValueGroupService.cs
index f195c6b5..f81d2460 100644
--- a/CometServer/AutoGenServices/ValueGroupService.cs
+++ b/CometServer/AutoGenServices/ValueGroupService.cs
@@ -393,7 +393,7 @@ public IEnumerable<Thing> GetDeep(NpgsqlTransaction transaction, string partitio
             }
 
             var results = new List<Thing>(this.GetShallow(transaction, partition, idFilter, containerSecurityContext));
-            var valueGroupColl = results.Where(i => i.GetType() == typeof(ValueGroup)).Cast<ValueGroup>().ToList();
+            var valueGroupColl = results.OfType<ValueGroup>().ToList();
 
             results.AddRange(this.AliasService.GetDeep(transaction, partition, valueGroupColl.SelectMany(x => x.Alias), containerSecurityContext));
             results.AddRange(this.DefinitionService.GetDeep(transaction, partition, valueGroupColl.SelectMany(x => x.Definition), containerSecurityContext));