This question is more of a probe to discover what people are doing in the community, in practical situations, than a specifically targeted question. I have searched pretty broadly about this, and while I have found a lot of bloggers advocating contract-first service design and some comments backing them up, I have yet to find much practical information about implementing contract-first with WCF, the pros and cons of doing so in a real-world environment, etc. I have recently done some extensive research into SOA, primarily through Thomas Erl's books, and one of the primary concepts he advocates is contract-first design.
My questions are as follows:
One of the major problems with contract-first development seems to be tooling. Svcutil is the only thing I have found that can generate service code from a contract, and it has some pretty poor output. Its single-file, chock full of attributes and code-generation artifacts, and it basically needs to be regenerated and replaced any time the contract is updated. I would prefer a better approach, preferably something that doesn't require regen-replace. I'm fine with manually creating the service-side contract even, assuming it is practical in a real-world scenario.
EDIT:
While WCSF solved my immediate needs, learning about Protocol Buffers and Service Factory are both intriguing tools that I am sure will help me in the future.
WCF has five types of contracts: service contract, operation contract, data contract, message contract and fault contract.
In the Contract First approach, development of the service is started from a WSDL definition, which becomes a contract between the service provider and the client. In this approach, WSDL definition is defined using Web services standards and the service implementation is done after that according to this contract.
wscf.blue:This Visual Studio add-in is the latest version of thinktecture's "contract first" development tool.
The service contract specifies what operations the service supports. An operation can be thought of as a Web service method. You create service contracts by defining a C# or Visual Basic interface.
WSCF provides a contract-first tool with VS integration. Checkitout. (free)
As of July 6th, there's a binary release with a setup program.
I use a contract-first approach, generally (but not always) using the same type representation at each end.
Actually, to use WCF you don't need any special proxies etc; you can use your regular .NET types at both ends and not use svcutil.exe
at all. Getting a working service is as simple as adding the "ABC" into the configuration file, and using something like:
public sealed class WcfClient<T> : System.ServiceModel.ClientBase<T>
where T : class
{
public T Service { get { return base.Channel; } }
}
Now you can use:
using(var client = new WcfClient<IMyService>()) {
int i = client.Service.SomeMethod("abc");
}
and all you have at the client (and server) is your IMyService
interface.
For other tools; protobuf-net is an implementation of Google's "protocol buffers" API, which has a DSL for describing data and services in a "contract first" (and portable/interoperable) way - for example (a .proto file):
message SearchRequest {
required string query = 1;
optional int32 page_number = 2;
optional int32 result_per_page = 3;
}
message SearchResponse {
repeated string result = 1;
}
service SearchService {
rpc Search (SearchRequest) returns (SearchResponse);
}
The protobuf-net tool (which I maintain) includes a "protogen" utility to transform this DSL into C#/VB; and one of the options (for C#, at least - I'd need to check VB) is to emit a full WCF proxy implementation (with your choice of sync or async methods); very similar to svcutil - but (due to the protobuf-net relationship) it includes the custom [ProtoBehavior]
attribute on the operation-contracts so that it uses the protobuf-net serializer instead of DataContractSerializer
(faster and more efficient, but different).
For VS integration; I'm working on exactly that (proof).
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With