Runtime Services aren't supported in DO4, so you should implement this by your own.

Regular Domain and Session-level services are supported. If you're using default IoC container integrated into Xtensive.Core (that's the case you have by default, although they're replaceable as well), all you should do is to apply this attribute to your service type: [Service(typeof(RequestedServiceType))], where RequestedServiceType must be its base type. Our integrated IoC framework relies on two attributes:

• ServiceAttribute. As you see, by default services are singletons, byt this is overridable. If service isn't singleton, its instance is created on each new request of it.

• ServiceConstructorAttribute. It marks the constuctor we must use to create service instance. If there are arguments, they're resolved via IoC containers as well (i.e. you can consume other services from your constructor).

To get Session-level or Domain-level service, you must use the following code:

// Session-level service:
var mySessionService1 = session.Services.Get<MySessionService>(); // returns null, if there is no requested service
var mySessionService2 = session.Services.Demand<MySessionService>(); // either an object or exception; Demand is an extension method to IServiceContainer
// Domain-level service:
var myDomainService = domain.Services.Demand<MyDomainService>();

session.Services and domain.Services here is an IoC container providing these services.

Also note that:

• If you inherit your service from SessionBound (or will implement ISessionBound), you'll be able to rely on its Session member; Session activation will work for its methods as well.

• Session and SessionHandler are available as services from Session.Services IoC container. So you can use them as constructor arguments for other Session-level services.

• Domain and DomainHandler are available as services from Domain.Services IoC container. So you can use them as constructor arguments for other Domain-level services.

Some examples of intagrated Session-level services:

• DirectSqlAccessor. See an example of its usage; is is also described in Manual.

• DirectEntitySetAccessor.

All you need is background thread (or threads) performing some tasks by schedule - I'm not sure if there is anything special to DO at all...

Few hints:

• I think you should decide what kind of scheduler you need first: transactional or simple in-memory scheduler. DO39 was providing just simple scheduler, but in some cases it's a good idea to use a transactional one - e.g. when you need to execute some tasks pretty rarely, but the execution itself must be guaranteed to occur.
• The easiest way to build a transactional sceduler is to implement persistent ScheduledOperation type ;)
• Use priority queue to implement in-memory scheduling effeciently. Xtensive.Core already contains PriorityQueue implementation, documentation is here.