Net4x.DapperLibrary.Generic 1.9.9.7

DapperLibrary.Generic

# DapperLibrary.Generic

A small, provider-agnostic layer that adapts ADO.NET `DbProviderFactory` implementations into the DapperLibrary plumbing.

This project exposes a generic provider factory and a generic dapper context which can be used to integrate arbitrary ADO.NET providers (SQL Server, MySQL, Oracle, OLE DB, etc.) with the DapperLibrary model, parameter handling and data adapter event wiring.

## Main types

- `GenericProviderFactory<TFactory, TRowUpdatedEventArgs>`
  - Adapts a `DbProviderFactory` (`TFactory`) into the DapperLibrary `ProviderFactoryBase`.
  - Copies custom `DatabaseModel` settings into the library's `GenericDatabaseModel` and `GenericDatabaseModelTypes`.
  - Hooks adapter events (`RowUpdated`, `RowUpdating`) and forwards them to the DapperLibrary event model.
  - Configures the `ParameterModel` (prefix, indexing and parameter preparation delegate).

- `GenericDapperContext<TFactory, TRowUpdatedEventArgs>`
  - `DapperContext` subclass that uses `GenericProviderFactory<TFactory,TRowUpdatedEventArgs>`.
  - Constructors:
    - Older platform overload (NET35/NET40) accepts `(TFactory factory, DatabaseModel model)` and constructs the context using an internal `DapperConfigurationManager`.
    - Modern overload accepts `(IConfiguration configuration, TFactory factory, DatabaseModel model)`.

- `GenericDatabaseModel`, `GenericDatabaseModelTypes`, `GenericDatabaseEnumTypes`
  - Default implementations of `IDatabaseModel`, `IDatabaseModelTypes` and `IDatabaseEnumTypes` suitable for a wide range of relational databases.
  - Provide configurable delimiters, parameter naming, type mapping strings and helpers such as `FormatDatetimeAsString`.

## Quick usage example

1) Prepare a database model (customize what you need):

```csharp
var model = new DapperLibrary.Generic.DbContexts.GenericDatabaseModel();
model.BeginDelimiter = "\""; // or "[" for SQL Server
model.EndDelimiter = "\"";
model.ParameterPrefix = "@";
// adjust types if needed: model.Types.VarChar = "varchar({0})";
```

2) Create the provider factory instance for your provider and construct a context. Example for System.Data.SqlClient (desktop .NET):

```csharp
using System.Data.SqlClient;
using Microsoft.Extensions.Configuration;

var configuration = new ConfigurationBuilder().Build();
var factory = SqlClientFactory.Instance; // TFactory

using var context = new GenericDapperContext<SqlClientFactory, SqlRowUpdatedEventArgs>(configuration, factory, model);

// use context.Operations, context.Schema, context.SaveDataTable, etc.
```

## Notes and recommendations

- `GenericProviderFactory` wires up `DbDataAdapter` events via reflection so adapters that expose `RowUpdated`/`RowUpdating` will be handled. Ensure your provider's adapter exposes those events if you rely on them.
- The generic type parameter `TRowUpdatedEventArgs` must match the adapter's row event argument type for your provider (for example `SqlRowUpdatedEventArgs` for `System.Data.SqlClient`).
- The library sets `ParameterModel.PrepareCommandParameters` to a delegate; if your provider requires special parameter handling you can set `DatabaseModel.ParameterPrefix` and other `DatabaseModel` properties accordingly.
- For older runtimes (NET35/NET40) use the constructor that accepts the factory and `DatabaseModel` without `IConfiguration`.

## Integration

- `GenericDapperContext` is intended to be used where there isn't a provider-specific `DapperContext` implementation in the solution. For provider-specific features (SQLite in-memory semantics, SQL Server LocalDB helpers, etc.) prefer the corresponding provider project (see other READMEs in the repository).

## License / Contributing

See repository root for license and contribution guidelines.