Profile io.ucaiug.cimtool.generated string abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ Annotated C# for Generated by CIMTool https://cimtool.ucaiug.io [cimtool.ucaiug.io] DO NOT EDIT — this file is fully regenerated by CIMTool on every build. Hand-written customisations belong in partial class files alongside this one. using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations.Schema; using System.Linq.Expressions; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; Entity Framework Core entity classes generated from the <b>CoreEquipment</b> CIMTool profile. <b>No <c>ICollection&lt;T&gt;</c> Properties — Intentional Design</b><br/> Collection-valued inverse navigation properties (<c>ICollection&lt;T&gt;</c>) are intentionally not generated. Single-valued foreign-key relationships are fully mapped; inverse one-to-many collections are omitted by design, not by omission. EF Core does not require them to configure or resolve a relationship. They are excluded because: CIM associations are unbounded by definition. Materialising an unbounded <c>ICollection&lt;T&gt;</c> into memory with no pagination is a runtime hazard for large profiles such as CGMES CoreEquipment. They introduce circular-reference risk during JSON serialisation with <c>System.Text.Json</c> or <c>Newtonsoft.Json</c> unless reference handling is explicitly configured. Inverse associations are profile-dependent and not present in all profiles, making generated <c>ICollection&lt;T&gt;</c> properties inconsistent across profiles. Bidirectional EF Core mappings require both sides to be kept in sync on every add/remove, adding fragility to consumer code. Explicit LINQ queries support pagination, filtering, and sorting that a generated collection property never can. To navigate from a parent entity to its children, query through the child side using LINQ: // All children for a given parent (via shadow FK): var units = context.Set<PowerElectronicsUnit>() .Where(u => u.PowerElectronicsConnectionId == connection.MRId) .ToList(); // With pagination for large result sets: var equipment = context.Set<Equipment>() .Where(e => e.EquipmentContainerId == substation.MRId) .Skip(0).Take(100).ToList(); Consumers who need inverse navigation for specific patterns can add <c>ICollection&lt;T&gt;</c> properties non-destructively via <c>partial class</c> declarations without modifying this generated file. <b>Compound Type References</b><br/> CIM Compound types are treated as value objects — each compound row has exactly one owner and is never shared across parent columns or rows. Each compound reference is represented as a shadow FK string property (e.g. <c>ElectronicAddressId</c>) paired with a nullable navigation property (e.g. <c>ElectronicAddress?</c>). The companion SQL DDL emits <c>ON DELETE CASCADE</c> for every compound FK (via a reverse-reference pattern that cascades in the correct owner-to-compound direction). The generated <c>ModelConfiguration</c> applies <c>DeleteBehavior.Restrict</c> for compound relationships, enforcing the ownership invariant at the EF Core layer: compounds must never be deleted directly — only through their parent. The generated <c>DbContextBase</c> <c>SaveChanges</c> and <c>SaveChangesAsync</c> overrides detect orphaned compound rows after each save and clean them up automatically. Each compound entity constructor assigns a new <see cref="System.Guid"/> to its <c>Id</c> property on instantiation, satisfying the strict one-compound-per-slot ownership invariant. <b>DbSet&lt;T&gt; Scope — Entity Classes Only</b><br/> <c>DbSet&lt;T&gt;</c> properties in the generated <c>DbContextBase</c> are limited to persistent CIM entity classes — classes that represent independently-addressable objects with their own primary key (natural <c>mRID</c> for IdentifiedObject subclasses, or a surrogate <c>id</c> for non-IdentifiedObject classes such as <c>CurveData</c>). Compound types and enumerated types are intentionally excluded. Compounds are value objects owned exclusively by their parent — exposing them as first-class <c>DbSet&lt;T&gt;</c> properties would invite independent querying and direct deletion, both of which violate the ownership invariant. Enumerated types are referenced only by their string literal values at runtime and lookup table rows are never queried in well-written application code. Both remain accessible via <c>context.Set&lt;T&gt;()</c> when direct access is genuinely needed. <b>DbContext Integration</b><br/> This file includes a generated <c>DbContextBase</c> nested abstract class containing DbSet properties, complete EF Core Fluent API configuration, and compound orphan cleanup logic. Create the following subclass once in your project — it will not be overwritten by CIMTool: public class DbContext : .DbContextBase public DbContext(DbContextOptions<DbContext> options) : base(options) { } public class [Table("")] [Index(nameof(Id), IsUnique = true)] public class : public class // Inherits from - configure further in EF Fluent API if needed public () { } public override string ToString() { return this.GetType().Name; } Determines whether this instance and a specified object represent the same , compared by runtime type and <c>MRId</c>. The object to compare with this instance. <c>true</c> if <paramref name="obj"/> is the same concrete type as this instance and both have an equal, non-null <c>MRId</c>; otherwise <c>false</c>. The runtime-type guard ensures two different subclasses with coincidentally identical UUIDs are never considered equal. Returning <c>false</c> when <c>MRId</c> is <c>null</c> is consistent with the EF Core convention that a transient (not-yet-persisted) entity is not equal to any other entity. All subclasses inherit this implementation and must not override it. public override bool Equals(object? obj) if (obj is not other) return false; if (ReferenceEquals(this, other)) return true; if (GetType() != other.GetType()) return false; return MRId != null && MRId == other.MRId; Returns a hash code based on runtime type and <c>MRId</c>. A hash code combining the runtime type and <c>MRId</c>, consistent with the <see cref="Equals"/> override. All subclasses inherit this implementation. public override int GetHashCode() => HashCode.Combine(GetType(), MRId); [Index(, IsUnique = true)] public class : // Inherits surrogate 'id' key from — do not redeclare [Key] here. // Neither this class nor its parent inherits from IdentifiedObject. // EF Core maps this as TPT using the shared surrogate 'id' PK. public () { } public override string ToString() { return this.GetType().Name; } public class public () { } public override string ToString() { return this.GetType().Name; } Determines whether this instance and a specified object represent the same <c></c>, compared by runtime type and surrogate <c>Id</c>. The object to compare with this instance. <c>true</c> if <paramref name="obj"/> is the same concrete type as this instance and both have an equal, non-null surrogate <c>Id</c>; otherwise <c>false</c>. This class uses a surrogate <c>Id</c> rather than a natural <c>MRId</c> because it does not inherit from IdentifiedObject. The runtime-type guard ensures subclasses with the same surrogate <c>Id</c> are not considered equal. Returning <c>false</c> when <c>Id</c> is <c>null</c> is consistent with the convention that a transient entity is not equal to any other entity. Subclasses inherit this implementation and must not override it. public override bool Equals(object? obj) if (obj is not other) return false; if (ReferenceEquals(this, other)) return true; if (GetType() != other.GetType()) return false; return Id != null && Id == other.Id; Returns a hash code based on runtime type and surrogate <c>Id</c>. A hash code combining the runtime type and <c>Id</c>, consistent with the <see cref="Equals"/> override. Subclasses inherit this implementation. public override int GetHashCode() => HashCode.Combine(GetType(), Id); Surrogate primary key — this class does not inherit from IdentifiedObject and has no natural single-column primary key. This surrogate 'id' is a persistence artefact. The [Index] above enforces a heuristic uniqueness constraint across all required non-surrogate columns as a guard against semantically corrupt duplicate rows. See the template documentation in the XSLT source for a full explanation of the design tradeoffs. [Key] [Column("id")] [MaxLength(100)] public string Id { get; set; } = null!; [Table("")] [Index(nameof(Id), IsUnique = true)] public class Initialises a new <c></c> and assigns a new UUID to <c>Id</c>, satisfying the compound value object ownership invariant: each compound row has exactly one owner and must carry a unique surrogate id that is never shared across parent columns or parent rows. See the companion sql-rdfs-ansi92 DDL script for full details. public () { Id = System.Guid.NewGuid().ToString(); } public override string ToString() { return this.GetType().Name; } Determines whether this instance and a specified object represent the same <c></c> compound value object, compared by surrogate <c>Id</c>. The object to compare with this instance. <c>true</c> if <paramref name="obj"/> is a <c></c> with the same <c>Id</c>; otherwise <c>false</c>. Compound types are value objects — each row has exactly one owner and its <c>Id</c> is a UUID assigned on construction, so <c>Id</c> is never <c>null</c> and no null guard is required. public override bool Equals(object? obj) if (obj is not other) return false; if (ReferenceEquals(this, other)) return true; return Id == other.Id; Returns a hash code based on the surrogate <c>Id</c> of this instance. The hash code of <c>Id</c>, consistent with the <see cref="Equals"/> override. public override int GetHashCode() => Id.GetHashCode(); [Key] [Column("id")] [MaxLength(100)] public string Id { get; set; } = null!; [Table("")] public class public () { } public override string ToString() { return this.GetType().Name; } Determines whether this instance and a specified object represent the same <c></c> enumeration literal, compared by <c>Name</c>. The object to compare with this instance. <c>true</c> if <paramref name="obj"/> is a <c></c> with the same non-null <c>Name</c>; otherwise <c>false</c>. Enumeration types are lookup tables keyed on <c>Name</c>. Returning <c>false</c> when <c>Name</c> is <c>null</c> is consistent with the convention that a transient entity is not equal to any other entity. public override bool Equals(object? obj) if (obj is not other) return false; if (ReferenceEquals(this, other)) return true; return Name != null && Name == other.Name; Returns a hash code based on the <c>Name</c> of this enumeration literal. The hash code of <c>Name</c>, or zero if <c>Name</c> is <c>null</c>, consistent with the <see cref="Equals"/> override. public override int GetHashCode() => Name?.GetHashCode() ?? 0; [Key] [Column("name")] [MaxLength(100)] public string Name { get; set; } = null!; typeof() [Key] [Column("")] public string { get; set; } = null!; public string { get; set; } = null!; public string? { get; set; } public { get; set; } public ? { get; set; } [Column("")] [MaxLength(100)] public string Id { get; set; } = null!; public string? Id { get; set; } [ForeignKey(nameof(Id))] public virtual ? { get; set; } ──────────────────────────────────────────────────────────────────────────────────────────────── Suppressed Collection Navigation: → [..*] The profile declares a [..*] association on this class to . A collection navigation property has been intentionally suppressed: // NOT generated public virtual ICollection<> { get; set; } See the assembly-level <remarks> block at the top of this file for the full rationale. In summary: unbounded collections risk loading entire result sets into memory with no pagination, are not consistently present across profiles, and introduce serialisation and change-tracking fragility. Instead, use an explicit LINQ query such as: Basic traversal: IQueryable<> results = ctx.Set<>() .Where(x => x.Id == this.); Paginated traversal: var page = await ctx.Set<>() .Where(x => x.Id == this.) .OrderBy(x => x.MRId) .OrderBy(x => x.MRId) .Skip(offset).Take(pageSize) .ToListAsync(); ──────────────────────────────────────────────────────────────────────────────────────────────── [Column("")] [MaxLength(100)] public string { get; set; } = null!; public string? { get; set; } public const string = ""; public static readonly System.Type[] allClasses = new System.Type[] Generated EF Core Fluent API configuration for the profile. Called automatically from <c>DbContextBase.OnModelCreating</c> — no manual wiring is required when using the generated <c>DbContextBase</c>. This class is fully regenerated by CIMTool — do not edit manually. <b>Restrict vs ClientNoAction Delete Behavior</b><br/> Two distinct <c>DeleteBehavior</c> values are configured depending on relationship kind: <c>DeleteBehavior.Restrict</c> — CIM Compound type references (e.g. <c>ElectronicAddress</c>, <c>Status</c>, <c>TelephoneNumber</c>). Compounds are value objects with exactly one owner. Direct compound deletion violates the ownership invariant and is rejected by EF Core at the change-tracker layer. Compound cleanup is handled in the correct direction — parent deleted first, then orphaned compounds — by the generated <c>SaveChanges</c> overrides in <c>DbContextBase</c>. The companion SQL DDL emits <c>ON DELETE CASCADE</c> as a safety net at the database level. <c>DeleteBehavior.ClientNoAction</c> — associations between independent IdentifiedObject entities. These carry no DB-level cascade and deleting one end must not silently delete the other. Cascade responsibility is left entirely to the application. public static class ModelConfiguration public static void ConfigureModel(ModelBuilder modelBuilder) Configure(modelBuilder); Configure(modelBuilder); Configure(modelBuilder); Generated abstract base DbContext for the profile. Subclass this once in your project to obtain a fully functional EF Core DbContext with compound orphan cleanup and all entity DbSet properties. This class is fully regenerated by CIMTool — do not edit manually. Compound lifecycle is managed automatically: <c>SaveChanges</c> and <c>SaveChangesAsync</c> detect and delete orphaned compound rows after each save. No hand-written cleanup logic is required. Create the following thin subclass once in your project: public class DbContext : .DbContextBase public DbContext(DbContextOptions<DbContext> options) : base(options) { } public abstract class DbContextBase : DbContext DbSet<T> properties are generated for persistent CIM entity classes only — classes with their own primary key (mRID or surrogate id). Compound types and enumerated types are intentionally excluded: compounds are value objects owned exclusively by their parent — exposing them as DbSet<T> would invite independent querying and direct deletion, violating the ownership invariant. Enumerated types are referenced only by string literals and never queried at runtime in normal application code. Both are accessible via context.Set<T>() when direct access is needed. See the file-level <remarks> for the full rationale. public DbSet<.> s => Set<.>(); Initialises a new instance of <c>DbContextBase</c> with the supplied EF Core options. Use this constructor when registering the context with a dependency injection container: services.AddDbContext<DbContext>(options => options.UseSqlServer(connectionString)); The EF Core options for this context, typically supplied by the host's dependency injection container. protected DbContextBase(DbContextOptions options) : base(options) { } protected override void OnModelCreating(ModelBuilder modelBuilder) => .ModelConfiguration.ConfigureModel(modelBuilder); public override int SaveChanges() var orphans = CollectCompoundOrphans(); var rows = base.SaveChanges(); if (orphans.Count == 0) return rows; DeleteOrphanedCompounds(orphans); return rows + base.SaveChanges(); public override int SaveChanges(bool acceptAllChangesOnSuccess) var orphans = CollectCompoundOrphans(); var rows = base.SaveChanges(acceptAllChangesOnSuccess); if (orphans.Count == 0) return rows; DeleteOrphanedCompounds(orphans); return rows + base.SaveChanges(acceptAllChangesOnSuccess); public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) var orphans = CollectCompoundOrphans(); var rows = await base.SaveChangesAsync(cancellationToken); if (orphans.Count == 0) return rows; DeleteOrphanedCompounds(orphans); return rows + await base.SaveChangesAsync(cancellationToken); public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default) var orphans = CollectCompoundOrphans(); var rows = await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken); if (orphans.Count == 0) return rows; DeleteOrphanedCompounds(orphans); return rows + await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken); private List<(Type Type, string Id)> CollectCompoundOrphans() ChangeTracker.DetectChanges(); var orphans = new List<(Type Type, string Id)>(); foreach (var entry in ChangeTracker.Entries<.>()) if (entry.State is not EntityState.Modified and not EntityState.Deleted) continue; CollectOrphan(entry, nameof(..Id), typeof(.), orphans); Phase 2: expand orphans for compound types that have their own compound children. Compounds orphaned via a parent FK change remain Unchanged in the change tracker and are invisible to Phase 1. The do/while loop handles arbitrary nesting depth — each iteration discovers the next level of nested compounds until no new entries are added. The deduplication guard prevents re-processing already-expanded entries. int countBefore; do countBefore = orphans.Count; foreach (var (_, id) in orphans.Where(o => o.Type == typeof(.)).ToList()) var entity = Set<.>().Local.FirstOrDefault(x => x.Id == id) ?? Set<.>().FirstOrDefault(x => x.Id == id); if (entity is null) continue; if (!string.IsNullOrWhiteSpace(entity.Id) && !orphans.Any(o => o.Type == typeof(.) && o.Id == entity.Id)) orphans.Add((typeof(.), entity.Id!)); while (orphans.Count != countBefore); return orphans; private void DeleteOrphanedCompounds(List<(Type Type, string Id)> orphans) foreach (var (type, id) in orphans) if (type == typeof(.)) else if (type == typeof(.)) DeleteCompound(Set<.>(), x => x.Id == id); private static void CollectOrphan<TEntity>( EntityEntry<TEntity> entry, string propertyName, Type compoundType, List<(Type, string)> orphans) where TEntity : class var originalId = entry.OriginalValues[propertyName] as string; var currentId = entry.State == EntityState.Deleted ? null : entry.CurrentValues[propertyName] as string; if (!string.IsNullOrWhiteSpace(originalId) && originalId != currentId) orphans.Add((compoundType, originalId)); private void DeleteCompound<TEntity>( DbSet<TEntity> set, Expression<Func<TEntity, bool>> predicate) where TEntity : class var entity = set.Local.FirstOrDefault(predicate.Compile()) ?? set.FirstOrDefault(predicate); if (entity is not null) Remove(entity); private static void Configure(ModelBuilder modelBuilder) => modelBuilder.Entity(typeof()).ToTable(""); private static void Configure(ModelBuilder modelBuilder) var e = modelBuilder.Entity<>(); e.ToTable(""); e.HasOne(x => x.).WithMany().HasForeignKey(x => x.Id).OnDelete(DeleteBehavior.Restrict); ──────────────────────────────────────────────────────────────────────────────────────────────── Suppressed Fluent API: → [..*] The FK column for this [..*] association lives on , not here. HasOne/HasMany is intentionally not configured on this parent side because no shadow FK property exists on (see the suppressed collection navigation comment in the entity class above). Instead, configure from the child side: modelBuilder.Entity<>() .HasOne(x => x.) .WithMany() .HasForeignKey(x => x.Id) .OnDelete(DeleteBehavior.ClientNoAction); ──────────────────────────────────────────────────────────────────────────────────────────────── e.HasOne(x => x.).WithMany().HasForeignKey(x => x.Id).OnDelete(DeleteBehavior.ClientNoAction);