Persisted GraphQL operations for Trax .NET: server-managed manifest mapping build-time-stable operation IDs to documents. Lets shipped clients (mobile, etc.) hot-fix server-side queries without redeploying the client. Includes shape-diff guardrail, optional in-memory cache, and optional RabbitMQ-backed multi-node cache invalidation.
# ThrowAway **ThrowAway** is a pragmatic and efficient C# library that marries functional programming concepts with traditional procedural error handling. It is designed to elegantly manage the dichotomy between successful outcomes (`Values`) and error states (`Failures`) by leveraging the power of the **Option** type. This hybrid approach makes it easy to write expressive, functional code while still integrating seamlessly with conventional try-catch exception handling. ## Overview In many C# applications, error handling is either bogged down by traditional exception logic or forced into a rigid functional style. ThrowAway bridges these two worlds by offering: - **Explicit Functional Handling:** Model success and failure as first-class citizens with Option types. - **Seamless Procedural Integration:** Implicit conversions let you work with Options as if they were plain values - while automatically throwing a `HasFailedException` when an Option is in a failed state. This allows you to mix functional transformations with traditional try-catch error management. ## Key Features - **Dual Outcomes:** Every operation returns an Option that encapsulates either a valid result (`Value`) or an error (`Failure`). - **Implicit Conversions:** Options automatically convert to their underlying type. When an Option represents a failure, an exception is thrown, enabling smooth integration with procedural exception handling. - **Rich Functional API:** A suite of extension methods (like `Map`, `FlatMap`, `Match`, `Filter`, `Transpose`, and `Use`) enables chaining and composing operations in a functional style. - **No Nulls:** Being struct-based, Options guarantee non-null instances, improving type safety. - **Hybrid Error Handling:** Combines the explicitness of functional error handling with the convenience of procedural exception handling. - **Robust Exception Wrapping:** Methods like `CatchFailure` and `CatchAll` convert exceptions into failed Options, maintaining consistency in error handling. - **Seamless Unwrapping:** `TryUnwrap` lets you extract both the value and the failure message without additional boilerplate.
Map Umbraco Content Types to Schema.org types and automatically generate JSON-LD structured data for your pages. Backoffice UI, auto-mapping, Delivery API integration, and a Razor tag helper.
Arcturus.Patchable is a lightweight .NET library for modeling and applying partial updates (patches) to objects in Web APIs. It provides strongly-typed patch contracts, opt-in patchable members, and helpers to validate, map, and merge changes before persistence—ideal for JSON-driven APIs where clients send only the fields they want to change.
Provides a command line API. Includes attributes to map commands to methods and classes to execute those commands. The commands support arbitrary input parameters, return values, and async execution.
A easy to use, high performance and robust library for implementing Facebook's API in any .NET environment. Includes 100 endpoints and 258 object properties mapped directly to .NET, with the ability to extend to any new endpoint.
Returns the 51Degrees Identifier (51Did) from the 51Degrees Cloud service through the 51Degrees Pipeline API. This engine maps the cloud response into the six 51Did properties, being probabilistic, random and hashed-email, each of which is either global across all callers or scoped to the caller's licence key. The outbound call itself is made by CloudRequestEngine from FiftyOne.Pipeline.CloudRequestEngine, so register both builders in the pipeline. A 51Degrees resource key is required.
SQLitePCL.pretty wraps the C like SQLiteAPI provided by SQLitePCL.raw with a friendly C# object oriented API. Notable features include support for using LINQ expressions on SQL query results, SQLite events exposed as C# events, and the ability to take advantage of advance SQLite features, such as collation, aggregate, scalar, and commit hook functions. For asynchronous query support, an additional companion API is available. See: https://www.nuget.org/packages/SQLitePCL.pretty.Async/ A simple table mapped ORM is also available. See https://www.nuget.org/packages/SQLitePCL.pretty.Orm/
GeoPicker EPiserver property is based on Google Maps API and provides a rich interface for selecting a geo-coordinates – perfect for editing location of points of interests we want to show on a map.
XmlToObjectConverter converts an XmlDocument or string to an object graph. The way to map XML to classes is easier than the classic ways in .NET. XmlHelper allows you to access XML in a null-safe and multiplicity-safe way. It uses XmlDocument as the underlying .NET API.
Lighter.NET is an light-weighted and intergrated package containing both back-end and front-end libraries, aiming to help developers to create .NET web application more efficiently, delightfully and decoupled from the .NET versions and unnecessary external dependancies. With Lighter.NET, you can: 1. Say Goodbye to the notorious ViewData and ViewBag. 2. Say Goodby to the long-winded Entity Data Model file structures, such as *.edmx, *.Context.tt, *.Designer.cs, and unecessary DbSet for db table mapping. 3. Say Goodbye to ever changing HtmlHelper or TagHelper as .NET version rapidly increasing. 4. Say Hello to a more clean, concise and elegant front-end and back-end coding style. 5. Say Hello to a more joyful and efficient coding experience. 6. Say Goodbye to jQuery. 7. Say Goodbye to Bootstrap. The features include the following: 1. An ApiResult class which unified the return data structure both for client-server API requests and the inter-function calls. 2. A ViewModelWrapper for delivering multiple models in a strong type manner between controller and view. 3. A series of framework-independant UiComponents for composing and rendering most frequently used html elements both from Views, Controllers or API endpoints. 4. Providing an light-weight ORM utilities through Lighter.NET.DB nuget package featuring easy CRUD, data paging, auto logging, partial columns updating, auto-increment column support and much more. 5. Providing an enhanced developer-friendly reflection tool kits. 6. Providing a more efficient localization mechanism with CompositeLocalizer. 7. Providing a series of more flexible and practical DateTime utilities including a MonthlyCalensar and DateTime extension methods. 8. Providing an enhanced and simplfied HttpClient helper for interaction with remote APIs. 9. Providing a set of IP address utilities which support both general and CIDR IP address range parsing and IP address related funcitons such as comparison, boundary IP address determination, applying netmask to an IP address, determining whether an IP range contains or overlaps with the other, etc.. 10. A ServerSideEventService that can start Server Side Event(SSE) response session, send messages, data and custom events to the client and control the cancellation and the life cycle of the whole process reliably. 11. A TextTemplateParser which is capable of parsing a text template with symbol clamped variable placeholder and applying the data model to fillout the variable placeholder. 12. A thread-safe CacheStore which can manage the cached items and their lifetime. 13. A toolset for simplifying and enhancing the use of Reflection. 14. Some other helpers to simplify common application development works. 15. A set of javascript library for client side DOM operations, AJAX oprerations, UI components such as DatePicker, PagingBar, AutoComplete, PopView, Panel, etc. and other client side routine UI interactions. 16. A light-weight responsive css framework for responsive design.
This is a port of the official IP Geolocation API (https://github.com/IPGeolocation/ip-geolocation-api-dotnet-sdk) that provides support for .NET Framework 4.0 and above with some few more additions. The official library only supports .NET Core. Fore more info, please visit https://github.com/Willy-Kimura/ip-geolocation-api-dotnet-sdk. IPGeolocation API (https://ipgeolocation.io) lets you identify country code (ISO2 and ISO3 standard), country name, continent code, continent name, country capital, state/province, district, city, zip code, latitude and longitude of city, if a country belongs to European Union, calling code, top level domain (TLD), languages, country flag, Internet Service Provider (ISP), connection type, organization, geographical name ID, currency code, currency name, time zone ID, time zone offset, current time in the time zone, is time zone in daylight saving time, and total daylight savings.
FourSquare SDK for .NET The SharpSquare .NET library provides a quick access to the FourSquare API v2. The library is built in C# and can therefore be used by all languages the .NET environment supports. Beacuse of clean natural object oriented approach, the library is easy to use. SharpSquare implements almost all the features offered by the FourSquare API and fully supports the oAuth protocol. Each API call is mapped to a one-to-one method and each FourSquare entity is mapped to a class.
This library is a simple wrapper over some common Google Maps or Google Places 'Web Services' API. It's ment to provide a quick and convenient way to query the specific Google Api's.
MapGuide Desktop API for .net. This package includes the FDO (Feature Data Objects) data access libraries. This wraps the x64 unmanaged binaries of mg-desktop. This package replaces the mg-desktop-net40-x64 package. That package still exists and should be considered a legacy package. Supported Platforms: - .NET Framework 4.0 and above
Abstractions used by the Ofl.Google.Maps project.
Register your api with Consul service registry. Use service discovery, key value store from consul and etc. Usage => In "Startup.cs" file In "ConfigureServices" Method add following line services.AddConsulClient(Configuration); //Configuration is ICounfiguration object mapped to json config file where exists consul config section. In "Configure" Method add "IApplicationLifetime lifetime" as parameter and following line app.UseConsul(lifetime); Example Configuration section for consul (add in your appsettings.json or somwhere else): "ConsulConfig": { "Address": "http://127.0.0.1:8500", "Token": "ConsulACLToken", "ApiName": "YourServiceApi", "Tags": [ "yourservicetag", "urlprefix-/yourservicetag strip=/yourservicetag" ] }
Accelerate the creation of .NET 5 API projects exposing IoT Hub features (Azure IoTHub C# SDK) with minimal dependencies and a solution containing settings for DI/IoC, API versioning, automatic OpenAPI/Swagger documentation, separated layers, preconfigured mapping settings, preconfigured log settings, etc.
A Result pattern library for .NET with typed errors, Railway-Oriented pipelines, and automatic flow diagrams generated from your code. Provides Result<T>, Result<T,TError>, ErrorsOf<T1..T8>, rich domain errors (ValidationError, ForbiddenError, NotFoundError, ConflictError) with TagKey<T> metadata, ResultContext for entity/correlation/tenant tracking, and full async pipeline support via Bind, Map, Ensure, Tap. Companion packages add pipeline visualization, ASP.NET Core, FluentValidation, OpenTelemetry, HTTP integration, and Roslyn safety analyzers.
UNLEIN® Utilities is a production-ready helper suite for .NET 6+/8+/9+ that removes boilerplate from everyday services. It ships: - Cryptology helpers for one-way/two-way hashing, secure tokens, and key-based encryption/decryption - File utilities for pre-upload metadata, Base64 generation, safe renaming, and instant uploads - Cookie manager plus string, collection, validation, math/finance, and date/time extension packs - Database stack with shared connections, retries, dynamic mapping, DataSet/DataTable helpers, and bulk insert - Lightweight logger with rolling files, API client with auto logging + telemetry, global error handler, retry policies, cache, and formula solver - NEW ObjectMapper for reflection-based auto mapping with naming transforms, skip-null semantics, and collection projections - NEW JsonSerialization layer for camel/snake/kebab/lower/upper naming when serializing or deserializing - README-backed docs, samples, and ready-to-ship configuration baked into the NuGet package About UNLEIN® Private Limited: - Focus on developer productivity tooling - Builds cloud-friendly solutions that balance performance and simplicity - Offers enterprise support, architectural guidance, and consulting for adopters - Trusted by fintech, ecommerce, and SaaS teams to keep pipelines resilient Drop it in, go to production, and publish to NuGet with confidence—UNLEIN® handles the plumbing while you focus on product.
Core abstractions and interfaces for Zonit.Extensions.Databases - a powerful repository pattern library with support for CRUD operations, dynamic queries, DTO mapping, and external data integration.
The eco friendly set of array pool based collections for netstandard2.1. Container's storage allocated and recycled back to shared memory pool by default. List of generic collections and APIs supported: - ``List`` - ``Map`` - ``Set`` - ``Stack`` - ``Queue`` Some extras built in: - BitArr - std::vector api - Python like APIs. Append methods, ``+`` ``-``, equality operators overloaded. - Lambda allocation free enumerable extensions Each collection is serializable by default. It has a class destructor defined and ``System.IDisposable`` interface implemented to recycle internal storage on demand or by ``GC``.
Target Platform/Framework: Web DevExpress Product Libraries Used: XAF (Cross-Platform .NET App UI & Web API) (https://www.devexpress.com/xaf) Available in the following DevExpress Subscription(s): Universal
SQL provider implementations for OmniDataAccess (PostgreSQL, CockroachDB, MySQL, SQL Server, SQLite) plus the OmniDB ORM layer. Includes an async-first ADO.NET-style manager (ISqlDatabaseManager) with mapped queries, streaming, paging, entity CRUD, bulk operations, transactions with savepoints, and stored procedures — and a higher-level entity API with a fluent LINQ query builder, eager loading, soft delete, optimistic concurrency, schema generation, and migrations.
Helps developers query Sitecore through the Item Web API and map custom models to Sitecore Items
The Maps JavaScript API encapsulated in Razor components.
A high performance content-object mapper for Umbraco. u2 support both sync and async. u2 uses Examine and Lucene query directly and has build-in caching, which makes it extremely fast. u2 uses a convention-based matching algorithm to auto match up content fields to object properties and fluent APIs to define costume mappings. u2 supports both IoC integration and stand-alone usages. u2 is interface based and highly flexible. u2 is designed to be Web API and MVC controller friendly. This is the umbraco module.
SQL Server provider for Zonit.Extensions.Databases - Entity Framework Core repository with fluent query API, ThenInclude, DTO mapping, and full-text search support.
Maps package for Lumeo — install alongside Lumeo. Modern WebGL maps powered by MapLibre GL with free CARTO basemaps (no API key required). Markers, routes, polygons, circles, arcs, clustering and shadcn-style controls included.
To make full use of web APIs, exclude the installation of extra packages by just installing DapperDBHelper. Create an object of DapperDBHelper and pass your connection string through the constructor of the DBHelper class. Here's how you can use DapperDBHelper. Below is an example: public class SetupsController { private readonly DBHelpers _dBHelpers; public SetupsController() { _dBHelpers = new DBHelpers(ConectionString.connectionString); } public async Task<List<YourViewModelClass>> GetSingleListAsync() { var result = await _dBHelpers.QueryAsyncList<YourViewModelClass>("SELECT * FROM table"); return result; } public YourViewModelClass GetSingleRecord() { var result = _dBHelpers.Query<YourViewModelClass>("SELECT TOP 1 * FROM table"); return result; } public async Task<Dictionary<string, IEnumerable<object>>> GetMultipleTablesAsync(int id) { // Make a list of table names that your stored procedure returns List<string> tableNames = new List<string> { "Table1", "Table2", "Table3" }; var result = await _dBHelpers.QueryMultipleAsync("EXEC Store_Procedure @ID", new { ID = id }, tableNames); return result; } // Execute Method is used for CRUD operations // After execution of your stored procedure, returning a single row of current execution is a best practice // ExecuteAsync call depends upon your application nature public async Task<int> InsertDataAsync(Employees model) { var result = await _dBHelpers.ExecuteAsync("EXEC Store_Procedure @FirstName, @LastName, @Address", new { FirstName = model.FirstName, LastName = model.LastName, Address = model.Address }); return result; } } For .NET 8, you can use the following code: // Register your service here builder.Services.AddTransient<DBHelpersForAllDatabases>(); // Register your database connection builder.Services.AddTransient<IDbConnection>(_ => new SqlConnection(Configuration.GetConnectionString("DefaultConnection"))); public class MyController : ControllerBase { private readonly DBHelpersForAllDatabases _dbHelpers; public MyController(DBHelpersForAllDatabases dbHelpers) { _dbHelpers = dbHelpers; } [HttpGet] public async Task<IActionResult> Get() { // Use DBHelpers to execute queries var result = await _dbHelpers.QueryAsyncList<MyModel>("SELECT * FROM MyTable"); return Ok(result); } } In this setup: GetSingleListAsync: Asynchronously retrieves a list of records from a table. GetSingleRecord: Retrieves a single record from a table. GetMultipleTablesAsync: Executes a stored procedure that returns multiple tables and maps them to a dictionary. InsertDataAsync: Executes a stored procedure to insert data into a table. Make sure to adjust the method signatures and implementations to match your specific use case and requirements. This setup allows you to effectively manage database interactions using DapperDBHelper in a streamlined manner.
.NET 4.5 The goal of ModelMapper is to make object mapping easy, by automatically determining how one object model maps to another, based on conventions, in the same way that a human would - while providing a simple, refactoring-safe API for handling specific use cases.
Bybit.Net is a client library for accessing the Bybit REST and Websocket API. All data is mapped to readable models and enum values. Additional features include automatic websocket (re)connection management, an implementation for maintaining a client side order book, easy integration with other exchange client libraries and more.
This is the dedicated Commons Web Library to accopmany my Commons Library, which is a separate package that includes the following features. Constructs to support web environment initialization, as well as various utilities. Packaged libraries (such as Angular, Bootstrap, SignalR, etc.) in embedded form and a way to serve them (so that you don't have to keep including the scripts in every application). Static content minification components. REST-based resource mapping layer for Web API that lets you route resource requests directly to services without having to write controllers. Security components targeted specifically at single page applications (SPAs) that use WIF.
Official SDK for consuming TAF.CRUD microservice. v6.9.0: Adds CheckInNotificationEvent and CheckInNotificationKind (Assigned = 1, Answered = 2) to TAF.CRUD.Domain.Events.CheckIns - one event for the check-in notifications (a run asked people to answer; an answer reached its receivers), consumed by taf_notificationservice. Self-contained payload (recipients resolved, title, answerer name, round) so the consumer performs no tenant-database access. Adds AppFieldConstants.UserName and AppFieldConstants.Email. Also the first published build of the 6.8.0 changes below. v6.8.0: Adds two optional properties to TriggerCreatedEvent, TriggerUpdatedEvent and TriggerDeletedEvent - SourceTriggerId (Guid?) and ReleaseVersion (string?) - set only for the released copy of a versioned TABD_Triggers row (ADR 0001): the Development row id (stable identity) and the copy's release. TriggerId is then the copy's own row id; key its scheduled job by (SourceTriggerId, EnvironmentId). Both stay null for Development rows and every unversioned trigger, so consumers on 6.7.0 and earlier see identical events. v6.7.0: Adds ApprovalNotificationKind.RecordChanged (6), raised when a watched field changes while an approval is still being decided and the process is configured ApprovalReApprovalPolicy.NotifyOnly - the approval is not re-run; the approvers who already signed off and the requester are told the record moved. Consumers on 6.6.0 receive the value but cannot map it to a definition. v6.6.0: Adds ApprovalNotificationEvent and ApprovalNotificationKind to TAF.CRUD.Domain.Events.Approval - one event for all five approval notifications (assignment, decision, reminder, escalation, outcome), discriminated by Kind and consumed by taf_notificationservice. Self-contained payload with recipients already resolved, so the consumer performs no tenant-database access. Replaces a design that required a TABD_Triggers row and a TABD_Notifications row in every app's database. v6.4.0: RecordMentionedEvent replaces AppBaseUrl with RecordPath (relative, for the in-app card whose client prefixes origin and app code itself) and RecordUrl (absolute, for the email, which is read outside the app where a relative href resolves against the mail client's own domain). BREAKING for anyone reading AppBaseUrl — it was always empty, so no deep link worked. Every CRUD event now also carries Origin and AppCode, captured from the originating request. v6.3.0: Folds the mention AppObject names (TABD_Comments, TABD_Record_Tagged, AspNetUsers, TABD_Person) into AppObjectConstants, so the bundled TAF.CRUD.SharedKernel.dll carries them. v6.2.0: Adds RecordMentionedEvent to TAF.CRUD.Domain.Events.Records — published by CRUD after commit when a record's rich-text content @-mentions users, and consumed by taf_notificationservice to deliver the mention notification. Self-contained payload (recipients, commenter name, plain-text preview, parent title and route) so the consumer performs no tenant-database access. v6.0.12: Bumps TAF.Infra.MassTransit dependency to 2.2.20 — CommandConsumer now logs at Information level (visible in Kibana at default log level) and pushes CorrelationId/TenantId/UserId/AppId/EnvironmentId into ILogger scope so all downstream handler logs carry correlation context. v6.0.9: Fixes DatabaseClient.ExecuteAsync deserialization mismatch — client was expecting List<List<Dictionary>> but API returns the flattened single-result-set shape List<Dictionary>. SP/function calls returning at least one row (including void-returning PG functions that produce a synthetic NULL row) now deserialize correctly. v6.0.8: JsonDefaults no longer attaches JsonStringEnumConverter — SDK requests serialize enums in their default integer form so the CRUD API (which has no string-enum converter) can deserialize them. Fixes 400 BadRequest on UPDATE/DELETE calls that carry a WhereClause filter.
Fluent API for importing CSV and Excel (XLSX) data into .NET 8+ with customizable property mapping, validation, type conversion, and support for init-only properties. Handles headers normalization, regex validation, custom converters, and detailed error reporting.
A .NET client library for the PCA Predict Capture Plus address search API. This is a basic wrapper around the Capture Plus web services, which maps the JSON responses to .NET classes. Disclaimer: This is not an official library! I am not in any way affiliated with Postcode Anywhere Ltd or the PCA Predict service (other than being a user of the service).
map hive core api utils - base for mh env api controllers use at your own risk...
BingMaps.js is a jQuery plugin to show Bing map on your web page and does all the configurations by itself. Yo can also set the other options for the map. The plugin also uses the Bing Maps API which allows you to search the location/address and pinpoint it on the map.
ASP.NET Core integration for Linger.Results library, providing extension methods to seamlessly convert Result objects to ActionResults with appropriate HTTP status codes. Simplifies API response handling with RFC 7807 support and automatic status mapping.