Replace c# code with csharp (#360)

Author: vonzshik

conceptual/EF6.PG/index.md

@@ -144,7 +144,7 @@ Example use cases:
 - Preventing accidental insertion of DateTime values having ```DateTimeKind.Unspecified```.
 - Forcing all postgres date/time types to be returned to Entity Framework as ```DateTimeOffset```.
 
-```c#
+```csharp
 [DbConfigurationType(typeof(AppDbContextConfiguration))]
 public class AppDbContext : DbContext
 {

conceptual/EFCore.PG/index.md

@@ -31,7 +31,7 @@ Below is a `.csproj` file for a console application that uses the Npgsql EF Core
 
 Let's say you want to store blogs and their posts in their database; you can model these as .NET types as follows:
 
-```c#
+```csharp
 public class Blog
 {
     public int BlogId { get; set; }
@@ -57,7 +57,7 @@ You then define a `DbContext` type which you'll use to interact with the databas
 
 Using `OnConfiguring()` to configure your context is the easiest way to get started, but is discouraged for most production applications:
 
-```c#
+```csharp
 public class BloggingContext : DbContext
 {
     public DbSet<Blog> Blogs { get; set; }
@@ -74,7 +74,7 @@ using var context = new BloggingContext();
 
 ### [DbContext pooling](#tab/context-pooling)
 
-```c#
+```csharp
 var dbContextFactory = new PooledDbContextFactory<BloggingContext>(
     new DbContextOptionsBuilder<BloggingContext>()
         .UseNpgsql("<connection string>")
@@ -89,7 +89,7 @@ using var context = dbContextFactory.CreateDbContext();
 
 When using ASP.NET - or any application with dependency injection - the context instance will be injected into your code. Use the following to configure EF with your DI container:
 
-```c#
+```csharp
 var builder = WebApplication.CreateBuilder(args);
 
 builder.Services.AddDbContextPool<BloggingContext>(opt => 
@@ -112,7 +112,7 @@ The Npgsql EF provider is built on top of the lower-level Npgsql ADO.NET provide
 
 If you're using EF 9.0 or above, the `UseNpgsql()` is a single point where you can configure everything related to Npgsql. For example:
 
-```c#
+```csharp
 builder.Services.AddDbContextPool<BloggingContext>(opt =>
     opt.UseNpgsql(
         builder.Configuration.GetConnectionString("BloggingContext"),
@@ -126,7 +126,7 @@ The above configures the EF provider to produce SQL for PostgreSQL version 13 (a
 
 If you need to configure something at the lower-level ADO.NET layer, use `ConfigureDataSource()` as follows:
 
-```c#
+```csharp
 builder.Services.AddDbContextPool<BloggingContext>(opt =>
     opt.UseNpgsql(
         builder.Configuration.GetConnectionString("BloggingContext"),
@@ -145,7 +145,7 @@ builder.Services.AddDbContextPool<BloggingContext>(opt =>
 
 If you're using a version of EF prior to 9.0, the above configuration methods aren't available. You can still create an `NpgsqlDataSource` yourself, and then pass it EF's `UseNpgsql()`:
 
-```c#
+```csharp
 var dataSourceBuilder = new NpgsqlDataSourceBuilder(builder.Configuration.GetConnectionString("BloggingContext"));
 dataSourceBuilder.MapEnum<Mood>();
 dataSourceBuilder.UseNodaTime();

conceptual/EFCore.PG/mapping/array.md

@@ -9,7 +9,7 @@ PostgreSQL has the unique feature of supporting [*array data types*](https://www
 
 Simply define a regular .NET array or `List<>` property:
 
-```c#
+```csharp
 public class Post
 {
     public int Id { get; set; }

conceptual/EFCore.PG/mapping/enum.md

@@ -15,7 +15,7 @@ If you're using EF 9.0 or above, simply call `MapEnum` inside your `UseNpgsql` i
 
 If you're passing a connection string to `UseNpgsql`, simply add the `MapEnum` call as follows:
 
-```c#
+```csharp
 builder.Services.AddDbContext<MyContext>(options => options.UseNpgsql(
     "<connection string>",
     o => o.MapEnum<Mood>("mood")));
@@ -27,7 +27,7 @@ This configures all aspects of Npgsql to use your `Mood` enum - both at the EF a
 
 If you're creating an external NpgsqlDataSource and passing it to `UseNpgsql`, you must make sure to map your enum on that data independently of the EF-level setup:
 
-```c#
+```csharp
 var dataSourceBuilder = new NpgsqlDataSourceBuilder("<connection string>");
 dataSourceBuilder.MapEnum<Mood>();
 var dataSource = dataSourceBuilder.Build();
@@ -47,7 +47,7 @@ On versions of EF prior to 9.0, enum setup is more involved and consists of seve
 
 First, you must specify the PostgreSQL enum type on your model, just like you would with tables, sequences or other databases objects:
 
-```c#
+```csharp
 protected override void OnModelCreating(ModelBuilder builder)
     => builder.HasPostgresEnum<Mood>();
 ```
@@ -62,7 +62,7 @@ Even if your database enum is created, Npgsql has to know about it, and especial
 
 Since version 7.0, NpgsqlDataSource is the recommended way to use Npgsql. When using NpgsqlDataSource, map your enum when building your data source:
 
-```c#
+```csharp
 // Call MapEnum() when building your data source:
 var dataSourceBuilder = new NpgsqlDataSourceBuilder(/* connection string */);
 dataSourceBuilder.MapEnum<Mood>();
@@ -75,7 +75,7 @@ builder.Services.AddDbContext<MyContext>(options => options.UseNpgsql(dataSource
 
 Since version 7.0, NpgsqlDataSource is the recommended way to use Npgsql. However, if you're not yet using NpgsqlDataSource, map enums by adding the following code, *before* any EF Core operations take place. An appropriate place for this is in the static constructor on your DbContext class:
 
-```c#
+```csharp
 static MyDbContext()
     => NpgsqlConnection.GlobalTypeMapper.MapEnum<Mood>();
 ```
@@ -91,7 +91,7 @@ This code lets Npgsql know that your CLR enum type, `Mood`, should be mapped to
 
 Once your enum is properly set up with EF, you can use your CLR enum type just like any other property:
 
-```c#
+```csharp
 public class Blog
 {
     public int Id { get; set; }
@@ -113,7 +113,7 @@ using (var ctx = new MyDbContext())
 
 The Npgsql provider only allow adding new values to existing enums, and the appropriate migrations will be automatically created as you add values to your CLR enum type. However, PostgreSQL itself doesn't support removing enum values (since these may be in use), and while renaming values is supported, it isn't automatically done by the provider to avoid using unreliable detection heuristics. Renaming an enum value can be done by including [raw SQL](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/managing?tabs=dotnet-core-cli#arbitrary-changes-via-raw-sql) in your migrations as follows:
 
-```c#
+```csharp
 migrationBuilder.Sql("ALTER TYPE mood RENAME VALUE 'happy' TO 'thrilled';");
 ```
 

conceptual/EFCore.PG/mapping/full-text-search.md

@@ -6,7 +6,7 @@ PostgreSQL has [built-in support for full-text search](https://www.postgresql.or
 
 PostgreSQL full text search types are mapped onto .NET types built-in to Npgsql. The `tsvector` type is mapped to `NpgsqlTsVector` and `tsquery` is mapped to `NpgsqlTsQuery`. This means you can use properties of type `NpgsqlTsVector` directly in your model to create `tsvector` columns. The `NpgsqlTsQuery` type on the other hand, is used in LINQ queries.
 
-```c#
+```csharp
 public class Product
 {
     public int Id { get; set; }
@@ -24,7 +24,7 @@ public class Product
 
 This method adds a `tsvector` column to your table, that is automatically updated when the row is modified. First, add an `NpgsqlTsVector` property to your entity:
 
-```c#
+```csharp
 public class Product
 {
     public int Id { get; set; }
@@ -43,7 +43,7 @@ Setting up the column to be auto-updated depends on your PostgreSQL version. On
 
 The following will set up a generated `tsvector` column, over which you can easily create an index:
 
-```c#
+```csharp
 protected override void OnModelCreating(ModelBuilder modelBuilder)
 {
     modelBuilder.Entity<Product>()
@@ -60,7 +60,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 
 First, modify the `OnModelCreating()` of your context class to add an index as follows:
 
-```c#
+```csharp
 protected override void OnModelCreating(ModelBuilder modelBuilder)
 {
     modelBuilder.Entity<Product>()
@@ -71,7 +71,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 
 Now generate a migration (`dotnet ef migrations add ....`), and open it with your favorite editor, adding the following:
 
-```c#
+```csharp
 public partial class CreateProductTable : Migration
 {
     protected override void Up(MigrationBuilder migrationBuilder)
@@ -99,7 +99,7 @@ public partial class CreateProductTable : Migration
 
 Once your auto-updated `tsvector` column is set up, any inserts or updates on the `Products` table will now update the `SearchVector` column and maintain it automatically. You can query it as follows:
 
-```c#
+```csharp
 var context = new ProductDbContext();
 var npgsql = context.Products
     .Where(p => p.SearchVector.Matches("Npgsql"))
@@ -112,7 +112,7 @@ Version 5.0.0 of the provider includes sugar for defining the appropriate expres
 
 #### [Version 5.0.0](#tab/v5)
 
-```c#
+```csharp
 modelBuilder.Entity<Blog>()
     .HasIndex(b => new { b.Title, b.Description })
     .HasMethod("GIN")
@@ -123,7 +123,7 @@ modelBuilder.Entity<Blog>()
 
 Create a migration which will contain the index creation SQL (`dotnet ef migrations add ...`). At this point, open the generated migration with your editor and add the following:
 
-```c#
+```csharp
 protected override void Up(MigrationBuilder migrationBuilder)
 {
     migrationBuilder.Sql(@"CREATE INDEX fts_idx ON ""Product"" USING GIN (to_tsvector('english', ""Name"" || ' ' || ""Description""));");
@@ -138,7 +138,7 @@ protected override void Down(MigrationBuilder migrationBuilder)
 
 Once the index is created on the `Title` and `Description` columns, you can query as follows:
 
-```c#
+```csharp
 var context = new ProductDbContext();
 var npgsql = context.Products
     .Where(p => EF.Functions.ToTsVector("english", p.Title + " " + p.Description)

conceptual/EFCore.PG/mapping/general.md

@@ -4,7 +4,7 @@ The EF Core provider transparently maps the types supported by Npgsql at the ADO
 
 This means that you can use PostgreSQL-specific types, such as `inet` or `circle`, directly in your entities. Simply define your properties just as if they were a simple type, such as a `string`:
 
-```c#
+```csharp
 public class MyEntity
 {
     public int Id { get; set; }
@@ -25,14 +25,14 @@ In some cases, your .NET property type can be mapped to several PostgreSQL data
 
 ## [Data Annotations](#tab/data-annotations)
 
-```c#
+```csharp
 [Column(TypeName="jsonb")]
 public string SomeStringProperty { get; set; }
 ```
 
 ## [Fluent API](#tab/fluent-api)
 
-```c#
+```csharp
 builder.Entity<Blog>()
        .Property(b => b.SomeStringProperty)
        .HasColumnType("jsonb");

conceptual/EFCore.PG/mapping/json.md

@@ -18,7 +18,7 @@ The simplest form of mapping to JSON is via a regular string property, just like
 
 ### [Data Annotations](#tab/data-annotations)
 
-```c#
+```csharp
 public class SomeEntity
 {
     public int Id { get; set; }
@@ -29,7 +29,7 @@ public class SomeEntity
 
 ### [Fluent API](#tab/fluent-api)
 
-```c#
+```csharp
 class MyContext : DbContext
 {
     public DbSet<SomeEntity> SomeEntities { get; set; }
@@ -67,7 +67,7 @@ Npgsql's support for `ToJson()` is fully aligned with the general EF support; se
 
 To get you started quickly, assume that we have the following Customer type, with a Details property that we want to map to a single JSON column in the database:
 
-```c#
+```csharp
 public class Customer
 {
     public int Id { get; set; }
@@ -90,7 +90,7 @@ public class Order       // Part of the JSON column
 
 To instruct EF to map CustomerDetails - and within it, Order - to a JSON column, configure it as follows:
 
-```c#
+```csharp
 protected override void OnModelCreating(ModelBuilder modelBuilder)
 {
     modelBuilder.Entity<Customer>()
@@ -112,7 +112,7 @@ To use traditional POCO mapping, configure a property a mapping to map to a `jso
 
 ### [Data Annotations](#tab/data-annotations)
 
-```c#
+```csharp
 public class Customer
 {
     public int Id { get; set; }
@@ -136,7 +136,7 @@ public class Order       // Part of the JSON column
 
 ### [Fluent API](#tab/fluent-api)
 
-```c#
+```csharp
 class MyContext : DbContext
 {
     public DbSet<SomeEntity> SomeEntities { get; set; }
@@ -178,7 +178,7 @@ Note that when using this mapping, only limited forms of LINQ querying is suppor
 
 If your column JSON schema isn't stable, a strongly-typed POCO mapping may not be appropriate. The Npgsql provider also allows you to map the DOM document type provided by [System.Text.Json APIs](https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-apis/).
 
-```c#
+```csharp
 public class SomeEntity : IDisposable
 {
     public int Id { get; set; }
@@ -192,7 +192,7 @@ Note that neither a data annotation nor the fluent API are required, as [JsonDoc
 
 Once a document is loaded from the database, you can traverse it:
 
-```c#
+```csharp
 var someEntity = context.Entities.First();
 Console.WriteLine(someEntity.Customer.RootElement.GetProperty("Orders")[0].GetProperty("Price").GetInt32());
 ```
@@ -208,15 +208,15 @@ Saving and loading documents these documents wouldn't be much use without the ab
 
 ### [Classic POCO Mapping](#tab/poco)
 
-```c#
+```csharp
 var joes = context.CustomerEntries
     .Where(e => e.Customer.Name == "Joe")
     .ToList();
 ```
 
 ### [JsonDocument Mapping](#tab/jsondocument)
 
-```c#
+```csharp
 var joes = context.CustomerEntries
     .Where(e => e.Customer.RootElement.GetProperty("Name").GetString() == "Joe")
     .ToList();

conceptual/EFCore.PG/mapping/nodatime.md

@@ -18,7 +18,7 @@ To set up the NodaTime plugin, add the [Npgsql.EntityFrameworkCore.PostgreSQL.No
 
 If you're passing a connection string to `UseNpgsql`, simply add the `UseNodaTime` call as follows:
 
-```c#
+```csharp
 builder.Services.AddDbContext<MyContext>(options => options.UseNpgsql(
     "<connection string>",
     o => o.UseNodaTime()));
@@ -30,7 +30,7 @@ This configures all aspects of Npgsql to use the NodaTime plugin - both at the E
 
 If you're creating an external NpgsqlDataSource and passing it to `UseNpgsql`, you must call `UseNodaTime` on your NpgsqlDataSourceBuilder independently of the EF-level setup:
 
-```c#
+```csharp
 var dataSourceBuilder = new NpgsqlDataSourceBuilder("<connection string>");
 dataSourceBuilder.UseNodaTime();
 var dataSource = dataSourceBuilder.Build();
@@ -42,7 +42,7 @@ builder.Services.AddDbContext<MyContext>(options => options.UseNpgsql(
 
 ### [Older EF versions, with a connection string](#tab/legacy-with-connection-string)
 
-```c#
+```csharp
 // Configure UseNodaTime at the ADO.NET level.
 // This code must be placed at the beginning of your application, before any other Npgsql API is called; an appropriate place for this is in the static constructor on your DbContext class:
 static MyDbContext()
@@ -57,7 +57,7 @@ builder.Services.AddDbContext<MyContext>(options =>
 
 The above sets up all the necessary mappings and operation translators. You can now use NodaTime types as regular properties in your entities, and even perform some operations:
 
-```c#
+```csharp
 public class Post
 {
     public int Id { get; set; }
@@ -72,7 +72,7 @@ var recentPosts = context.Posts.Where(p => p.CreationTime > someInstant);
 
 The provider knows how to translate many members and methods on mapped NodaTime types. For example, the following query will be translated to SQL and evaluated server-side:
 
-```c#
+```csharp
 // Get all events which occurred on a Monday
 var mondayEvents = context.Events.Where(p => p.SomeDate.DayOfWeek == DayOfWeek.Monday);