Filter attributes

Demis Bellot edited this page Oct 25, 2016 · 24 revisions

  1. Getting Started

    1. Creating your first project
      1. Create Service from scratch
    2. Your first webservice explained
    3. Example Projects Overview
    4. Learning Resources
  2. Designing APIs

    1. ServiceStack API Design
    2. Designing a REST-ful service with ServiceStack
      1. Simple Customer REST Example
    3. How to design a Message-Based API
    4. Software complexity and role of DTOs
  3. 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. Customize JSON Responses
    11. Plugins
    12. Validation
    13. Error Handling
    14. Security
    15. Debugging
    16. JavaScript Client Library (ss-utils.js)
  4. Clients

    1. Overview
    2. C#/.NET client
      1. .NET Core Clients
    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
  5. Formats

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

    1. Razor & Markdown Razor
    2. Markdown Razor
  7. Hosts

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

    1. Authentication
    2. Sessions
    3. Restricting Services
    4. Encrypted Messaging
  9. 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 profiling
    9. Form Hijacking Prevention
    10. Auto-Mapping
    11. HTTP Utils
    12. Dump Utils
    13. Virtual File System
    14. Config API
    15. Physical Project Structure
    16. Modularizing Services
    17. MVC Integration
    18. ServiceStack Integration
    19. Embedded Native Desktop Apps
    20. Auto Batched Requests
    21. Versioning
    22. Multitenancy
  10. Caching

    1. Caching Providers
    2. HTTP Caching
      1. CacheResponse Attribute
      2. Cache Aware Clients
  11. Auto Query

    1. Overview
    2. Why Not OData
    3. AutoQuery RDBMS
    4. AutoQuery Data
      1. AutoQuery Memory
      2. AutoQuery Service
      3. AutoQuery DynamoDB
  12. Server Events

    1. Overview
    2. JavaScript Client
    3. C# Server Events Client
    4. Redis Server Events
  13. Service Gateway

    1. Overview
    2. Service Discovery
  14. Encrypted Messaging

    1. Overview
    2. Encrypted Client
  15. Plugins

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

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

    1. Install ServiceStackVS
    2. Add ServiceStack Reference
    3. TypeScript React Template
      1. React, Redux Chat App
    4. AngularJS App Template
    5. React Desktop Apps
  18. 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
  19. Amazon Web Services

    1. ServiceStack.Aws
    2. PocoDynamo
    3. AWS Live Demos
    4. Getting Started with AWS
  20. Deployment

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

    1. Redis on Windows
    2. RabbitMQ on Windows
  22. 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
  23. Performance

    1. Real world performance
  24. Other Products

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

    1. Roadmap
Clone this wiki locally

This page has moved to

ServiceStack also contains interfaces for attributes which can be executed before and after a request like request/response filters. The filter attributes are great for composing re-usable functionality as you can wrap common functionality in a Filter Attribute and selectively annotate which Services they should apply to.

For example, ServiceStack uses [Authenticate] and [RequiredPermission] filter attributes to decorate which Services should be protected with authentication or specific permissions (see Authentication and authorization).

Request Filter Attributes

You can create a Filter Attribute by implementing one of the Request or Response Filter interfaces below:

public interface IHasRequestFilter 
    void RequestFilter(IRequest req, IResponse res, object requestDto);
    int Priority { get; }      // <0 Run before global filters. >=0 Run after
    IHasRequestFilter Copy();  // Optimization: fast creation of new instances

Response Filter Attributes

If you implement this interface, the method ResponseFilter will be executed after the service was called.

public interface IHasResponseFilter 
    void ResponseFilter(IRequest req, IResponse res, object responseDto);
    int Priority { get; }      // <0 Run before global filters. >=0 Run after
    IHasResponseFilter Copy();  // Optimization: fast creation of new instances

Action Filter Attributes

Method-level filter attributes are always executed just before/after the Service, i.e. the Priority is only scoped and sorted between other method-level attributes.

Filter Attributes Example

It's recommended that you create separate attributes for each interface, but of course you can implement both interfaces in one attribute, too.

public class CustomRequestFilterAttribute : RequestFilterAttribute 
    public void RequestFilter(IRequest req, IResponse res, object requestDto)
        //This code is executed before the service
        string userAgent = req.UserAgent;
public class CustomResponseFilterAttribute : ResponseFilterAttribute 
    public void ResponseFilter(IRequest req, IResponse res, object responseDto)
        //This code is executed after the service
        res.AddHeader("Cache-Control", "max-age=3600");

As you can see, you can access the IHttpRequest, IHttpResponse and the request/response DTO. So you can change the DTO, the http response (eg status code) or look for a specific header in the http request. You can also attach any data to this request via the IHttpRequest.Items dictionary that all subsequent filters and services can access.

Example Usage

These two attributes have to be added to a request/response DTO or to the service implementation to enable them.

//Request DTO
public class User
    public string Name { get; set; }
    public string Company { get; set; }
    public int Age { get; set; }
    public int Count { get; set; }

//Response DTO
public class UserResponse : IHasResponseStatus
    public string Car { get; set; }
    public ResponseStatus ResponseStatus { get; set; }

...or if you don't want the code-first DTOs messed with attributes:

public class AspectService : Service
    public object Get(Aspect request)

That's all, now ServiceStack recognizes the attributes and executes them on every call!

Dependencies are auto-wired

Just like in Services and Validators, the filter attributes are also auto-wired, e.g:

public class CustomRequestFilterAttribute : RequestFilterAttribute
    //This property will be resolved by the IoC container
    public ICacheClient Cache { get; set; }

    public void RequestFilter(IRequest req, IResponse res, object requestDto)
        //Access the property 'Cache' here

        //This code is executed before the service
        string userAgent = req.UserAgent;

In this case the property Cache will be tried to be resolved by the IoC container.

RequestFilterAttribute base class

ServiceStack also has two base classes, which implement the above interfaces, which make it easier to create contextual filters. Contextual filters are only executed on specific HTTP verbs (GET, POST...).

public class StatisticFilterAttribute : RequestFilterAttribute
    //This property will be resolved by the IoC container
    public ICacheClient Cache { get; set; }

    public StatisticFilterAttribute() {}

    public StatisticFilterAttribute(ApplyTo applyTo)
        : base(applyTo) {}

    public override void Execute(IRequest req, IResponse res, object requestDto)
        //This code is executed before the service
        string userAgent = req.UserAgent;

The ResponseFilterAttribute base class can be used for Response Filter Attributes which works the same as RequestFilterAttribute above.

Conditionally Apply Filter Attributes

The base class RequestFilterAttribute has an empty constructor and a constructor which takes the ApplyTo flag. If the empty constructor is called, the method Execute will be called on every HTTP verb (ApplyTo.All), with the other constructor it will be called only on the configured HTTP verbs (eg ApplyTo.Get | ApplyTo.Post).

So you can use the attribute on your request DTO/service like that:

//Filter will be executed on every request

//Filter will be executed only on GET and POST requests
[StatisticFilter(ApplyTo.Get | ApplyTo.Post)]