Todor efcore snippets (#2176)

* move snippets to code base

* minor region fix

Author: todorarabadzhiev

designing-reports/connecting-to-data/data-source-components/entitycoredatasource-component/configuring-the-database-connectivity-with-the-entitycoredatasource-component.md

@@ -20,46 +20,16 @@ A typical EF Core `DbContext` reads its connection string from `appsettings.json
 
 To overcome this, the `EntityCoreDataSource` component exposes a `ConnectionString` property. When configuring the data source in the Web Report Designer or the Standalone Report Designer, the wizard prompts for the connection string and stores it in the report definition. At processing time, the component forwards the value to the `DbContext` constructor that accepts a `string` argument at processing time. The `DbContext` must therefore expose such a constructor, as shown in the following Code First sample:
 
-```CSharp
-public class AppDbContext : DbContext
-{
-    public AppDbContext()
-    {
-    }
-
-    public AppDbContext(string connectionString)
-        : base(BuildOptions(connectionString))
-    {
-    }
-
-    private static DbContextOptions<AppDbContext> BuildOptions(string connectionString)
-    {
-        return new DbContextOptionsBuilder<AppDbContext>()
-            .UseSqlServer(connectionString)
-            .Options;
-    }
-}
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=CodeFirstAppDbContext}}
+
 
 ## Setting the ConnectionString Property
 
 To set the connection string in code, use either the property setter or the three-argument constructor:
 
-```CSharp
-var dataSource = new Telerik.Reporting.EntityCoreDataSource
-{
-    Context = typeof(AppDbContext),
-    ContextMember = "People",
-    ConnectionString = "Server=.;Database=MSSQLLocalDB;Integrated Security=True;TrustServerCertificate=True"
-};
-```
-
-```CSharp
-var dataSource = new Telerik.Reporting.EntityCoreDataSource(
-    "Server=.;Database=MSSQLLocalDB;Integrated Security=True;TrustServerCertificate=True",
-    typeof(AppDbContext),
-    "People");
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreConnectionStringThreeArgConstructor_0}}
+
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreConnectionStringThreeArgConstructor_1}}
 
 The wizard stores the value as an attribute on the `EntityCoreDataSource` element of the `.trdp` or `.trdx` definition. To centralize the value and avoid embedding credentials in the file, use a named connection instead. Store it in the configuration file of the report-hosting process and read it at startup before assigning it to the `ConnectionString` property.
 

designing-reports/connecting-to-data/data-source-components/entitycoredatasource-component/connecting-to-a-dbcontext-with-the-entitycoredatasource-component.md

@@ -38,22 +38,11 @@ public EntityCoreDataSource(string connectionString, object context, string cont
 
 To create the simplest configuration, use the parameterless constructor and set the `Context` and `ContextMember` properties. Set `Context` to the `DbContext` type and `ContextMember` to the name of the `DbSet<T>`, queryable property, or method that retrieves the data:
 
-```CSharp
-var dataSource = new Telerik.Reporting.EntityCoreDataSource
-{
-    Context = typeof(AppDbContext),
-    ContextMember = "People"
-};
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreConnectionStringTwoArgConstructor_0}}
 
 Use the three-argument constructor when you need to set the connection string, context type, and context member in a single call:
 
-```CSharp
-var dataSource = new Telerik.Reporting.EntityCoreDataSource(
-	"Server=.;Database=MSSQLLocalDB;Integrated Security=True;TrustServerCertificate=True",
-	typeof(AppDbContext),
-	"People");
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreConnectionStringThreeArgConstructor_1}}
 
 ## Binding to a DbContext Type Versus an Instance
 
@@ -62,17 +51,7 @@ The `Context` property is typed as `object` and accepts either a `Type` referenc
 - When you supply a **type**, the component instantiates the `DbContext`, holds it for the duration of report processing, and disposes it automatically. This is the recommended pattern because it preserves [lazy loading](slug:entitycoredatasource-context-lifecycle) throughout report processing.
 - When you supply an **instance**, the application owns the lifetime of the context. The component does not call `Dispose` on the supplied instance.
 
-```CSharp
-var context = new AppDbContext(connectionString);
-
-var dataSource = new Telerik.Reporting.EntityCoreDataSource
-{
-    Context = context,
-    ContextMember = "People"
-};
-
-// You have to dispose of the context manually after rendering the report.
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreConnectionStringTwoArgConstructor_1}}
 
 ## Code First Versus Database First
 

designing-reports/connecting-to-data/data-source-components/entitycoredatasource-component/maintaining-the-lifecycle-of-the-context-with-the-entitycoredatasource-component.md

