Profile cover photo
Profile photo
Demis Bellot
Communities and Collections
View all

Post has attachment
v5.4 Released!

Excited to share our new `app` and `web` dotnet tools which are packed with features around making it easy to create, run, discover, install, update and publish .NET Core Windows Applications.

Basically you can run existing .NET Core Apps within a Windows Desktop Application that renders it within a Chromium Embedded Framework (CEF) browser with:

$ app MyApp.dll

For better integration you can create a Desktop Shortcut with:

$ app shortcut MyApp.dll

Whilst it's useful for all .NET Core Apps, it's especially suited for [ServiceStack Web Apps][1] where it greatly simplifies the development model, discovery and distribution of your published App. E.g. you can install a local [Redis Admin UI][2] with:

$ app install redis

and then run it by double-clicking the generated Desktop Shortcut.

It also supports multiple publishing options where you can package your App with the `app` binaries into a xcopy-able folder with:

$ app publish

Or you can bundle .NET Core with your App by creating a self-contained .NET Core App with:

$ app publish

Please check the Release Notes for tonnes of other features which also includes a step-by-step guide for creating a SVG "Spirals" Desktop App where all development happens whilst the App is running in real-time:


Post has attachment
v5.2 Released!

This release includes support for .NET Core 2.1, number of performance improvements with internals rewritten to use .NET’s new Span<T> Memory Types, all SPA Templates upgraded to utilize latest CLI projects, new simpler zero-configuration Parcel SPA Templates, exciting enhanced capabilities added to ServiceStack Templates - providing a fun and productive alternative to Razor, more capable and versatile Web Apps, a minimal multi-user .NET Core Blog Web App developed in a real-time live development workflow, enhancements to Swift, Dart, TypeScript end-to-end Typed integrations, support for the latest 3rd Party dependencies, and lots more.

Checkout the table of contents below to jump to and read more about features you're interested in:

Spanified ServiceStack
- Performance Improvements
- .NET Core Memory Provider Abstraction
- MemoryStream Pooling
- Support for .NET Core 2.1

.NET Core Templates
- vue-spa
- react-spa
- angular-spa
- aurelia-spa
- vuetify-spa
- vue-nuxt
- vuetify-nuxt
- SPA Project Templates Dev Workflow
- New Parcel SPA Template

ServiceStack Templates Remastered
- JavaScript Expressions
- Template Blocks
- Page Based Routing
- Dynamic Page Routes
- Init Pages
- Buffered View Pages
- Dynamic API Pages
- Order Report Example
- SQL Studio Example

New in Web Apps
- Customizable Auth Providers
- Customizable Markdown Providers
- Rich Template Config Arguments
- New Parcel Web App Template

New Blog Web App

Templates Admin Service
- Zero downtime deployments

New Template Filters

- Support for Npgsql 4.01
- Support for MySql.Data 8.0.12
- Bitwise operators
- Extended Select SqlExpression APIs
- OrmLite variables in CustomField
- Update from Object Dictionary
- Custom Index Name
- Array parameters in ExecuteSql

- Debugging Data Corruption Issues

Add ServiceStack Reference
- Swift
- Dart
- TypeScript
- Customize DTO Type generation
- Interfaces Exported on all DTOs


- Async overloads in Service Clients
- BearerToken in Request DTOs
- New FallbackHandlers filters
- Multitenancy
- Authentication
- Serilog
v5.2 Release Notes
v5.2 Release Notes

Post has attachment
Hi Everyone,

As per yesterday's ServiceStack Community Announcement in the v5.1 Release Notes we eventually plan on closing down this Google+ Community and Feature Requests on UserVoice and directing everyone over to the new ServiceStack Community on:

If you're interested in getting notified of any new ServiceStack Announcements, hit the Subscribe button on left of the page, or follow @ServiceStack on Twitter (

If you have any feedback on suggestions please leave them in the comments on:


Post has attachment
v5.1 Released!

As these Release Notes ended up being quite long, the release notes includes a Table of Contents so you can quickly jump to any sections you're interested in:

*Dart and Flutter!*
- Flavors of Dart
- Dart ServiceStack Reference
- Example Usage
- Rich Generated Models
- JsonCodec compatible
- Default Constructor
- IConvertible
- JsonServiceClient
- JsonWebClient
- IServiceClient API
- HelloFlutter App
- HelloFlutter UI
- Standard API Requests
- Authenticated Requests
- JWT RefreshToken Requests
- AutoQuery Requests
- Generating Unknown Types
- Auto Batched Requests
- Binary Requests
- Angular Dart



*New Single Page App Templates!*
- Nuxt.js
- ServiceStack Integration
- Getting Started
- Dev Workflow
- Update DTOs
- Generate Static Production Build
- Publishing App for Deployment
- Host static content on Netlify’s CDN for free
- Nuxt Templates
- Vuetify
- Vue App
- Vue Nuxt App

*The New TechStacks*
- Resilience of ServiceStack
- Netlify CDN
- AWS LightSail
- ServiceStack Community Resources
- The new Community enhanced TechStacks
- ServiceStack Community Changes

*Solution Highlights*
- Deployments
- Client / Server Validation with Vuetify
- Extensible AutoQuery Services

*Background MQ Service*
- Using Background Service to send Emails
- Replaying Messages
- MQ Status

*New Vue Components*

- Vuetify Markdown Editor
- Beautiful, free Hero Backgrounds
- Image Upload Vue Component
- Stripe Gateway


- Accept arbitrary JavaScript or JSON Objects
- Populate Objects from Read Only Dictionary
- Support for [EnumMember]


- Support for SQL Server 2012 Sequences
- SQL Server Dialects
- Auto populated Guid Ids
- Select Multiple Join Alias Tables
- Support for [Unique] and [UniqueConstraint]
- Order by dynamic expressions
- New BeforeExecFilter and AfterExecFilter filters
- Typed Sql.Cast() SQL Modifier
- Typed Column and Table APIs
- Dapper Upgraded
- New Live Create Table Schemas Example
- .NET Core Extensibility in WebApps


- Support for multiple Audiences
- New JWT APIs


- Native Type Wildcards
- Include Request DTO and its dependent types
- Include All Types within a C# namespace
- Use a different BaseUrl
- Call Internal and External Services from URLs


- Logging
- ServerEvents Client
- Sessions
- Minor Features

*Open API*


*Patch Release Versions*
v5.1 Release Notes
v5.1 Release Notes

Post has attachment
Happy New Year All!

In case you've missed it we've recently released v5 and v5.0.2. You can read summaries for each release at:

- v5.0.2:
- v5.0.0:

Or if you have the time, please check out the full Release Notes at:

