Introduction

.NET is the foundation of enterprise application development across industries. Whether you define database schemas with Entity Framework Core, orchestrate data pipelines in C#, or interact with operational databases through ADO.NET, .NET applications are often the upstream source of truth for the data that powers your analytics stack.

Because .NET applications are strongly typed and model-driven, tracing exactly which columns are read, written, and transformed across .NET services requires deep static analysis. When data moves from a .NET-managed operational database through an ETL pipeline into a data warehouse and then into BI dashboards, traditional runtime observability tools lose visibility — turning your .NET data flows into a black box.

Foundational connects to your existing repositories and reads your .NET code directly. It builds column-level lineage from the code itself, without requiring a running database or any changes to your application.

Why this framework matters in your data stack

.NET applications can sit anywhere in your data stack: as the operational source that feeds ETL tools, as microservices that write to data lakes, or as batch jobs that populate warehouse tables. .NET-managed schemas are the starting point for a chain of downstream dependencies.

When an upstream change occurs — such as a renamed property in an Entity Framework model or a removed column in a query — it can silently break downstream transformations, dashboards, and machine-learning pipelines. Data teams need a way to predict the downstream impact of these schema changes before they deploy.

Foundational CI, powered by comprehensive end-to-end lineage, thoroughly checks every pending Pull Request to ensure it doesn't disrupt downstream transformations, dashboards, ML models, and more.

How Foundational analyzes this framework

Foundational's code engine scans and extracts lineage straight from the .NET source code. Data teams gain full visibility into any .NET data flow, including legacy applications and custom ADO.NET code that does not rely on a modern ORM framework.

This shift-left approach makes it possible to review data flow changes in pending Pull Requests, ensuring that any changes impacting your data stack do not lead to data incidents, pipeline disruptions, or compromises in data quality.

Foundational supports a wide range of .NET data frameworks, including:

Entity Framework Core — model classes annotated with data annotations or configured via the Fluent API, analyzed to extract table names, column names, and relationships
LINQ queries — query expressions that map C# objects to database columns via EF Core or LINQ to SQL, traced to determine which columns are read and how they flow downstream
Dapper — lightweight ORM queries that map SQL results to C# objects, analyzed for column-level read and write operations
ADO.NET — raw SQL strings executed via SqlCommand and SqlDataReader, analyzed for column-level read and write operations
Other .NET data access libraries — including NHibernate, ServiceStack OrmLite, and custom data access patterns built on top of standard .NET database drivers

Multi-step extraction process

Foundational uses a multi-step process to track data:

Identify relevant files: Foundational scans accessible repositories to locate .NET files that define database schemas and data access logic. It uses heuristics to detect Entity Framework Core model classes, DbContext configurations, Dapper query methods, and raw SQL strings in ADO.NET code. For example:

public class Order
{
    [Key]
    public int Id { get; set; }    [Column("customer_id")]
    public int CustomerId { get; set; }    [Column("total_amount")]
    public decimal TotalAmount { get; set; }    [Column("status")]
    public string Status { get; set; }
}public class AppDbContext : DbContext
{
    public DbSet<Order> Orders { get; set; }
}

Parse model definitions and extract schema: Foundational parses C# source files using static analysis. It reads data annotation attributes and Fluent API configurations to extract table names, column names and types, primary and foreign key relationships, and navigation property structures. When column names are not declared explicitly, Foundational applies Entity Framework's default conventions — for example, mapping property names directly to column names.
Analyze SQL and data flow: For Dapper and ADO.NET, Foundational extracts lineage by analyzing SQL strings in query methods and command objects. It identifies which columns are read (SELECT), written (INSERT, UPDATE), and used for filtering or ordering. For example, this ADO.NET snippet:
```
string sql = "INSERT INTO reporting.order_summary (customer_id, total_amount) "
           + "SELECT customer_id, SUM(total_amount) "
           + "FROM orders "
           + "GROUP BY customer_id";using var cmd = new SqlCommand(sql, connection);
cmd.ExecuteNonQuery();
```
Produces the following column-level lineage:
orders.customer_id → reporting.order_summary.customer_id
orders.total_amount → reporting.order_summary.total_amount
Graph construction and linking: Because a single .NET service rarely contains full schema context, Foundational merges code analysis results with schema definitions found elsewhere in your repositories or data systems. It resolves cross-project dependencies, handles wildcard references using known schema context, and assembles the complete column-level lineage graph — tracing data from the .NET-managed operational database through the warehouse, into transformations, and out to BI tools and downstream consumers.

Advantages of Foundational's approach

Foundational provides data teams with:

Early visibility: Shows how .NET schema changes impact data flows during development, seamlessly integrated into your source control — GitHub, GitLab, Azure Repos, Bitbucket, and more.
Shift-left impact analysis: Detects breaking changes in open Pull Requests before they reach production, so downstream consumers can prepare in advance.
Broad .NET framework coverage: Supports Entity Framework Core, LINQ queries, Dapper, ADO.NET, and more — including embedded SQL and legacy code that runtime tools miss entirely.
Reduced breakages: Prevents dashboards, ML features, transformation pipelines, and reverse ETL syncs from breaking due to upstream .NET schema changes.

Set up .NET lineage in Foundational

Setup is seamless.

Connect the repositories that contain your .NET application code. There is no need to manually annotate code, add instrumentation, or modify your application.
From there, the code engine automatically identifies .NET data access patterns across supported frameworks, extracts schema and lineage, detects changes in Pull Requests, and evaluates downstream impact.

Useful links

Extracting Lineage from Doctrine (ORM for PHP)

Extracting Lineage from Entity Framework Core (Native C# ORM)

Extracting Lineage from Python

Extracting Lineage from Java

Extracting Lineage from Scala

Extracting Lineage from .NET