I apologize for the length of this message. I have tried to provide all of
the potentially relavant code up front to help identify the problem. I am
relatively new to WCF and hope that I have overlooked something relatively
simple.

I am currently developing a set of WCF (.NET 3.0) services to use as the
middle-tier of a distributed app. The services will not be publicly
available, and I have complete control over all three tiers of the
application.

Some of the services return strongly-typed DataTables for use by the UI
layer (ASP.NET 2.0) of the application. (SOA purists will object to this,
but we determined that this is the best choice for the data.) The
strongly-typed DataTables all follow the same model as the example listed
below.

The problem: I am using VisualStudio 2005 to generate a service reference
(client) class. I will be providing a wrapper class around the generated
client, compliant with my IComponentProviderListService, for consumers of the
service to use. The generated interface includes the following comment:
"Parameter 'ListEquipmentResult' requires additional schema information that
cannot be captured using the parameter mode." The specific attribute is
'System.Xml.Serialization.XmlElementAttribute'. What does this mean? How do
I resolve it? In the generated ListEquipmentResponse and
ListEquipmentResponseListEquipmentResult classes (shown below), where am I
supposed to see something that looks like a serialized DataTable that I can
deserialize?


My interface looks like this:

[ServiceContract(SessionMode=SessionMode.Required)]
public interface IComponentProviderListService
{
. . .

[OperationContract(IsInitiating = false, IsTerminating = false)]
EquipmentList ListEquipment(bool availableOnly);

. . .
}



The analogous method in the proxy looks like

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel",
"3.0.0.0")
[System.ServiceModel.ServiceContractAttribute(ConfigurationName="ComponentService.Proxy.ComponentProviderListService.IComponentProviderListService" +
"", SessionMode=System.ServiceModel.SessionMode.Required)]
public interface IComponentProviderListService
{

// CODEGEN: Parameter 'ListEquipmentResult' requires additional schema
information that cannot be captured using the parameter mode. The specific
attribute is 'System.Xml.Serialization.XmlElementAttribute'.
[System.ServiceModel.OperationContractAttribute(IsInitiating=false,
Action="http://tempuri.org/IComponentProviderListService/ListEquipment",
ReplyAction="http://tempuri.org/IComponentProviderListService/ListEquipmentResponse")]
[System.ServiceModel.XmlSerializerFormatAttribute()]
ComponentService.Proxy.ComponentProviderListService.ListEquipmentResponse
ListEquipment(ComponentService.Proxy.ComponentProviderListService.ListEquipmentRequest request);
}


The generated ListEquipmentResponse looks like

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel",
"3.0.0.0")
[System.ServiceModel.MessageContractAttribute(WrapperName="ListEquipmentResponse", WrapperNamespace="http://tempuri.org/", IsWrapped=true)]
public partial class ListEquipmentResponse
{


[System.ServiceModel.MessageBodyMemberAttribute(Namespace="http://tempuri.org/", Order=0)]
[System.Xml.Serialization.XmlElementAttribute(IsNullable=true)]
public
ComponentService.Proxy.ComponentProviderListService.ListEquipmentResponseListEquipmentResult ListEquipmentResult;

public ListEquipmentResponse()
{
}

public
ListEquipmentResponse(ComponentService.Proxy.ComponentProviderListService.ListEquipmentResponseListEquipmentResult ListEquipmentResult)
{
this.ListEquipmentResult = ListEquipmentResult;
}
}


The generated ListEquipmentResponseListEquipmentResult looks like

[System.CodeDom.Compiler.GeneratedCodeAttribute("svcutil", "3.0.4506.30")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true,
Namespace="http://tempuri.org/")]
public partial class ListEquipmentResponseListEquipmentResult
{

private System.Xml.XmlElement[] anyField;
private System.Xml.XmlElement any1Field;
private string namespaceField;
private string tableTypeNameField;

public ListEquipmentResponseListEquipmentResult()
{
this.namespaceField = "Components.DataStructures";
this.tableTypeNameField = "EquipmentList";
}



[System.Xml.Serialization.XmlAnyElementAttribute(Namespace="http://www.w3.org/2001/XMLSchema", Order=0)]
public System.Xml.XmlElement[] Any
{
get{return this.anyField;}
set{this.anyField = value;}
}


[System.Xml.Serialization.XmlAnyElementAttribute(Namespace="urn:schemas-microsoft-com:xml-diffgram-v1", Order=1)]
public System.Xml.XmlElement Any1
{
get{return this.any1Field;}
set{this.any1Field = value;}
}

[System.Xml.Serialization.XmlAttributeAttribute()]
public string @namespace
{
get{return this.namespaceField;}
set{this.namespaceField = value;}
}

[System.Xml.Serialization.XmlAttributeAttribute()]
public string tableTypeName
{
get{return this.tableTypeNameField;}
set{this.tableTypeNameField = value;}
}
}


The EquipmentList (strongly typed DataTable class)


[XmlSchemaProvider("GetSchema")]
[Serializable]
public class EquipmentList : DataTable, IXmlSerializable, IEnumerable
{
private static string _tableName = "EquipmentList";
private static string _namespace = "Components.DataStructures";
private static XmlSchema _schema;

// Private DataColumn variables declared and initialized here

public EquipmentList():base(_tableName, _namespace)
{
this.TableName = _tableName;
this.BeginInit();
Initialize();
this.EndInit();
}

protected EquipmentList(string tableName, string nameSpace) :
base(tableName, nameSpace)
{
this.TableName = _tableName;
this.BeginInit();
Initialize();
this.EndInit();
}

public int Count
{
get{return this.Rows.Count;}
}

// Misc. methods for adding and retrieving strongly typed rows omitted
// Properties to expose DataColumns omitted

private void Initialize()
{
// Set DataColumn properties and add them to base.Columns collection

if (_schema == null)
{
GetTableSchema();
_schema.Id = _tableName;
}
}

Steven,

Thank you for your reply. I had already implemented the first two steps you
recommend (the strongly typed DataTables in their own library and referencing
that library in the service and proxy projects). Between my posting the
question and your reply today, I had experimented with some different
attributes and seemed to get closer to what I needed. I am hopeful that the
additional information you provided about the proxy generation will get me
the rest of the way there. I will post the final solution here, assuming I
get it to work, or will report that something is still amiss.

It would be useful to have a reference available somewhwere (KB on the
Microsoft site) with an explanation of all messages that the code generation
tools can produce, including their causes and resolutions. That might have
saved the need to post anything here at all.

Thank You

[quoted text, click to view]