• Data-only class
  
• Delegation
  
• Wrapper
  
• Inheritance
  
• Conversion

// Create the connection to the web service proxy

NewsService news = new NewsService();
// Set security for the web service - may not be required in all environments
news.Credentials = System.Net.CredentialCache.DefaultCredentials;
// Create the news item
NewsService.NewsItem item = news.GetItem();
// Display something from the NewsItem to prove we got the item returned
Response.Write("News item summary: "
+ item.NewsSummary
+ "<BR><BR>");

1. The shared class has to be on the web service side, not on the client. This is because the web service has no knowledge of the client but, since the client has a web reference to the web service, the client is aware of the capabilities of the web service.
   
   
   
2. The shared class must be used in the signature of a WebMethod (as a return type or as a parameter) in order for the Microsoft tools to automatically expose the class in the WSDL.
   
   
   
3. The caveat most likely to be a show stopper in a situation where this simple model would otherwise work is that you cannot by default, use the class for data binding at the client. There are third party tools and VS2003 add-ins that will create proper proxy classes but the tool shipped with VS2003,used either manually or by adding/updating web references in visual studio, is WSDL.exe. WSDL.exe creates a proxy that represents all public properties of the web service class as public fields in the proxy. Databinding in ASP.Net will not work with fields; it must be done with properties. You can manually edit the proxy class, refactoring the public fields as public properties by encapsulating the fields in properties. Just remember that any time you update the web reference, you will have to perform the edit again!

1. They're data-only. Classes represent objects and objects typically have behaviors or operations implemented as methods.
   
2. The Visual Studio tools generate proxies that cannot be used for data binding because properties are converted to fields.

// A NewsItem to return and display
public class NewsItemDelegate
{
private NewsService.NewsItem item;
private string region;

private NewsItemDelgate()
{
}

public NewsItemDelegate(NewsService.NewsItem item)
{
this.item = item;
}

public NewsService.NewsItem Item
{
get{ return item; }
set{ item = value; }
}

public string Region
{
get{ return region; }
set{ region = value; }
}

public string FormatToHtmlString()
{
return "<B>" + item.NewsSummary + "</B>";
}

}

// A NewsItem to return and display
private NewsItemDelegate nid = new NewsItemDelegate(item);
Response.Write(nid.Item.NewsDate + "<BR>");
Response.Write(nid.FormatToHtmlString());

public string NewsTitle
{
get{ return item.NewsTitle; }
set{ item.NewsTitle = value; }
}

public string NewsDate
{
get{ return item.NewsDate; }
set{ item.NewsDate = value; }
}

public string PicName
{
get{ return item.PicName; }
set{ item.PicName = value; }
}

public class ClientNewsItem : NewsService.NewsItem

[WebMethod]
public Void SaveNewsItem(NewsItem item)
{
// Code here to save a NewsItem
}

// Create the connection to the web service proxy
NewsService news = new NewsService();
// Set security for the web service - may not be required in all environments
news.Credentials = System.Net.CredentialCache.DefaultCredentials;
ClientNewsItem cni = new ClientNewsItem();

// Code here to set the properties of the ClientNewsItem, then

//Save the news item
news.SaveNewsItem(cni);

1. The NewsService.NewsItem.Reporters property is of type NewsService.Reporter[]. Therefore, in our inherited class, we only halfway achieved our goal of separation from the web service NewsItem class because ClientNewsItem still has properties in the NewsService namespace.
   
   
2. The inherited Reporters property is, by necessity when coming from a web service, an array. I don't like arrays. I like collections. I want my Reporters property to be a collection, perhaps something like a ReportersCollection (not defined in our sample code). Collections inherited from System.Collections.CollectionBase have too many great features to pass up: Indexers, methods such as IList.Add, IList.Insert, IList.Contains, IList.IndexOf, and much more. Did I mention that I like collections?
   
   
3. To solve the first two defects, you have to hide the inherited Reporters property. I don't like hiding base class members. Consumers of your class expect certain characteristics based upon the base class of your class. Altering or hiding those characteristics should not be done without good reason.

[WebMethod]
[XmlInclude(typeof(Reporter)), XmlInclude(typeof(Person))]
public NewsItemData GetItem(int newsId)
{
 // Return the NewsItemData class
 return ConvertNewsItemToData(DataLayer.GetNewsItem(newsId));
}

}

[WebMethod]
[XmlInclude(typeof(Reporter)), XmlInclude(typeof(Person))]
public NewsItemData GetItem(int newsId)
{
 // Return the NewsItemData class
 return (NewsItemData)DataLayer.GetNewsItem(newsId);
}

// Create the connection to the web service proxy
NewsService news = new NewsService();
// Set security for the web service - may not be required in all environments
news.Credentials = System.Net.CredentialCache.DefaultCredentials;
// For simplicity, I hard coded our only news item NewsId value of 1.
this.NewsItem item = (this.NewsItem)news.GetItem(1);

// Display the item using the FormatToHtmlString method.
ItemLabel.Text = item.FormatToHtmlString();

// Create the connection to the web service proxy
NewsService news =  new NewsService();
// Set security for the web service - may not be required in all environments
news.Credentials = System.Net.CredentialCache.DefaultCredentials;

// Save the NewsItem.
bool result = news.SaveItem((NewsService.NewsItemData)item);

this.NewsItem item = (this.NewsItem)news.GetItem(1);

this.NewsItem item = news.GetItem(1);

bool result = news.SaveItem((NewsService.NewsItemData)item);

bool result = news.SaveItem(item);