Skip to content


Subversion checkout URL

You can clone with
Download ZIP


Demis Bellot edited this page · 34 revisions

  1. Getting Started

    1. Creating your first project
      1. Create Service from scratch
    2. Your first webservice explained
    3. ServiceStack's new API Design
    4. Designing a REST-ful service with ServiceStack
    5. Example Projects Overview
    6. Learning Resources
  2. Reference

    1. Order of Operations
    2. The IoC container
    3. Configuration and AppSettings
    4. Metadata page
    5. Rest, SOAP & default endpoints
    6. SOAP support
    7. Routing
    8. Service return types
    9. Customize HTTP Responses
    10. Plugins
    11. Validation
    12. Error Handling
    13. Security
    14. Debugging
    15. JavaScript Client Library (ss-utils.js)
  3. Clients

    1. Overview
    2. C#/.NET client
    3. Add ServiceStack Reference
      1. C# Add Reference
      2. F# Add Reference
      3. VB.NET Add Reference
      4. Swift Add Reference
      5. Java Add Reference
    4. Silverlight client
    5. JavaScript client
      1. Add TypeScript Reference
    6. Dart Client
    7. MQ Clients
  4. Formats

    1. Overview
    2. JSON/JSV and XML
    3. ServiceStack's new HTML5 Report Format
    4. ServiceStack's new CSV Format
    5. MessagePack Format
    6. ProtoBuf Format
  5. View Engines

    1. Razor & Markdown Razor
    2. Markdown Razor
  6. Hosts

    1. IIS
    2. Self-hosting
    3. Messaging
    4. Mono
  7. Security

    1. Authentication/authorization
    2. Sessions
    3. Restricting Services
    4. Encrypted Messaging
  8. Advanced

    1. Configuration options
    2. Access HTTP specific features in services
    3. Logging
    4. Serialization/deserialization
    5. Request/response filters
    6. Filter attributes
    7. Concurrency Model
    8. Built-in caching options
    9. Built-in profiling
    10. Form Hijacking Prevention
    11. Auto-Mapping
    12. HTTP Utils
    13. Virtual File System
    14. Config API
    15. Physical Project Structure
    16. Modularizing Services
    17. ServiceStack Integration
    18. Embedded Native Desktop Apps
    19. Auto Batched Requests
    20. Versioning
  9. Server Events

    1. Overview
    2. JavaScript Client
    3. C# Server Events Client
    4. Redis Server Events
  10. Encrypted Messaging

    1. Overview
    2. Encrypted Client
  11. Plugins

    1. Auto Query
    2. Server Sent Events
    3. Swagger API
    4. Postman
    5. Request logger
    6. Sitemaps
    7. Cancellable Requests
    8. CorsFeature
  12. Tests

    1. Testing
    2. HowTo write unit/integration tests
  13. ServiceStackVS

    1. Install ServiceStackVS
    2. Add ServiceStack Reference
    3. AngularJS App Template
    4. ReactJS App Template
  14. Other Languages

    1. FSharp
      1. Add ServiceStack Reference
    2. VB.NET
      1. Add ServiceStack Reference
    3. Swift
      1. Swift Add Reference
    4. Java
      1. Add ServiceStack Reference
      2. Android Studio & IntelliJ
      3. Eclipse
  15. Deployment

    1. Deploy Multiple Sites to single AWS Instance
      1. Simple Deployments to AWS with WebDeploy
    2. Advanced Deployments with OctopusDeploy
  16. Install 3rd Party Products

    1. Redis on Windows
    2. RabbitMQ on Windows
  17. Use Cases

    1. Single Page Apps
      1. HTML, CSS and JS Minifiers
    2. Azure
      1. Connecting to Azure Redis via SSL
    3. Logging
    4. Bundling and Minification
    5. NHibernate
  18. Performance

    1. Real world performance
  19. Other Products

    1. ServiceStack.Redis
    2. ServiceStack.OrmLite
    3. ServiceStack.Text
  20. Future

    1. Roadmap
