Question

We have a WCF REST service that connects to a database. In fact, we have several instances of the database, all with the same schema.

We would like to set up one endpoint for each database instance and associate a connection string with the endpoint. The service would read the connection string and connect to the appropriate SQL Server instance.

I’m sure this is possible; is it a good idea? How do I set it up? Is there documentation on MSDN?

Edit: I found this question, where the answer suggests adding connection information on the client in a header. I don’t want to do that—for security reasons, and because I do want to have a distinct uri for each database.

Answer 1

This was a bit harder than I thought. WCF has so many extensibility points its hard to pick the right one. Please answer or comment if you think there’s a better way, or anything wrong with this.

I’ve settled on using a custom class that implements IEndpointBehavior and IDispatchMessageInspector. I have a class derived from BehaviorExtensionElement that lets me associate the behavior with an endpoint in configuration. This blog post describes hot do do that.

My DatabaseConnectionContext class looks like this:

/// <summary>
/// An endpoint behavior that associates a database connection string name with the endpoint and adds it to the
/// properties of incoming messages.
/// </summary>
public class DatabaseConnectionContext : IEndpointBehavior, IDispatchMessageInspector
{
    /// <summary>
    /// Initializes a new instance of the <see cref="DatabaseConnectionContext"/> class with the provided connection string name.
    /// </summary>
    /// <param name="connectionStringName">The name of the connection string to associate with the endpoint.</param>
    public DatabaseConnectionContext(string connectionStringName)
    {
        this.ConnectionStringName = connectionStringName;
    }

    /// <summary>
    /// Gets the name of the connection string to associate with the endpoint.
    /// </summary>
    public string ConnectionStringName { get; private set; }

    /// <inheritdoc />
    public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
    {
    }

    /// <inheritdoc />
    public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
    {
        throw new NotImplementedException();
    }

    /// <inheritdoc />
    public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
    {
        endpointDispatcher.DispatchRuntime.MessageInspectors.Add(this);
    }

    /// <inheritdoc />
    public void Validate(ServiceEndpoint endpoint)
    {
    }

    /// <inheritdoc />
    public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
    {
        request.Properties["connectionStringName"] = this.ConnectionStringName;
        return null;
    }

    /// <inheritdoc />
    public void BeforeSendReply(ref Message reply, object correlationState)
    {
    }
}

In my service class I have this method:

    /// <summary>
    /// Returns the connection string to use for this service call.
    /// </summary>
    /// <returns>A SQL Server database connection string.</returns>
    private string GetConnectionString()
    {
        string connectionStringName = (string)OperationContext.Current.IncomingMessageProperties["connectionStringName"];
        return ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
    }

My BehaviorExtensionElement class looks like this:

/// <summary>
/// Associates a <see cref="DatabaseConnectionContext"/> with an endpoint in configuration.
/// </summary>
public class DatabaseConnectionContextBehaviorExtension : BehaviorExtensionElement
{
    /// <summary>
    /// The name of the <see cref="ConnectionStringName"/> property when it appears in a configuration file.
    /// </summary>
    private const string ConnectionStringNamePropertyName = "connectionStringName";

    /// <summary>
    /// Gets or sets the name of the configuration string to associate with the endpoint.
    /// </summary>
    [ConfigurationProperty(ConnectionStringNamePropertyName)]
    public string ConnectionStringName
    {
        get
        {
            return (string)this[ConnectionStringNamePropertyName];
        }

        set
        {
            this[ConnectionStringNamePropertyName] = value;
        }
    }

    /// <inheritdoc />
    public override Type BehaviorType
    {
        get { return typeof(DatabaseConnectionContext); }
    }

    /// <inheritdoc />
    protected override object CreateBehavior()
    {
        return new DatabaseConnectionContext(this.ConnectionStringName);
    }
}

My web.config contains something like this:

<behaviors>

  <endpointBehaviors>
    <behavior name="DevRestEndpointConfiguration">
      <webHttp helpEnabled="false" />
      <connectionStringInterceptor connectionStringName="myDevConnectionStringName" />
    </behavior>
    <behavior name="ProductionRestEndpointConfiguration">
      <webHttp helpEnabled="false" />
      <connectionStringInterceptor connectionStringName="myProductionConnectionStringName" />
    </behavior>
  </endpointBehaviors>

</behaviors>

<extensions>
  <behaviorExtensions>
    <add name="connectionStringInterceptor" type="DatabaseConnectionContextBehaviorExtension, MyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
  </behaviorExtensions>
</extensions>

Each <endpoint /> element in the <services /> section has its behaviorConfiguration set to the name of an appropriate element from the <endpointBehaviors /> section.