Happy Hacking!
v5.0.2 Released!
v5.0.2 Released!

v4.5.14 Released!

In this release we’ve added a new simple, fast and highly-versatile alternative to Razor for developing Server generated Websites, official support for .NET Core 2.0, new ServiceStack.Azure NuGet package for deeper integration with ServiceStack Apps hosted on Azure and a number of new features and enhancements across ServiceStack.

Please see the full release notes for what’s in this Release:

Google+ is a poor medium for detailed release notes like this, so if you prefer to read a summary instead, I recommend reading the condensed release notes summary at:

Or continue reading if you prefer a plain text-view summary below:

.NET Core 2.0 Ready

Firstly we’d like to announce this Release adds support for the newly released .NET Core 2.0. Our test suites have been upgraded to run .NET Core 2.0 as well as some of our existing .NET Core Apps. All new Web Apps created in this release were developed on .NET Core 2.0 which we believe is the first .NET Core release that should be given first consideration for development of new greenfield .NET Web Apps to see if it’s able to meet your requirements.

ServiceStack Templates!

We’re super excited to announce ServiceStack Templates. At its core ServiceStack Templates is a simple, fast and versatile general-purpose dynamic templating language for .NET and .NET Core. It requires no pre-compilation, is lazily loaded and Starts up instantly with fast runtime performance, is late-bound with no binary coupling, is highly extensible and is evaluated in a Sandbox with complete fine-grain control over what functionality is available to templates running in different contexts.

These characteristics opens up Templates into a number of exciting new use-cases, some of which we cover in our comprehensive and interactive documentation at

Starter Projects

The Starter Projects below provide a quick way to get started with a pre-configured ServiceStack Template App:

.NET Core 2.0 Boostrap Starter
Clone the TemplatesBootstrapStarter GitHub project to start from a Bootstrap v4 and jQuery .NET Core 2.0 App:

ASP.NET v4.5 Bootstrap Starter
For ASP.NET v4.5 projects create a new ServiceStack ASP.NET Templates with Bootstrap from the VS.NET Templates in ServiceStackVS VS.NET Extension to create an ASP.NET v4.5 Project using ServiceStack’s recommended project structure:

Why Templates?
We developed Templates because we want to be able to offer a simple, clean, highly-productive and innovative end-to-end solution for building ServiceStack Web Apps without the external baggage and issues Razor brings to a project. If interested in the finer details, we’ve published some of the limitations and issues we’ve hit in Why not Razor.

So we set out to build the server templating language we wanted, one without the complexity, issues, design problems and static coupling of Razor, with great Startup and runtime performance, is highly-extensible and promotes reuse, integrates cleanly with .NET but still adopts the strengths that make the premier JavaScript frameworks enjoyable and productive to build HTML UIs with.

We didn’t want to invent a new syntax so we evaluated various syntax from multiple JavaScript frameworks and ultimately settled on Vue.js Filters syntax which has optimal syntax for a templating language, we also share Vue’s primary focus on simplicity and its incremental approach to layering advanced functionality, a goal that drove the design and development of ServiceStack Templates. The Syntax is essentially compatible with Vue.js filters including supporting JavaScript’s syntax for its native data types and function calls.

Within this minimal syntax we’ve been able to achieve a highly versatile dynamic template language whose expressive power comes from its filters of which we’ve included a comprehensive suite to handle many of the tasks commonly required in Templates and Web Apps.

Meet ServiceStack Templates
Even in this initial release we’re extremely pleased with its current form. It’s not coupled to any external tooling or susceptible to any of the external factors that has plagued us with Razor. It’s highly testable by design with unit tests being trivial to write that it’s our most tested feature with over 350 new tests added to support its current feature-set, it’s also our most documented feature.

It’s small, lightweight footprint and built-in Hot Reloading provides a fun, clean and productive alternative to MVC Razor that’s easily integrated into any web framework and runs identically in every platform ServiceStack runs on, it can also be returned in ASP.NET MVC and ASP.NET MVC Core Controllers - in all cases, using the same high-performance implementation to asynchronously write to a forward-only OutputStream for max performance and maximum potential reuse of your code.

Templates are lazily loaded and late-bound for Instant Startup, doesn’t require any pre-compilation, have coupling to any external configuration files, build tools, designer tooling or have any special deployment requirements. It can be used as a general purpose templating language to enhance any text format and includes built-in support for .html.

Templates are evaluated in an Isolated Sandboxed that enables fine-grained control over exactly what functionality and instances are available to different Templates. They’re pre-configured with a comprehensive suite of safe Default Filters which when running in trusted contexts can easily be granted access to enhanced functionality.

Templates are designed to be incrementally adoptable where its initial form is ideal for non-programmers, that can gradually adopt more power and functionality when needed where they can leverage existing Services or MVC Controllers to enable an MVC programming model or have .html pages upgraded to use Code Pages where they can utilize the full unlimited power of the C# programming language to enable precise control over the rendering of pages and partials. Code pages take precedence and are interchangeable wherever normal .html pages are requested making them a non-invasive layered solution whenever advanced functionality is required.

Surrounding Ecosystem
These qualities opens Templates up to a number of new use-cases tthat’s better suited than Razor for maintaining content-heavy websites, live documents, Email Templates and can easily introspect the state of running .NET Apps where they provide valuable insight at a glance with support for Adhoc querying.

Web Apps
One use-case made possible by Templates we’re extremely excited about is Web Apps - a new approach to dramatically simplify .NET Web App development and provide the most productive development experience possible whilst maximizing reuse and component sharing.

Web Apps leverages Templates to develop entire content-rich, data-driven websites without needing to write any C#, compile projects or manually refresh pages - resulting in the easiest and fastest way to develop Web Apps in .NET!

Ultimate Simplicity
Not having to write any C# code or perform any app builds dramatically reduces the cognitive overhead and conceptual knowledge required for development where the only thing front-end Web developers need to know is Template’s syntax and what filters are available to call. Because of Template’s high-fidelity with JavaScript, developing a Website with Templates will be instantly familiar to JavaScript developers despite calling and binding directly to .NET APIs behind the scenes.

All complexity with C#, .NET, namespaces, references, .dlls, strong naming, packages, MVC, Razor, build tools, IDE environments, etc has been eliminated leaving all Web Developers needing to do is run a cross-platform web/app.dll .NET Core 2.0 executable and configure a simple web.settings text file to specify which website folder to use, which ServiceStack features to enable, which db or redis providers to connect to, etc.