Clone this wiki locally


As caching is an essential technology in the development of high-performance web services, Service Stack has a number of different caching options available that each share the same common client interface (ICacheClient) for the following cache providers:

  • Redis - A very fast key-value store that has non-volatile persistent storage and support for rich data structures such as lists and sets.
  • OrmLiteCacheClient - Supports all OrmLite's RDBMS providers for using an existing RDBMS as a distributed cache.
  • Memcached - The tried and tested most widely used cache provider.
  • In Memory Cache - Useful for single host web services and enabling unit tests to run without needing access to a cache server.
  • Azure Cache Client - For using the Azure DataCache client when your application is hosted on Azure.
  • Aws Cache Client - For using with Amazon's Dynamo DB backend hosted on Amazon Web Services

To configure which cache should be used, the particular client has to be registered in the IoC container:

In-memory cache:

container.Register<ICacheClient>(new MemoryCacheClient());
NuGet Package: ServiceStack


container.Register<IRedisClientsManager>(c => 
    new PooledRedisClientManager("localhost:6379"));

container.Register(c => c.Resolve<IRedisClientsManager>().GetCacheClient());
NuGet Package: ServiceStack.Redis


//Register OrmLite Db Factory if not already
container.Register<IDbConnectionFactory>(c => 
    new OrmLiteConnectionFactory(connString, SqlServerDialect.Provider)); 

container.RegisterAs<OrmLiteCacheClient, ICacheClient>();

//Create 'CacheEntry' RDBMS table if it doesn't exist already
NuGet Package: ServiceStack.Server


    new MemcachedClientCache(new[] { "" }); //Add Memcached hosts
NuGet Package: ServiceStack.Caching.Memcached


    new AzureCacheClient("MyAppCache")); //Add your Azure CacheName if any
NuGet Package: ServiceStack.Caching.Azure

Cache a response of a service

To cache a response you simply have to call ToOptimizedResultUsingCache which is an extension method existing in ServiceStack.ServiceHost.

In your service:

public class OrdersService : Service
    public object Get(CachedOrders request)
        var cacheKey = "unique_key_for_this_request";
        return base.Request.ToOptimizedResultUsingCache(base.Cache,cacheKey,()=> 
                //Delegate is executed if item doesn't exist in cache 
                //Any response DTO returned here will be cached automatically

Tip: There exists a class named UrnId which provides helper methods to create unique keys for an object.

ToOptimizedResultUsingCache also has an overload which provides a parameter to set the timespan when the cache should be deleted (marked as expired). If now a client calls the same service method a second time and the cache expired, the provided delegate, which returns the response DTO, will be executed a second time.

var cacheKey = "some_unique_key";
//Cache should be deleted in 1h
var expireInTimespan = new TimeSpan(1, 0, 0);
return base.Request.ToOptimizedResultUsingCache(
    base.Cache, cacheKey, expireInTimespan, ...)

Delete cached responses

If now for example an order gets updated and the order was cached before the update, the webservice will still return the same result, because the cache doesn't know that the order has been updated.

So there are two options:

  • Use time based caching (and expire cache earlier)
  • Cache on validility

When the cache is based on validility the caches are invalidated manually (e.g. when a user modified his profile, > clear his cache) which means you always get the latest version and you never need to hit the database again to rehydrate the cache if it hasn't changed, which will save resources.

So if the order gets updated, you should delete the cache manually:

public class CachedOrdersService : Service
    public object Put(CachedOrders request)
        //The order gets updated...
        var cacheKey = "some_unique_key_for_order";
        return base.Request.RemoveFromCache(base.Cache, cacheKey);

If now the client calls the webservice to request the order, he'll get the latest version.

Live Example and code

A live demo of the ICacheClient is available in The ServiceStack.Northwind's example project. Here are some requests to cached services:

Which are simply existing web services wrapped using ICacheClient that are contained in CachedServices.cs

Something went wrong with that request. Please try again.