CODEWITHSUNDEEP
c#wcformdatasvcutil
melaos
melaos

Reputation: 8428

What's the pros and cons of using classes generated from WCF vs Creating your own model dll?

As of now, my project relies heavily on WCF which is linked to a database. we use the classes generated from the database which are ORM if you will to do processing in our system.

i know that using DataSvcUtil, we can easily extract out all the classes and compile that as a DLL to be shared across our other systems.

But in our current project, we create another DLL which mirrors the WCF generated table class rather than using those classes directly.

  1. So my question is there a best practice on these sort of things?
  2. and what's the pros and cons of these two methods?
  3. are there other methods?

thanks

Updates:

It seems like the consensus is on creating your own custom classes rather than relying on those that are created by WCF.

I am currently following this method, and as of now just using extension to create method to convert to the model and another one to convert it back to the type.

And having your own simpler class is good for extensibility and other stuff :)

Upvotes: 2

Views: 336

Answers (3)

dice
dice

Reputation: 2880

It is better to have a separate dll as you do in your current project - decoupling is a best practice, generating the WCF DataContracts from the database is almost certainly not a good idea however - it can be used for the first shot but subsequent changes to your database should not be directly reflected in the web service.

One of the advantages of using WCF is that you can easily achieve decoupling through a service layer, if you were to distribute a dll compiled in the way you describe you would essentially be coupling all clients to your database representation.

Decoupling enables your ORM / database to be tweaked as necesarry without all you clients having to re-compile.

On the con side - decoupling like this is a bit slower to implement up front - so if you have a very small project can be overkill - but if you are working cross team or in any way distributed then it is essential.

Upvotes: 0

Andrey Marchuk
Andrey Marchuk

Reputation: 13483

I would suggest to still use WCF, but use compilied dll as client instead of service reference. This way you can still have your interface consistent, even if you will decide to change database in future. The pros of using DLL:

  1. As your service will grow, users may occasionally start getting timeouts when trying to generate service reference
  2. You will be safe from people having wrong service reference. When generating service reference some properties can be changed, thus users can generate potentially dead service reference
  3. You will be protected from other IDEs generating slightly different references
  4. It's a bit easier to be backwards compatible and to pinpoint the problem as you will be 100% sure that the way client is used is the same across users.

Cons of using DLL:

  1. You will have additional reference

Upvotes: 1

ek_ny
ek_ny

Reputation: 10243

I'm not that familiar with WCF-- but I use Linq To Sql which I'm assuming generates the same types of classes (as does any ORM tool). I always create my own POCO classes which describe my domain model. I know there is a bit more work involved-- and you are then tasked with mapping your POCO classes with your generated classes. But I find it the best way to keep my domain classes pure. The generated classes can be somewhat complex with attributes describing the tables and columns which will be used to populate them. I like the generated classes because they make it easier for me to interact with the database-- but I always like the separation of having the simple domain classes-- it also gives me the flexibility to swap out database implementations.

Upvotes: 0

Related Questions