Rapid Development Workflow
The iterative development experience is also unparalleled for a .NET App, no compilation is required so you can just leave the web/app.dll running whilst you add the template .html files needed to build your App and thanks to the built-in Hot Reloading support, pages will refresh automatically as you save. You’ll just need to do a full page refresh when modifying external .css/.js files to bypass the browser’s cache and you’ll need to restart web/app.dll to pick up any changes to your web.settings or .dlls to your /plugins folder.

Pure Cloud Apps
Web Apps also enable the development of Pure Cloud Apps where the same Web App can be developed and run entirely on AWS S3 and RDS or Azure Blob Storage and SQL Server by just changing the web.settings that’s deployed with the pre-compiled Web App Binary.

Example Web Apps
We’ve developed a number of Web Apps to illustrate the various features available and to showcase its strengths and the different kind of Web Apps that can easily be developed with it. The source code for each app is maintained in NetCoreWebApps and each Web App runs the same pre-compiled web/app.dll binary.

Metadata Debug Templates

All ServiceStack Apps now have access to rich introspection and queryability for inspecting remote ServiceStack instances with the new Metadata Debug Template.

The Debug Template is a Service in TemplatePagesFeature that’s pre-registered in DebugMode. The Service can also be available when not in DebugMode by enabling it with:

Plugins.Add(new TemplatePagesFeature {
EnableDebugTemplate = true

This registers the Service but limits it to Users with the Admin role, alternatively you configure an Admin Secret:

SetConfig(new HostConfig { AdminAuthSecret = "secret" })

Which will let you access it by appending the authsecret to the querystring:


Alternatively if preferred you can make the Debug Template Service available to all users with:

Plugins.Add(new TemplatePagesFeature {
EnableDebugTemplateToAll = true

Which is the configuration that allows to be accessible to anyone.

JavaScript Utils
The development of Templates also brought with it the development of a number of high-performance utilities that are useful for use on their own. The ServiceStack.Text JSON Serializer was only designed for serializing Typed POCOs, you can still use it to deserialize dynamic JSON but you would need to specify the Type to deserialize into on the call-site otherwise the value would be returned as a string.

Templates implementation of JavaScript preserves the Type which can be used to parse JavaScript or JSON literals:

JSON.parse("1") //= int 1
JSON.parse("1.1") //= double 1.1
JSON.parse("'a'") //= string "a"
JSON.parse("{a:1}") //= new Dictionary<string, object> { {"a", 1 } }

It can be used to parse dynamic JSON and any primitive JavaScript data type. The inverse API of JSON.stringify() is also available.

Eval is useful if you want to execute custom JavaScript functions, or if you want to have a text DSL or scripting language for executing custom logic or business rules you want to be able to change without having to compile or redeploy your App. It uses Templates Sandbox which lets you evaluate the script within a custom scope that defines what functions and arguments it has access to, e.g:

public class CustomFilter : TemplateFilter
public string reverse(string text) => new string(text.Reverse().ToArray());

var scope = JS.CreateScope(
args: new Dictionary<string, object> { { "arg", "value"} },
functions: new CustomFilter());

JS.eval("arg", scope) //= "value"
JS.eval("reverse(arg)", scope) //= "eulav"

//= ["eulav___", "eulav___", "eulav___"]
JS.eval("itemsOf(3, padRight(reverse(arg), 8, '_'))", scope)

//= { a: ["eulav___", "eulav___", "eulav___"] }
JS.eval("{a: itemsOf(3, padRight(reverse(arg), 8, '_')) }", scope)

Simple Container

In order for Templates to be free of external dependencies and be decoupled from any one Web Framework but still retain AutoWired functionality it uses a new SimpleContainer which implements IContainer - the smallest interface we could define for a minimal but useful IOC:

public interface IContainer
Func<object> CreateFactory(Type type);

IContainer AddSingleton(Type type, Func<object> factory);

IContainer AddTransient(Type type, Func<object> factory);

object Resolve(Type type);

bool Exists(Type type);

It’s late-bound API supports registering dependencies in the 2 most useful Scopes: Singleton and Transient. Leveraging the utility of extension methods, every IOC implementing IContainer also gains the same Typed Generic API, e.g:

container.AddTransient<IFoo>(() => new Foo());
container.AddTransient<IBar>(() => new Bar());
container.AddTransient(() => new FooImpl());

container.AddSingleton(() => foo);

var foo = container.Resolve<IFoo>();
var bar = container.Resolve(typeof(IBar));

var hasFoo = container.Exists<IFoo>();

Both Funq.Container and SimpleContainer implement the IContainer interface which ServiceStack’s TemplatePagesFeature utilizes to replace the TemplateContext’s built-in IOC to use Funq where it shares the same IOC instance and is able to resolve ServiceStack’s AppHost dependencies.

Fast, small, dependency-free IOC
We’re happy to report SimpleContainer is even smaller and faster than Funq and only requires a dependency to ServiceStack.Common.dll. It supports AutoWiring, constructor and public property injection but not Funq’s other less used features like Child Containers, named dependencies and Request Scoped dependencies.

Simple AppSettings

SimpleAppSettings is an IAppSettings provider that you can use to maintain substitutable App Configuration without a dependency to ServiceStack.dll.

Virtual File System

The major change added in order for Templates to be isolated from the ServiceStack Web Framework was to decouple the Virtual File System providers from ServiceStack’s AppHost and move them to `ServiceStack.Common`.

This separation makes it easier to use VFS providers outside of ServiceStack AppHost which is a useful abstraction for copying files from different file sources as done in the copy-files project to upload files to AWS S3 or Azure Blob Storage.

Registering an additional VFS provider in AppHost’s previously required overriding `GetVirtualFileSources()`, they can now also be registered by adding them to `AddVirtualFileSources`, e.g:


VFS Breaking Change
ServiceStack App’s typically don’t create instances of VFS providers directly but all VFS provider constructors needed to be changed to remove its `IAppHost` dependency. We used the same breaking change window to also give the user-facing VFS providers better names, changing their suffixes from VirtualPathProvider to VirtualFiles, e.g:

- FileSystemVirtualFiles
- MemoryVirtualFiles
- ResourceVirtualFiles
- S3VirtualFiles
- AzureBlobVirtualFiles
- MultiVirtualFiles

The VFS providers and extension methods in ServiceStack.Common use the same `ServiceStack.IO` namespace that the VFS Interfaces are defined in where typically this would be the only change required, including using `ServiceStack.IO` if you’re using any VFS extension methods.


We’ve added deeper integration with Azure with ServiceStack.Azure - a new project containing Azure backed managed implementations for popular ServiceStack providers (as we’ve done with ServiceStack.Aws):

- ServiceBusMqServer - MQ Server for invoking ServiceStack Services via Azure ServiceBus
- AzureBlobVirtualFiles - Virtual File System provider using Azure Blob Storage
- AzureTableCacheClient - Cache Client provider using Azure Table Storage

We intend to add support for additional providers in future and make it even easier for ServiceStack Apps to be able to move freely between hosting on an Azure or an AWS managed infrastructure.

ServiceBus MQ Server
Configuring to use ServiceBus is the same as other MQ Servers, by first registering the ServiceBus IMessageService provider followed by registering all ServiceStack Services you want to be able to invoke via MQ’s:

container.Register<IMessageService>(c => new ServiceBusMqServer(ConnectionString));

var mqServer = container.Resolve<IMessageService>();

Azure Blob Storage VFS
The AzureBlobVirtualFiles VFS provider can be used to serve website content directly from an Azure Blob Storage container:

public class AppHost : AppHostBase
public override void Configure(Container container)
//Specify to use Azure Blob Container for uploading / writing files
VirtualFiles = new AzureBlobVirtualFiles(connectionString, containerName);

//Register an additional File Source for static files

Azure Table Storage Cache Client
The AzureTableCacheClient Caching provider lets you use an Azure Table for your App’s distributed caching:

container.Register<ICacheClient>(c => new

A number of internal improvements were made for making ServiceStack run better than ever on .NET Core:

Internal improvements
In preparation for .NET Core’s plans to disallow sync read / writes to Request and Responses a number of internal handlers were refactored to use async APIs when writing to the Response Stream including static files and all raw byte[], Stream responses, including HTTP Partial Content responses. Custom Results can implement the new IStreamWriterAsync and IPartialWriterAsync interfaces to return results that asynchronously writes to the Response Stream.

- ASP.NET, HttpListener and .NET Core hosts were refactored to use as much of the same code-paths as possible to ensure better consistency and code maintenance.
- The HTTP Request Pipeline was refactored to only use VFS APIs when determining static file requests resulting in more consistent behavior for all VFS sources.
- Requests to directories are automatically redirected to enforce a trailing slash, it can be disabled with Config.RedirectDirectoriesToTrailingSlashes=false.

Strict Mode
We’re adding a new Strict Mode to ServiceStack which you can use to make ServiceStack behave stricter and throw Exceptions when it sees certain failure conditions. To enable Strict Mode across all libraries use:

Env.StrictMode = true;

Otherwise to just enable StrictMode for ServiceStack:

SetConfig(new HostConfig {
StrictMode = true

When enabled ServiceStack will perform runtime checks to catch invalid state, currently:

- Checks if Services return Value Types
- Checks if UserSession has circular dependencies
- Fails fast for exceptions on Startup

In future we’ll use it to change the default mode of deserializing as much as possible without error, to fail fast when it detects an error condition. Initially it will be used in Text Serializers and OrmLite to detect mapping errors.

Content-Type Specific Service Implementations

Service implementations can now use Verb{Format} method names to provide a different implementation for handling a specific Content-Type. The Service below defines several different implementation for handling the same Request:

public class MyRequest
public string Name { get; set; }

public class ContentTypeServices : Service
// Handles all other unspecified Verbs/Formats to /my-request
public object Any(MyRequest request) => ...;

// Handles GET /my-request for JSON responses
public object GetJson(MyRequest request) => ..;

// Handles POST/PUT/DELETE/etc /my-request for HTML Responses
public object AnyHtml(MyRequest request) =>
<h1>AnyHtml {request.Name}</h1>

// Handles GET /my-request for HTML Responses
public object GetHtml(MyRequest request) =>
<h1>GetHtml {request.Name}</h1>

Redirect Paths
The RedirectPaths dictionary can be used to maintain a redirect mapping of redirect paths, e.g. we use this to redirect all requests to /metadata/ to redirect to /metadata:

SetConfig(new HostConfig {
RedirectPaths = {
{ "/metadata/", "/metadata" },

Forbidden Paths
The ForbiddenPaths can be used to prevent access to different folders in your Web Root, e.g:

SetConfig(new HostConfig {
ForbiddenPaths = {

The list of Service Implementation Assemblies specified in your AppHost constructor is available from IAppHost.ServiceAssemblies which plugins can use to enable auto-wired features, e.g. you can use ScanAppHostAssemblies in ValidationFeature to automatically register any validators defined in the Service Implementation Assemblies:

Plugins.Add(new ValidationFeature {
ScanAppHostAssemblies = true

ServiceStack Minor Features
- New Config.Metadata.GetAllDtos() metadata API to return all DTO Types
- Encrypted Messaging Requests are now marked as Secure in IRequest.RequestAttributes
- VaryByHeaders option added to [CacheResponse] attribute
- New [ExcludeMetadata] attribute as alias for [Exclude(Feature.Metadata | Feature.Soap)]

Service Clients

New `Body` and `BodyAsync` APIs have been added to all Service Clients which lets you post a separate Request Body for Request DTOs that implement `IRequiresRequestStream` where they contain both properties and a custom Request Body, e.g:

public class SendJson : IRequiresRequestStream, IReturn<string>
public string Name { get; set; }
public Stream RequestStream { get; set; }

public class SendText : IRequiresRequestStream, IReturn<string>
public string Name { get; set; }
public string ContentType { get; set; }
public Stream RequestStream { get; set; }

public class SendRawService : Service
public object Any(SendJson request) => request.RequestStream.ReadFully();

public object Any(SendText request)
base.Request.ResponseContentType = request.ContentType ?? base.Request.AcceptTypes[0];
return request.RequestStream.ReadFully();

The new APIs accept both a Request DTO which specifies which Service to call and what properties to add to the QueryString and another object to send in the raw HTTP Request Body, e.g:

var client = new JsonServiceClient(BaseUrl);

var json = client.PostBody(
new SendJson { Name = "JSON body" },
new PocoRequest { Foo = "Bar" });
json.FromJson<PocoRequest>().Foo //= Bar

json = await client.PutBodyAsync(
new SendJson { Name = "JSON body" },
json.FromJson<PocoRequest>().Foo //= Bar

var client = new JsonHttpClient(BaseUrl);
var request = new SendText { Name = "Text body", ContentType = "text/plain" };

var text = await client.PostBodyAsync(request, "foo");
text //= foo

Previously all AutoQuery Requests would execute an additional Aggregate query to return the total records available for that query. As this can be unnecessary overhead for requests that don’t need it, we’ve made it opt-in where requests that need the total can add it on the QueryString, e.g:


Or on the Request DTO:

var response = client.Get(new MyQuery { Include = "Total" });

You can restore the previous behavior and have the Total returned in every request with:

Plugins.Add(new AutoQueryFeature {
IncludeTotal = true

Native Types

User defined interfaces on Request DTOs are now being exported in the generated DTOs. It can be disabled with:

.MetadataTypesConfig.ExcludeImplementedInterfaces = true;

Open API Refinements
You can register Open API Tags by adding them to the Tags collection:

Plugins.Add(new OpenApiFeature
Tags =
new OpenApiTag
Name = "TheTag",
Description = "TheTag Description",
ExternalDocs = new OpenApiExternalDocumentation
Description = "Link to External Docs Desc",
Url = "",

- [ApiMember(IsRequired = true)] is now included in OpenApiSchema
- [ApiResponse(IsDefaultResponse = true)] can be used to specify the default Service response
- The LogoHref and LogoUrl properties can be used to customize the /swagger-ui logo
- A RequestType was added in OpenApiOperation to make it easy for filters to map Open API classes back to Services
- Added support for IReturnVoid NoContent responses

Request Logging
- Add logging for short-circuited requests terminated in Request Filters
- Allow logging of non-Service Requests, opt-in with


- Add SkipLogging delegate to control which requests should be logged

You can send MQ Request bodies using a different registered Content-Type which ServiceStack will use to deserialize into the Request DTO.

LiteDB Auth Provider
Stefan de Vogelaere from the ServiceStack Community released the ServiceStack.Authentication.LiteDB AuthProvider for LiteDB - A .NET NoSQL Document Store in a single data file.


Several enhancements were added in ServiceStack.Text to improve support for Object Dictionaries and KeyValuePair’s which are extensively used in Templates, including support in CSV, QueryStrings and AutoMapping/Conversion Utils.

String Segment Extensions
We’ve further enhanced it with several StringSegment extension methods to make it easier to work with, e.g. TryReadLine is nice for efficiently reading lines from a large string without generating any string references on the heap:

var pos = 0;
var buf = new StringSegment(fileContents);
while (buf.TryReadLine(out StringSegment line, ref pos)) {
// line

Resolve Paths
The `ResolvePaths()` extension method evaluates string paths containing directory commands, e.g:

"/a/b/../".ResolvePaths() //= /a/
"a/../b".ResolvePaths() //= b
"a/../b/./c".ResolvePaths() //= b/c


@KevinHoward added preliminary support for SQL Server JSON queries, e.g:

var results = db.Select<Table>(q => Sql.JsonValue(q.JsonColumn, "$.State") == "NV" && q.Id == 1);

Normalizing PostgreSQL
By default PostgreSQL’s dialect provider uses quoted snake_case for all Table and Column names. It can be configured to generate similar SQL as other RDBMS’s with:

PostgreSqlDialectProvider.Instance.Normalize = true;

Where it will use the default Naming strategy and only quote tables and columns using reserved words. OrmLite’s mapping is case-insensitive so will still be able to map columns as a result of PostgreSQL’s lowercase names for unquoted symbols.

Ignore properties
The new [IgnoreOnInsert] and [IgnoreOnUpdate] attributes can be used to ignore properties from INSERT’s and UPDATE’s.

- Added [Computed] attribute as a better named alias for [Compute]
- Added support for using string params larger than default string length
- The new SqlConcat, SqlCurrency, SqlBool and SqlLimit APIs can help creating cross-platform SQL, see SqlDialectTests.cs for examples.

Post has attachment
We've created a GitHub issue to help us decide on whether we should we sign all NuGet packages by default in v5?

Please vote if you have an interest on whether or not you want ServiceStack packages signed by default at:

Post has attachment
v4.5.10 Released!

We've developed new Angular4, React, Aurelia and Vue.js Single Page App VS.NET templates for ASP .NET which have been re-imagined to incorporate the latest gold standard in modern Single Page App development and integrated to provide the ideal development experience within VS.NET, optimal bundling and packaging for production including one-click Web App deployments using MS Web Deploy.

Please see the v4.5.10 Release Notes for the full details:

Full support for VS.NET 2017

We've added complete support for VS.NET 2017 with the ServiceStackVS VS.NET Extension and have migrated all ServiceStack code-bases for all of ServiceStack's NuGet packages to VS2017's new MSBuild format which is now being used to generate the different .NET 4.5 and .NET Standard platform builds used in all .NET Core packages including our multi-target Test projects.

Webpack-powered Single Page App Templates

We've developed a new Single Page App template for the simple and elegant Vue.js ( and our existing Angular, Aurelia, React and React Desktop Single Page App templates have been rewritten to completely embrace Webpack ( - the most advanced module bundler for JavaScript Apps. Webpack is used to power the development, testing and production builds of your Web App.

The release notes contains a detailed overview of Webpack and how to use it from within VS.NET and command-line which support both of Webpack's popular developer options of watching for changes and regenerating its outputs as well as Live Reload support using the Webpack Dev Server which automatically reloads the current page after processing any changes.

Single Page App Template features

The templates provide a highly productive base that's ideal for developing small to medium-sized JavaScript Web Apps including just the core essentials that pack the most productive punch whilst adding minimal complexity and required configuration, whilst still remaining open-ended to easily plug-in other tools into your Webpack configuration you believe will improve your development workflow.

With these goals in mind we've hand-picked and integrated a number of simple best-of-breed technologies so you'll be immediately productive:

- Integrated Bootstrap v4 UI framework and font-awesome Vector Icons
- Angular4 uses the more natural Material Design Lite UI framework and Design Icons
- High-level TypeScrpt and Sass support andstandard .js or .css when preferred
- End-to-end Typed APIs pre-configured with TypeScript JsonServiceClient and Server DTOs
- All templates have Routing Enabled in a Multi-page Layout
- Deep linkable Pretty URLs
- JavaScript Unit Testing
- Live Unit Testing which automatically re-runs tests when sources have changed
- Built-in Test Coverage
- Single Click Deployments using MS WebDeploy

Gistlyn Updated was upgraded to use the new Webpack-powered React Desktop Apps template.

Simple command-line utilities for ServiceStack

The new servicestack-cli ( npm package replaces our existing `ss-util.exe` and OSX `swiftref` command-line programs to provide simple command-line utilities to easily Add and Update ServiceStack References for all of ServiceStack's 7 supported languages. Using it is as easy as choosing the language you want and the BaseUrl of the remote ServiceStack instance you want to download the Server DTOs for, e.g:

$ csharp-ref

Major Memory and Performance Improvements to ServiceStack.Text

We've replaced our internal string parsing in ServiceStack.Text's serializers to use .NET Core's new `StringSegment` class (polyfilled in .NET 4.5) which dramatically reduces the memory allocations needed and execution time for deserialization. Parsing implementations of primitive .NET Types like integers, decimal and Guid types were also replaced with custom implementations utilizing `StringSegment` which sees their performance improved by 2.5-4x. These improvements are best seen in large complex types with nested arrays like MiniProfiler's DTO where memory allocations were reduced by 5.3x and performance improved by 33%.

Vulnerability with object Properties

We've resolved a vulnerability using public `object` properties on DTOs where we've needed to adopt a whitelist to limit the Types that are allowed to create instances of. Please see the release notes for full details.

Fast Reflection APIs

We've consolidated functionality for populating the fields and properties of a runtime `Type` behind a formal API which includes multiple cascading implementations so it's able to use the fastest implementation available in each supported platform, i.e. for most .NET platforms we use the Reflection.Emit implementations when possible, when not available it falls back to using Compiled Expression trees, then finally falling back to using a Reflection-based implementation.

This functionality is available using the `CreateGetter()` and `CreateSetter()` extension methods on both `PropertyInfo` or `FieldInfo` which you may find useful if you'd like to get better performance when populating runtime types dynamically, e.g:

var runtimeType = typeof(MyType);

object instance = runtimeType.CreateInstance();
PropertyInfo pi = runtimeType.GetProperty("Id");
var idSetter = pi.CreateSetter();
var idGetter = pi.CreateGetter();

idSetter(instance, 1);
var idValue = idGetter(instance);

Support for C# 7 Value Tuples in OrmLite

The fast, new C# 7 Value Tuple support in OrmLite enables an alternative terse, clean and typed API for accessing the Dynamic Result Sets returned when using a custom Select expression, e.g:

var query = db.From<Employee>()
.OrderBy(e => e.Id)
.Select<Employee, Department>(
(e, d) => new { e.Id, e.LastName, d.Name });

var results = db.Select<(int id, string lastName, string deptName)>(query);

var row = results[i];
$"row: ${}, ${row.lastName}, ${row.deptName}".Print();

Expanded Typed SqlExpresion Surface Area

OrmLite's Typed SqlExpression has been expanded to support up to 15 tables* in a single SQL Condition and up to *4 tables in a JOIN expression.

Proxy Feature

The new `ProxyFeature` plugin is an application-level proxy that can be used to transparently proxy HTTP Requests through to
downstream servers whose behavior can be customized with custom C# hooks to control how requests are proxied.

`ProxyFeature` registers an async/non-blocking `RawHttpHandler` which bypasses ServiceStack's Request Pipeline that in ASP.NET is executed as an ASP.NET `IHttpAsyncHandler` so it should be flexible and performant enough to handle many demanding workloads.

Autowired Typed Request Filters

Josh Engler contributed support for Autowired Request and Response Filters which lets you handle Request DTOs in a Typed Filter similar to how Autowired Services handles Typed Request DTOs with access to IOC injected dependencies.Refinements to Open API, Server Events, JWT

Driven by customer requests we've added support to Open API, Server Events, JWT

HTTP Caching static Files

Returning a static Virtual File or FileInfo in a `HttpResult` now sets the *Last-Modified* HTTP Response Header whose behavior instructs the pre-configured `HttpCacheFeature` to generate the necessary HTTP Headers so HTTP Clients are able to validate subsequent requests using the If-Modified-Since HTTP Request Header, allowing them to skip re-downloading files they've already cached locally.


We've changed the default behavior to no longer skipping Authenticating existing Authenticated Users. This resolves an issue for not being able to retrieve JWT Refresh Tokens if you're already Authenticated, previous behavior can be restored with:

Plugins.Add(new AuthFeature(...) {
SkipAuthenticationIfAlreadyAuthenticated = true

API Key Auth Provider

You can opt-in to allow API Keys to be passed on the *QueryString* (e.g. `?apikey={APIKEY}`) or HTTP POST *Form Data* with:

Plugins.Add(new ApiKeyAuthProvider {
AllowInHttpParams = true


The home page and directories are no longer cached in DebugMode to better be able to reflect changes during development.


The `WebServiceException` Message returns the the more appropriate `ResponseStatus.ErrorMessage` if available. The previous StatusDescription text can be retrieved from the `WebServiceException.StatusDescription` property.

Other Changes

- The `RemoveHeader()` API has been added to `IResponse` and all implementations
- The HTTP Request/Response Preview in Metadata pages uses the Verb, URL and Request Body of the preferred HTTP Method for each Service
- The Basic Auth Credentials are auto-sent in `JsonHttpClient` 401 Challenged Responses
- Empty Collections are now ignored AutoQuery Filters

That's a high-level overview, please see the v4.5.10 Release Notes for the full details:

v4.5.10 Release Notes
v4.5.10 Release Notes

Post has attachment
v4.5.8 Released!

We've got a another feature-packed release with a number of exciting new features new support for the Open API specification enabling new integration possibilities with Azure API Management and Azure AutoRest, our real-time Server Events solution extending to new Mobile, Desktop and Server platforms, more flexible Authentication options to dramatically simplify integration with Mobile, Desktop and Web clients, effortless JWT Refresh Tokens, enhanced support for TypeScript and Java client libraries, new compression options, upgrades to the latest Fluent Validation with support for Async validators, Async Request Filters, a number of new quality OSS ServiceStack projects developed by the community and lots more use-case driven features and refinements across the entire ServiceStack suite!

Please see the v4.5.8 Release Notes for the full details:

For a quick summary we'll highlight the major features below:

Open API

We've added support for the Open API Specification which opens up several new integration possibilities including importing your Services into Azure API Management and generating native clients with Azure's AutoRest. The Open API plugin also embeds Swagger UI letting you quickly explore and interact with your services.

Server Events

We've made great strides in this release towards our goal of expanding the Server Event ecosystem in popular Mobile, Desktop and Server platforms with new first-class implementations for Android, Java and TypeScript which now includes:

- C# Server Events Client
- Xamarin.iOS
- Xamarin.Android
- .NET Framework 4.5+
- .NET Core (.NET Standard 1.3+)
- TypeScript Server Events Client
- Web
- Node.js Server
- React Native
- iOS
- Android
- Java Server Events Client
- Android
- JVM 1.7+ (Java, Kotlin, Scala, etc)
- Java Clients
- Java Servers
- JavaScript (jQuery plugin)
- Web

Android Java Chat

To showcase real-world usage of `AndroidServerEventsClient` in an Android App we've ported C# Xamarin Android Chat into Java 8 using Google's recommended Android Studio Development Environment:

In addition to retaining the same functionality as the original C# Xamarin.Android Chat App, it also leverages the native Facebook, Twitter and Google SDK's to enable seamless and persistent authentication when signing in with Facebook, Twitter or Google User accounts.

Web, Node.js and React Native ServerEvents Apps

The TypeScript servicestack-client npm package is a cross-platform library enabling a rich, productive end-to-end Typed development experience on Web, node.js Server projects, node.js test suites, React Native iOS and Android Mobile Apps - written in either TypeScript or plain JavaScript.

To help getting started using servicestack-client in each of JavaScript's most popular platforms we've developed a simple Server Events Web, Node.js and React Native Mobile iOS App that can connect to any Server Events Server and listen to messages published on the subscribed channel. The App also maintains a live synchronized list of Users in the channel that's automatically updated whenever Users join or leave the channel:

Each App uses the optimal starting configuration that enables a productive workflow on each platform and uses the minimum runtime dependencies - essentially just servicestack-clientand its es6-shim and W3C `EventSource` polyfills on Node.js and React Native where it's missing a native implementation.

TypeScript servicestack-client improvements

New APIs have been added to TypeScript's servicestack-client to catch up with the additional flexibility and features available in C#/.NET Service Clients:

Sending additional arguments with Typed API Requests

Many AutoQuery Services utilize implicit conventions to query fields that aren't explicitly defined on AutoQuery Request DTOs, these can now be queried by specifying additional arguments with the typed Request DTO, e.g:

const request = new FindTechStacks();

client.get(request, { VendorName: "ServiceStack" })
.then(r => { }) // typed to QueryResponse<TechnologyStack>

Calling APIs with Custom URLs

In addition to Typed API Requests you can now also call Services using relative or absolute urls, e.g:



// GET
client.get<GetTechnologyResponse>("/technology", { Slug: "ServiceStack" })

Relaxed TypeScript Definitions

The metadata requirements in TypeScript Ambient Interface definitions generated by Add ServiceStack Reference's `/types/typescript.d` have been relaxed so they can be used to Type Object Literals:

let request:QueryContracts = { accountId: 1234 };

Authentication via OAuth AccessTokens

To improve OAuth Sign In integration from native Mobile or Desktop Apps we've added support for direct Authentication via AccessTokens which can dramatically simplify the Development and User Experience by being able to leverage the Native Facebook, Twitter and Google Client SDK's to Sign In users locally then reuse their local AccessToken to Authenticate with back-end ServiceStack Servers.

This feature is what's used to enable Integrated Facebook, Twitter and Google Logins in Android Java Chat and be able to Automatically Sign In users with saved AccessTokens.

This capability is now available on the popular OAuth Providers below:

- `FacebookAuthProvider` - Sign in with Facebook
- `TwitterAuthProvider` - Sign in with Twitter
- `GithubAuthProvider` - Sign in with Github
- `GoogleOAuth2Provider` - Sign in with Google

Client Authentication with AccessToken

Clients can utilize this feature with the new `AccessToken` and `AccessTokenSecret` properties on the existing `Authenticate` request DTO, sent with the provider that the AccessToken is for, e.g:

var response = client.Post(new Authenticate {
provider = "facebook",
AccessToken = facebookAccessToken,
RememberMe = true,

JWT Refresh Tokens

Support for Refresh Tokens is now available in the JWT Auth Provider where new JWT Tokens can now be generated from a longer-lived `RefreshToken` which can be used to fetch new JWT Tokens without needing to re-authenticate with a separate Auth Provider.

Accessing Refresh Tokens

Just like JWT Tokens, Refresh Tokens are populated on the `AuthenticateResponse` DTO after successfully authenticating via any registered Auth Provider, e.g:

var response = client.Post(new Authenticate {
provider = "credentials",
UserName = userName,
Password = password,

var jwtToken = response.BearerToken;
var refreshToken = response.RefreshToken;

Lifetimes of tokens

The default expiry time of JWT and Refresh Tokens below can be overridden when registering the `JwtAuthProvider`:

new JwtAuthProvider {
ExpireTokensIn = TimeSpan.FromDays(14), // JWT Token Expiry
ExpireRefreshTokensIn = TimeSpan.FromDays(365), // Refresh Token Expiry

Using JWT and Refresh Tokens

In order to provide the simplest development experience possible you only need to specify the Refresh Token on the Service Client and it will take care of transparently fetching a new JWT Token behind-the-scenes. You don't even need to configure the client with a JWT Token as it will just fetch a new one on first use, e.g:

var client = new JsonServiceClient(baseUrl) {
RefreshToken = refreshToken,

var response = client.Send(new Secured());

Fluent Validation Upgraded

Another major feature added in this release was contributed by the community with +Scott Mackay upgrading our internal Fluent Validation implementation to the latest version of FluentValidation. Special care was taken to maintain backwards compatibility where ServiceStack enhancements were retrofitted on top of the new version and existing Error Codes were preserved to ensure minimal disruption with existing code bases.

### Async Validators

One of the benefits from using the latest version of Fluent Validation is we now have support for Async Validators! Async validators can be registered using the `MustAsync` validator where you could simulate the following built-in Not Empty validation:

public class MyRequestValidator : AbstractValidator<MyRequest>
public MyRequestValidator()
RuleFor(x => x.Name).NotEmpty();

And replace it with an Async version that uses the Service Gateway to call a custom Async `GetStringLength` Service that returns the same `ErrorCode` and Error Message as the Not Empty validator:

public class MyRequestValidator : AbstractValidator<MyRequest>
public MyRequestValidator()
RuleFor(x => x.Name).MustAsync(async (s, token) =>
(await Gateway.SendAsync(new GetStringLength { Value = s })).Result > 0)
.WithMessage("'Name' should not be empty.")

Async Global Request Filters

To properly implement Async Validators we also needed Async Request Filters which were also added in this release where you can now register non-blocking Request Filters with:

GlobalRequestFiltersAsync.Add(async (req,res,dto) => {
var response = await client.Send(new CheckRateLimit {
Service = dto.GetType().Name,
IpAddress = req.UserHostAddress,
if (response.RateLimitExceeded)
res.StatusCode = 403;
res.StatusDescription = "RateLimitExceeded";

Enhanced Compression Options

We've followed up Request Compression added in the last release with more compression features in this release including:

[CompressResponse] Attribute

You can now selectively choose which Services should be compressed with the new `[CompressResponse]` attribute to compress responses for clients which support compression, which can be applied to most Response Types, e.g:

public class CompressedServices : Service
public object Any(CompressDto request) => new CompressExamplesResponse();
public object Any(CompressString request) => "foo";
public object Any(CompressBytes request) => "foo".ToUtf8Bytes();
public object Any(CompressStream request) => new MemoryStream("foo".ToUtf8Bytes());
public object Any(CompressFile request) => new HttpResult(VirtualFileSources.GetFile("/foo"));

public object Any(CompressAnyHttpResult request)
return new HttpResult(new CompressExamplesResponse()); // DTO
return new HttpResult("foo", "text/plain"); // string
return new HttpResult("foo".ToUtf8Bytes(), "text/plain"); // bytes

> Note using `[CompressResponse]` is unnecessary when returning cached responses as ServiceStack automatically caches and returns the most optimal Response - typically compressed bytes for clients that supports compression

Static File Compression

ServiceStack can also be configured to compress static files with specific file extensions that are larger than specific size with the new opt-in Config options below:

SetConfig(new HostConfig {
CompressFilesWithExtensions = { "js", "css" },
// (optional), only compress .js or .css files > 10k
CompressFilesLargerThanBytes = 10 * 1024

When more fine-grained logic is needed you can override `ShouldCompressFile()` in your AppHost to choose which static files you want to compress on a per-file basis, e.g:

public override bool ShouldCompressFile(IVirtualFile file)
return base.ShouldCompressFile(file) || file.Name == "large.csv";


We've been lucky to receive a number of quality contributions from the Community in this release starting with the new Serilog Logging provider contributed by +Josh Engler:


To Configure Serilog Logging, first download ServiceStack.Logging.Serilog from NuGet:

PM> Install-Package ServiceStack.Logging.Serilog

Then configure ServiceStack to use `SerilogFactory`:

LogManager.LogFactory = new SerilogFactory();

Community Projects

There's also been a number of quality OSS Community projects that's surfaced recently that you may find useful to enable in your ServiceStack projects:


If you need to implement a Webhooks solution for your Services you'll definitely want to check out ServiceStack.Webhooks +Jezz Santos. ServiceStack.Webhooks is a high-quality, actively developed, well documented solution for raising and managing application-level "events" raised by your services:


is a fork of ServiceStack.Authentication.Aad developed by +Ian Kulmatycki which provides an `AzureAuthenticationProvider` for easily authenticating users with Office365 and hybrid Azure Active Directories:


is a `UserAuthRepository` repository developed by +Michal Gajek for persisting users in Marten - a Document Database for PostgreSQL.


Another feature contributed by +Josh Engler is the `MultiAppSettingsBuilder` which adds a fluent discoverable API for configuring ServiceStack's various App Setting Providers, e.g:

AppSettings = new MultiAppSettingsBuilder()
.AddDictionarySettings(new Dictionary<string,string> { "override" : "setting" })

CacheClient with Prefix

The `CacheClientWithPrefix` class contributed by +Joël Harkes lets you decorate any `ICacheClient` to prefix all cache keys using the `.WithPrefix()` extension method. This could be used to easily enable multi-tenant usage of a single redis instance, e.g:

container.Register(c =>

OrmLite Soft Deletes

Select Filters were added to OrmLite to let you specify a custom `SelectFilter` that lets you modify queries
that use `SqlExpression<T>` before they're executed. This could be used to make working with "Soft Deletes"
Tables easier where it can be made to apply a custom `x.IsDeleted != true` condition on every `SqlExpression`.

By either using a `SelectFilter` on concrete POCO Table Types, e.g:

SqlExpression<Table1>.SelectFilter = q => q.Where(x => x.IsDeleted != true);
SqlExpression<Table2>.SelectFilter = q => q.Where(x => x.IsDeleted != true);

Or alternatively you can configure a global `SqlExpressionSelectFilter` with:

OrmLiteConfig.SqlExpressionSelectFilter = q =>
if (q.ModelDef.ModelType.HasInterface(typeof(ISoftDelete)))
q.Where<ISoftDelete>(x => x.IsDeleted != true);

Both solutions above will transparently add the `x.IsDeleted != true` to all `SqlExpression<T>` based queries so it only returns results which aren't `IsDeleted` from any of queries below:

var results = db.Select(db.From<Table>());
var result = db.Single(db.From<Table>().Where(x => x.Name == "foo"));
var result = db.Single(x => x.Name == "foo");


You can easily escape HTML Entities characters (`<`, `>`, `&`, `=`, `'`) when serializing JSON strings with:

JsConfig.EscapeHtmlChars = true;

This can also be requested by clients using Customized JSON Responses, e.g:


Rabbit MQ

A strong-named version of ServiceStack.RabbitMq is now available at:

PM> Install-Package ServiceStack.RabbitMq.Signed

The new `CreateQueueFilter` and `CreateTopicFilter` filters added to the Rabbit MQ Server will let you customize what options Rabbit MQ Queue's and topics are created with.

Startup Errors

To better highlight the presence of Startup Errors we're now adding a red warning banner in `/metadata` pages when in DebugMode.
The number of Startup Errors is also added to the `X-Startup-Errors: n` Global HTTP Header so you'll be able to notice it when debugging HTTP Traffic.

Forcing a Content Type

Whilst ServiceStack Services are typically available on any endpoint and format, there are times when you only want adhoc Services available in a particular format, for instance you may only want the View Models for your dynamic Web Views available in HTML. This can now be easily enabled with the new `[HtmlOnly]` Request Filter Attribute, e.g:

public class HtmlServices : Service
public object Any(MyRequest request) => new MyViewModel { .. };

This feature is also available for other built-in Content Types: `[JsonOnly]`, `[XmlOnly]`, `[JsvOnly]` and `[CsvOnly]`.

AuthProvider available on IAuthSession

You can now determine what Auth Provider was used to populate a User's Session with the new `IAuthSession.AuthProvider` property. This could be used for instance to detect and ensure highly-sensitive services are only available to users that authenticated using a specific Auth Provider.

All .NET Core Examples upgraded to .NET Core 1.1

All .NET Core Live examples including the redis-geo project used in Deploy .NET Core with Docker to AWS ECS Guide were upgraded to .NET Core 1.1 and has been changed to use the `microsoft/dotnet:1.1-sdk-projectjson` Docker Image since `microsoft/dotnet:latest` was changed to only support projects with VS 2017 `.csproj` msbuild format.

This covers a high-level view of the major features added in this release, please see the v4.5.8 Release Notes for the full details and other features added in this release:

- Enjoy!
v4.5.8 Release Notes
v4.5.8 Release Notes

Post has attachment
Hi All,

We've released significant updates to our TypeScript ServerEventsClient that is an idiomatic port with full feature parity with our original C# Server Events Client.

It's an isomorphic library that can be used to create either TypeScript or JavaScript client Web Apps, node.js Server Apps or React Native Mobile Apps with maximum code-reuse as seen in:

Docs for the TypeScript ServerEventsClient are also available at:
Wait while more posts are being loaded