NuGet Gallery Feed for Dapper.FastCrudYou hate verbatim SQL queries with zero type safety for your code but you love the speed?
Dapper.FastCRUD is built around essential features of the C# 6 / VB that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
Visual Studio 2019 or later is recommended.https://www.nuget.org/packages/Dapper.FastCrud/2023-03-09T14:44:30Zhttps://api.nuget.org/v3-flatcontainer/dapper.fastcrud/3.1.46/iconhttps://www.nuget.org/packages/Dapper.FastCrud/3.1.46Dapper.FastCrud 3.1.462023-03-09T14:42:27Z2023-03-09T14:44:30ZMoonStormhttps://www.nuget.org/profiles/MoonStormYou hate verbatim SQL queries with zero type safety for your code but you love the speed?
Dapper.FastCRUD is built around essential features of the C# 6 / VB that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
Visual Studio 2019 or later is recommended.https://www.nuget.org/packages/Dapper.FastCrud/3.0.46Dapper.FastCrud 3.0.462022-03-02T15:40:01Z2022-03-02T15:42:04ZMoonStormhttps://www.nuget.org/profiles/MoonStormYou hate verbatim SQL queries with zero type safety for your code but you love the speed?
Dapper.FastCRUD is built around essential features of the C# 6 / VB that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
Visual Studio 2019 or later is recommended.https://www.nuget.org/packages/Dapper.FastCrud/3.0.45Dapper.FastCrud 3.0.452022-02-22T02:35:50Z2022-02-22T02:37:53ZMoonStormhttps://www.nuget.org/profiles/MoonStormYou hate verbatim SQL queries with zero type safety for your code but you love the speed?
Dapper.FastCRUD is built around essential features of the C# 6 / VB that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
Visual Studio 2019 or later is recommended.https://www.nuget.org/packages/Dapper.FastCrud/2.6.7Dapper.FastCrud 2.6.72022-01-18T21:50:21Z2022-01-18T21:52:22ZMoonStormhttps://www.nuget.org/profiles/MoonStormDapper.FastCRUD is built around essential features of the C# 6 / VB that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels. These features leave no chance to mistypings or problems arising from db entity refactorings. Visual Studio 2015 or later is recommended.https://www.nuget.org/packages/Dapper.FastCrud/2.5.0.39Dapper.FastCrud 2.5.0.392018-04-19T15:38:19Z2018-11-07T13:29:03ZMoonStormhttps://www.nuget.org/profiles/MoonStormDapper.FastCrud is built around essential features of the C# 6 / VB that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels. These features leave no chance to mistypings or problems arising from db entity refactorings. Visual Studio 2015 or later is recommended.https://www.nuget.org/packages/Dapper.FastCrud/2.4.1Dapper.FastCrud 2.4.12016-10-27T02:14:24Z2018-11-07T13:29:14ZMoonStormhttps://www.nuget.org/profiles/MoonStormThe fastest micro-orm extension for Dapper is built around essential features of the C# 6 / VB 14 that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
It is mandatory to use VS2015 or an equivalent build environment.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql.
- Composite primary keys are supported.
- Compatible with component model data annotations.
- Opt-in relationships.
- Multiple entity mappings are supported, useful for partial queries in large denormalized tables and data migrations between different database types.
- All the CRUD methods accept a transaction, a command timeout, and a custom entity mapping.
- Fast pre-computed entity queries.
- A useful SQL builder and statement formatter which can be used even if you don't need the CRUD features of this library.
- A generic T4 template for C# is also provided for convenience in the NuGet package Dapper.FastCrud.ModelGenerator.
Code first entities are also supported which can either be decorated with attributes, have their mappings programmatically set, or using your own custom convention.
Check out the project site for release notes, usage and benchmarks..https://www.nuget.org/packages/Dapper.FastCrud/2.4.0Dapper.FastCrud 2.4.02016-09-21T17:36:24Z2018-11-07T13:29:25ZMoonStormhttps://www.nuget.org/profiles/MoonStormThe fastest micro-orm extension for Dapper is built around essential features of the C# 6 / VB 14 that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
It is mandatory to use VS2015 or an equivalent build environment.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql.
- Composite primary keys are supported.
- Compatible with component model data annotations.
- Opt-in relationships.
- Multiple entity mappings are supported, useful for partial queries in large denormalized tables and data migrations between different database types.
- All the CRUD methods accept a transaction, a command timeout, and a custom entity mapping.
- Fast pre-computed entity queries.
- A useful SQL builder and statement formatter which can be used even if you don't need the CRUD features of this library.
- A generic T4 template for C# is also provided for convenience in the NuGet package Dapper.FastCrud.ModelGenerator.
Code first entities are also supported which can either be decorated with attributes, have their mappings programmatically set, or using your own custom convention.
Check out the project site for release notes, usage and benchmarks..https://www.nuget.org/packages/Dapper.FastCrud/2.3.2Dapper.FastCrud 2.3.22016-02-09T16:13:20Z2018-11-07T13:31:29ZMoonStormhttps://www.nuget.org/profiles/MoonStormThe fastest micro-orm type extension for Dapper is built around essential features of the C# 6 /VB 14 that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
There is no need to target .NET 4.6, but it is mandatory to use VS2015 or an equivalent build environment.
For .NET 4.5, the package will also install the dependency 'StringInterpolationBridge', which contains the polyfills required when using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql.
- Composite primary keys are supported.
- Compatible with most EF data annotations.
- Multiple entity mappings are supported, useful for partial queries in large denormalized tables and data migrations between different database types.
- All the CRUD methods accept a transaction, a command timeout, and a custom entity mapping.
- Fast pre-computed entity queries.
- A useful SQL builder and statement formatter which can be used even if you don't need the CRUD features of this library.
- A generic T4 template for C# is also provided for convenience in the NuGet package Dapper.FastCrud.ModelGenerator.
Code first entities are also supported which can either be decorated with attributes, have their mappings programmatically set, or using your own custom convention.
Check out the project site for release notes, usage and benchmarks.https://www.nuget.org/packages/Dapper.FastCrud/2.3.0Dapper.FastCrud 2.3.02016-01-02T07:53:42Z2018-11-07T13:32:24ZMoonStormhttps://www.nuget.org/profiles/MoonStormThe fastest micro-orm type extension for Dapper is built around essential features of the C# 6 /VB 14 that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
There is no need to target .NET 4.6, but it is mandatory to use VS2015 or an equivalent build environment.
For .NET 4.5, the package will also install the dependency 'StringInterpolationBridge', which contains the polyfills required when using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql
- Composite primary keys are supported
- Multiple entity mappings are supported, useful for partial queries in large denormalized tables and data migrations between different database types.
- All the CRUD methods accept a transaction, a command timeout, and a custom entity mapping.
- Fast pre-computed entity queries
- A useful SQL builder and statement formatter which can be used even if you don't need the CRUD features of this library.
- A generic T4 template for C# is also provided for convenience in the NuGet package Dapper.FastCrud.ModelGenerator.
Code first entities are also supported which can either be decorated with attributes, have their mappings programmatically set, or using your own custom convention.
Please check the project site for usage and benchmarks.https://www.nuget.org/packages/Dapper.FastCrud/2.2.0Dapper.FastCrud 2.2.02015-12-08T03:22:36Z2018-11-07T13:32:31ZMoonStormhttps://www.nuget.org/profiles/MoonStormThe fastest micro-orm type extension for Dapper is built around essential features of the C# 6 /VB 14 that have finally raised the simplicity of raw SQL constructs to acceptable maintenance levels.
These features leave no chance to mistypings or problems arising from db entity refactorings.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
There is no need to target .NET 4.6, but it is mandatory to use VS2015 or an equivalent build environment.
For .NET 4.5, the package will also install the dependency 'StringInterpolationBridge', which contains the polyfills required when using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql
- Composite primary keys are supported
- Multiple entity mappings are supported, useful for partial queries in large denormalized tables and data migrations between different database types.
- All the CRUD methods accept a transaction, a command timeout, and a custom entity mapping.
- Fast pre-computed entity queries
- A useful SQL builder and statement formatter which can be used even if you don't need the CRUD features of this library.
- A generic T4 template for C# is also provided for convenience in the NuGet package Dapper.FastCrud.ModelGenerator.
Code first entities are also supported which can either be decorated with attributes, have their mappings programmatically set, or using your own custom convention.
Please check the project site for usage and benchmarks.https://www.nuget.org/packages/Dapper.FastCrud/2.1.2Dapper.FastCrud 2.1.22015-10-30T04:55:23Z2018-11-07T13:33:44ZMoonStormhttps://www.nuget.org/profiles/MoonStormThe fastest micro-orm type extension for Dapper.
For Dapper constructs in general, it is recommended to use Visual Studio 2015 for features such as nameof and string interpolation, but that's not a requirement.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
For .NET 4.5, the package will also install the dependency 'StringInterpolationBridge', which contains the polyfills required when using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql
- Entities having composite primary keys are supported
- Multiple entity mappings are supported, useful for partial queries in large denormalized tables and data migrations between different database types.
- All the CRUD methods accept a transaction, a command timeout, and a custom entity mapping.
- Fast pre-computed entity queries
- A simple Sql builder with alias support is provided, which is very useful when manual SQL queries are unavoidable.
- A generic T4 template is also provided for convenience in the NuGet package Dapper.FastCrud.ModelGenerator.
Code first entities are also supported which can either be decorated with attributes such as Table, Key and DatabaseGenerated, or can have their mappings programmatically set.
Examples of usage:
-------------------
- using Dapper.FastCrud
- dbConnection.Insert(newEntity);
- dbConnection.Get()
- dbConnection.Get(new Entity() {Id = 10});
- dbConnection.Update(updatedEntity);
- dbConnection.Delete(entity)
- dbConnection.Count()
- dbConnection.Find<Entity>(
whereClause:$"{nameof(Entity.FirstName)}=@FirstNameParam",
orderClause:$"{nameof(Entity.LastName)} DESC",
skipRowsCount:10, limitRowsCount:20,
queryParameters: new {FirstNameParam: "John"});
This is where the power of the C# 6 compiler comes into play, and leaves no chance to mistypings or to problems arising from db entity refactorings.
More details and benchmarks are available on the project site.https://www.nuget.org/packages/Dapper.FastCrud/2.1.0Dapper.FastCrud 2.1.02015-09-18T18:13:56Z2018-11-07T13:34:04ZMoonStormhttps://www.nuget.org/profiles/MoonStormThe fastest micro-orm type extension for Dapper.
For Dapper constructs in general, it is recommended to use Visual Studio 2015 for features such as nameof and string interpolation, but that's not a requirement.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
For .NET 4.5, the package will also install the dependency 'StringInterpolationBridge', which contains the polyfills required when using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql
- Entities having composite primary keys are supported
- Multiple entity mappings are supported, useful for partial queries in large denormalized tables and data migrations between different database types.
- All the CRUD methods accept a transaction, a command timeout, and a custom entity mapping.
- Fast pre-computed entity queries
- A simple Sql builder with alias support is provided, which is very useful when manual SQL queries are unavoidable.
- A generic T4 template is also provided for convenience in the NuGet package Dapper.FastCrud.ModelGenerator.
Code first entities are also supported which can either be decorated with attributes such as Table, Key and DatabaseGenerated, or can have their mappings programmatically set.
Examples of usage:
-------------------
- using Dapper.FastCrud
- dbConnection.Insert(newEntity);
- dbConnection.Get()
- dbConnection.Get(new Entity() {Id = 10});
- dbConnection.Update(updatedEntity);
- dbConnection.Delete(entity)
- dbConnection.Count()
- dbConnection.Find<Entity>(
whereClause:$"{nameof(Entity.FirstName)}=@FirstNameParam",
orderClause:$"{nameof(Entity.LastName)} DESC",
skipRowsCount:10, limitRowsCount:20,
queryParameters: new {FirstNameParam: "John"});
This is where the power of the C# 6 compiler comes into play, and leaves no chance to mistypings or to problems arising from db entity refactorings.
More details and benchmarks are available on the project site.https://www.nuget.org/packages/Dapper.FastCrud/2.0.0Dapper.FastCrud 2.0.0.02015-06-01T16:23:22Z2018-11-07T13:34:43ZMoonStormhttps://www.nuget.org/profiles/MoonStormThe fastest micro-orm type extension for Dapper.
For Dapper constructs in general, it is recommended to use Visual Studio 2015 for features such as nameof and string interpolation, but that's not a requirement.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
For .NET 4.5, the code contains the polyfills for the missing FormattableString class, which is required when targetting that framework version and using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql
- Entities having composite primary keys are supported
- Multiple entity mappings are supported, useful for partial queries in large denormalized tables and data migrations between different database types.
- All the CRUD methods accept a transaction, a command timeout, and a custom entity mapping.
- Fast pre-computed entity queries
- A simple Sql builder with alias support is provided, which is very useful when manual SQL queries are unavoidable.
- A generic T4 template is also provided for convenience in the NuGet package Dapper.FastCrud.ModelGenerator.
Code first entities are also supported which can either be decorated with attributes such as Table, Key and DatabaseGenerated, or can have their mappings programmatically set.
Examples of usage:
-------------------
- using Dapper.FastCrud
- dbConnection.Insert(newEntity);
- dbConnection.Get()
- dbConnection.Get(new Entity() {Id = 10});
- dbConnection.Update(updatedEntity);
- dbConnection.Delete(entity)
- dbConnection.Find<Entity>(
whereClause:$"{nameof(Entity.FirstName)}=@FirstNameParam",
orderClause:$"{nameof(Entity.LastName)} DESC",
skipRowsCount:10, limitRowsCount:20,
queryParameters: new {FirstNameParam: "John"});
This is where the power of the C# 6 compiler comes into play, and leaves no chance to mistypings or to problems arising from db entity refactorings.
More details and benchmarks are available on the project site.https://www.nuget.org/packages/Dapper.FastCrud/1.1.1Dapper.FastCrud 1.1.1.02015-05-21T22:58:46Z2018-11-07T13:35:24ZMoonStormhttps://www.nuget.org/profiles/MoonStormFast Dapper CRUD extensions added to the IDbConnection for convenience and a less error prone experience. This library is 2x faster than Dapper.SimpleCRUD.
For Dapper constructs in general, it is recommended to use Visual Studio 2015 for features such as nameof and string interpolation but that's not a requirement.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
For .NET 4.5, the code contains the polyfills for the missing FormattableString class, which is required when targetting that framework version and using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite, PostgreSql
- Entities having composite primary keys are supported
- All the CRUD methods accept a transaction and a command timeout
- Fast pre-computed entity queries
- A generic T4 template is also provided for convenience. Entity domain partitioning and generation can be achieved via separate template configurations.
Existing POCO entities are also supported which can be decorated with attributes such as Table, Key and DatabaseGenerated.
Column name overrides are not supported and not recommended. As you'll end up writing more complex SQL queries, outside of the domain of this library, you'll want to use the nameof operator as much as possible.
Examples of usage:
-------------------
- DapperExtensions.Dialect = SqlDialect.MsSql | MySql | SqLite | PostgreSql
- dbConnection.Insert(newEntity);
- dbConnection.Get()
- dbConnection.Get(new Entity() {Id = 10});
- dbConnection.Update(updatedEntity);
- dbConnection.Delete(entity)
- dbConnection.GetTableName<Entity>()
- dbConnection.Find<Entity>(
whereClause:$"{nameof(Entity.FirstName)}=@FirstNameParam",
orderClause:$"{nameof(Entity.LastName)} DESC",
skipRowsCount:10, limitRowsCount:20,
queryParameters: new {FirstNameParam: "John"});
This is where the power of the C# 6 compiler comes into play, and leaves no chance to mistypings or to problems arising from db entity refactorings.
More details and benchmarks are available on the project site.https://www.nuget.org/packages/Dapper.FastCrud/1.1.0Dapper.FastCrud 1.1.0.02015-05-21T21:33:02Z2018-11-07T13:35:34ZMoonStormhttps://www.nuget.org/profiles/MoonStormFast Dapper CRUD extensions added to the IDbConnection for convenience and a less error prone experience. This library is 2x faster than Dapper.SimpleCRUD.
For Dapper constructs in general, it is recommended to use Visual Studio 2015 for features such as nameof and string interpolation but that's not a requirement.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
For .NET 4.5, the code contains the polyfills for the missing FormattableString class, which is required when targetting that framework version and using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb, Ms Sql Server, MySql, SqLite
- Entities having composite primary keys are supported
- All the CRUD methods accept a transaction and a command timeout
- Fast pre-computed entity queries
- A generic T4 template is also provided for convenience. Entity domain partitioning and generation can be achieved via separate template configurations.
Existing POCO entities are also supported which can be decorated with attributes such as Table, Key and DatabaseGenerated.
Column name overrides are not supported and not recommended. As you'll end up writing more complex SQL queries, outside of the domain of this library, you'll want to use the nameof operator as much as possible.
Examples of usage:
-------------------
- DapperExtensions.Dialect = SqlDialect.MsSql|MySql|SqLite
- dbConnection.Insert(newEntity);
- dbConnection.Get()
- dbConnection.Get(new Entity() {Id = 10});
- dbConnection.Update(updatedEntity);
- dbConnection.Delete(entity)
- dbConnection.GetTableName<Entity>()
- dbConnection.Find<Entity>(
whereClause:$"{nameof(Entity.FirstName)}=@FirstNameParam",
orderClause:$"{nameof(Entity.LastName)} DESC",
skipRowsCount:10, limitRowsCount:20,
queryParameters: new {FirstNameParam: "John"});
This is where the power of the C# 6 compiler comes into play, and leaves no chance to mistypings or to problems arising from db entity refactorings.
More details and benchmarks are available on the project site.https://www.nuget.org/packages/Dapper.FastCrud/1.0.2Dapper.FastCrud 1.0.2.02015-05-18T05:40:48Z2018-11-07T13:35:54ZMoonStormhttps://www.nuget.org/profiles/MoonStormFast Dapper CRUD extensions added to the IDbConnection for convenience and a less error prone experience. This library is 2x faster than Dapper.SimpleCRUD.
For Dapper constructs in general, it is recommended to use Visual Studio 2015 for features such as nameof and string interpolation but that's not a requirement.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
For .NET 4.5, the code contains the polyfills for the missing FormattableString class, which is required when targetting that framework version and using string interpolation with the C# 6 compiler in VS 2015.
Features:
----------
- Support for LocalDb and Ms Sql Server (more coming soon)
- Entities having composite primary keys are supported
- All the CRUD methods accept a transaction and a command timeout
- Fast pre-computed entity queries
- A generic T4 template is also provided for convenience. Entity domain partitioning and generation can be achieved via separate template configurations.
Existing POCO entities are also supported which can be decorated with attributes such as Table, Key and DatabaseGenerated.
Column name overrides are not supported and not recommended. As you'll end up writing more complex SQL queries, outside of the domain of this library, you'll want to use the nameof operator as much as possible.
Examples of usage:
-------------------
- dbConnection.Insert(newEntity);
- dbConnection.Get()
- dbConnection.Get(new Entity() {Id = 10});
- dbConnection.Update(updatedEntity);
- dbConnection.Delete(entity)
- dbConnection.GetTableName<Entity>()
- dbConnection.Find<Entity>(
whereClause:$"{nameof(Entity.FirstName)}=@FirstNameParam",
orderClause:$"{nameof(Entity.LastName)} DESC",
skipRowsCount:10, limitRowsCount:20,
queryParameters: new {FirstNameParam: "John"});
This is where the power of the C# 6 compiler comes into play, and leaves no chance to mistypings or to problems arising from db entity refactorings.
More details and benchmarks are available on the project site.https://www.nuget.org/packages/Dapper.FastCrud/1.0.1Dapper.FastCrud 1.0.1.02015-05-16T08:25:41Z2018-11-07T13:36:02ZMoonStormhttps://www.nuget.org/profiles/MoonStormSimple extensions added to the IDbConnection for convenience and a less error prone experience. This library is 2x faster than Dapper.SimpleCRUD.
For Dapper constructs in general, it is recommended to use Visual Studio 2015 for features such as nameof and string interpolation but that's not a requirement.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
For .NET 4.5, the code contains the polyfills for the missing FormattableString class, which is required when targetting that framework version and using string interpolation with the C# 6 compiler in VS 2015.
Examples of usage:
-------------------
- dbConnection.Insert(newEntity);
- dbConnection.Get()
- dbConnection.Get(new Entity() {Id = 10});
- dbConnection.Update(updatedEntity);
- dbConnection.Delete(entity)
- dbConnection.GetTableName<Entity>()
- dbConnection.Find<Entity>(
whereClause:$"{nameof(Entity.FirstName}=@FirstNameParam",
orderClause:$"{nameof(Entity.LastName)} DESC",
queryParameters: new {FirstNameParam: "John"});
This is where the power of the C# 6 compiler comes into play, and leaves no chance to mistypings or to problems arising from db entity refactorings.
Features:
----------
- Support for LocalDb and Ms Sql Server (more coming soon)
- Entities having composite primary keys are supported
- All the CRUD methods accept a transaction and a command timeout
- Fast pre-computed entity mappings
- A generic T4 template is also provided for convenience. Isolated entity generation via separate template configurations.
Existing POCO entities are also supported which can be decorated with attributes such as Table, Key and DatabaseGenerated.
Column name overrides are not supported and not recommended. As you'll end up writing more complex SQL queries, outside of the domain of this library, you'll want to use the nameof operator as much as possible.https://www.nuget.org/packages/Dapper.FastCrud/1.0.0Dapper.FastCrud 1.0.0.02015-05-16T01:51:07Z2018-11-07T13:36:18ZMoonStormhttps://www.nuget.org/profiles/MoonStormSimple extensions added to the IDbConnection for convenience and a less error prone experience. This library is 2x faster than Dapper.SimpleCRUD.
For Dapper constructs in general, it is recommended to use Visual Studio 2015 for features such as nameof and string interpolation but that's not a requirement.
The package contains .NET 4.5 and 4.6 DLLs, one of which will be installed based on the target framework in your project.
Examples of usage:
- dbConnection.Insert(newEntity);
- dbConnection.Get()
- dbConnection.Get(new Entity() {Id = 10});
- dbConnection.Update(updatedEntity);
- dbConnection.Delete(entity)
- dbConnection.GetTableName<Entity>()
- dbConnection.Find<Entity>(
whereClause:$"{nameof(Entity.FirstName}=@FirstNameParam",
orderClause:$"{nameof(Entity.LastName)} DESC",
queryParameters: new {FirstNameParam: "John"});
This is where the power of the C# 6 compiler comes into play, and leaves no chance to mistypings or to problems arising from db entity refactorings.
Features:
- Support for LocalDb ans Ms Sql Server (support for more databases will come soon)
- Entities having composite primary keys are supported
- All the CRUD methods accept a transaction and a command timeout
- Fast pre-computed entity mappings
- A generic T4 template is also provided for convenience. Isolated entity generation via separate template configurations.
Existing POCO entities are also supported which can be decorated with attributes such as Table, Key and DatabaseGenerated.
Column name overrides are not supported and not recommended. As you'll end up writing more complex SQL queries, outside of the domain of this library, you'll want to use the nameof operator as much as possible.