What I was planning to do, is creating a webmethod with one argument which
is actually a serializable class like this:

[XmlRoot("GenericMessage")]
public abstract class GenericMessage
{
 public enum Action {ADD_THIS, ADD_THAT, EDIT_ANOTHER_THING, DELETE_THIS,
ADD};
 public Action type;
 ....
}

Then it is also possible to derive other classes from this one with more
specific information about certain action and use it with the same
webmethod, e.g:

public class AddSpecialMessage : GenericMessage
{
 public string moreInfo;
 ....
}

But like you mention, this would not be so clear for an external user what
you can do with this method, but I still think it would be easier than
creating all the seperate methods, just if you want to change something to
one of the method, or add a method...

Maybe it is indeed better to create all the seperate webmethods, thanks for
the advice,

Bert

Hi Mujtaba,

I hestitated for a long time between .NET Remoting and web services,
but I thought that it is be better to choose web services with the eye on
the
future (Indigo). But it would indeed probably be better for performance to
choose .NET Remoting.
Should I start hesitating again now after reading your message?

Thanks for your advice,
Bert

Hi Steve,

I get your point and you are absolutely correct, thanks for that advice.

But just to go a little deeper into this:
Imagine that it is possible to get a customer not only by email and ID, but
also by 20 other things. Then I see two options, you can add 22 webmethods,
but you could also add 1 webmethod with 2 arguments, first an enum to
specify on which field you are selecting the customer, and secondly the
string with the email, ID or one of the 20 other fields:

public CustomerClass GetCustomerFromEmail(string emailadress);
public CustomerClass GetCustomerFromID(string id);
public CustomerClass GetCustomerFromName(string name);
public CustomerClass GetCustomerFromAddress(string address);
public CustomerClass GetCustomerFromCountry(string country);
... 22 of these methods ...

OR

public CustomerClass GetCustomer(enum field, string field);

Now, which one is preferable?

Then you could also take this a little further:
Imagine a webservice where you can not only retrieve customers, but also 20
other objects (e.g.: products, users, locations, ...). Then you can ask
yourself, if you have to add 21 webmethods, or just one webmethod with an
extra argument (= enum).

Thanks for your comments,
Bert