@@ -30,31 +30,13 @@ When you assign a `Type` to the `Context` property (or pass one to the construct
 1. The instance is held for the duration of report processing so that lazy-loaded navigation properties remain available.
 1. The component disposes the instance when rendering completes.
 
-```CSharp
-var dataSource = new Telerik.Reporting.EntityCoreDataSource
-{
-	Context = typeof(AppDbContext),
-	ContextMember = "People"
-};
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreConnectionStringTwoArgConstructor_0}}
 
 ## Supplying Your Own Instance
 
 When you assign a live `DbContext` instance to the `Context` property, the application is responsible for disposing it. The component does not call `Dispose` on a context it did not create. Use this pattern when the context is wired into your application's dependency-injection container and must follow the container's scope.
 
-```CSharp
-var context = serviceProvider.GetRequiredService<AppDbContext>();
-
-var dataSource = new Telerik.Reporting.EntityCoreDataSource
-{
-	Context = context,
-	ContextMember = "People"
-};
-
-// Use the data source while the context is alive, then dispose
-// the context explicitly when you no longer need the report:
-context.Dispose();
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreConnectionStringTwoArgConstructor_2}}
 
 > warning Disposing the supplied `DbContext` before the report engine finishes processing the report breaks lazy loading and causes runtime exceptions. Coordinate the dispose call with the end of the report-processing pipeline.
 

designing-reports/connecting-to-data/data-source-components/entitycoredatasource-component/overview.md

@@ -69,56 +69,11 @@ The following snippets show the minimal `DbContext` shape that the component can
 
 * Code First scenario:
 
-	```CSharp
-	public class AppDbContext : DbContext
-	{
-		public AppDbContext()
-		{
-		}
-
-		public AppDbContext(string connectionString)
-			: base(BuildOptions(connectionString))
-		{
-		}
-		
-		public DbSet<Person> People => Set<Person>();
-
-		private static DbContextOptions<AppDbContext> BuildOptions(string connectionString)
-		{
-			return new DbContextOptionsBuilder<AppDbContext>()
-				.UseSqlServer(connectionString)
-				.Options;
-		}
-	}
-	```
+	{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContextCodeFirst.cs region=CodeFirstAppDbContext}}
 
 * Database First scenario:
 
-	```CSharp
-	public class AppDbContext : DbContext
-	{
-		public AppDbContext()
-		{
-		}
-
-		public AppDbContext(DbContextOptions<AppDbContext> options)
-			: base(options)
-		{
-		}
-
-		public DbSet<Person> People => Set<Person>();
-
-		protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-		{
-			if (!optionsBuilder.IsConfigured)
-			{
-				// Replace the literal below with your own connection string or
-				// resolve it from configuration before calling UseSqlServer.
-				optionsBuilder.UseSqlServer("<your connection string>");
-			}
-		}
-	}
-	```
+	{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContextDbFirst.cs region=DbFirstAppDbContext}}
 
 
 ## Supported Developer Platforms

designing-reports/connecting-to-data/data-source-components/entitycoredatasource-component/using-parameters-with-the-entitycoredatasource-component.md

@@ -20,35 +20,17 @@ This article explains how to pass values from [Report Parameters](slug:telerikre
 
 Add a method or queryable property on the `DbContext` that accepts the values you need to filter by. The names and types of the data source parameters must match the names and types of the corresponding method arguments exactly; otherwise the component throws an exception at runtime.
 
-```CSharp
-public partial class AppDbContext : DbContext
-{
-    public IQueryable<Person> QueryPeopleWithSalaryAbove(decimal threshold)
-    {
-        return this.Persons.Where(p => p.Salary > threshold);
-    }
-}
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContextParameters.cs region=AppDbContextParameters}}
 
 ## Mapping Report Parameters to the Data Source
 
 Set the `ContextMember` property to the method name and add one entry to the `Parameters` collection of the data source for every method argument. The `Parameters` collection is inherited through `ObjectDataSourceBase` and exposes the same fluent overload used by every Telerik Reporting data source: `Add(name, type, valueOrExpression)`. Bind to a [Report Parameter](slug:telerikreporting/designing-reports/connecting-to-data/report-parameters/overview) by setting the value to an expression such as `=Parameters.threshold.Value`:
 
-```CSharp
-var dataSource = new Telerik.Reporting.EntityCoreDataSource
-{
-    Context = typeof(AppDbContext),
-    ContextMember = "QueryPeopleWithSalaryAbove"
-};
-
-dataSource.Parameters.Add("threshold", typeof(decimal), "= Parameters.threshold.Value");
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreConnectionStringTwoArgConstructor_3}}
 
 You can also pass literal values when the data source must execute with a fixed argument:
 
-```CSharp
-dataSource.Parameters.Add("threshold", typeof(decimal), 60000);
-```
+{{source=CodeSnippets\Blazor\Docs\DataSources\AppDbContext.cs region=EFCoreFixedParameter}}
 
 ## Pushing Filtering to the Server
 

designing-reports/report-designer-tools/web-report-designer/tools/entitycoredatasource-wizard.md

@@ -25,15 +25,7 @@ When started, the application that hosts the Web Report Designer will try to res
 
 	The default .NET application's configuration is the `appsettings.json` file:
 
-	```JSON
-	"telerikReporting": {
-		"assemblyReferences": [
-			{
-				"name": "EFCoreExample"
-			}
-		]
-	}
-	```
+	{{source=CodeSnippets\Blazor\Docs\DataSources\efcore_appsettings.json region=RegisterEFCoreExample}}
 
 	Another option is a custom implementation of the [IConfiguration](https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.configuration.iconfiguration) interface.