/// <summary>
/// Generate a DPWSClientProxy source file from a wsdl service description.
/// </summary>
/// <param name="serviceDesc">A valid wsdl service description.</param>
public void GenerateClientProxy(ServiceDescription serviceDesc, TargetPlatform platform)
{
// Well here's a nasty used in an attempt to make up a name
string clientProxyClassName = serviceDesc.Name;
string clientProxyNs = CodeGenUtils.GenerateDotNetNamespace(serviceDesc.TargetNamespace);
string filename = serviceDesc.Name + "ClientProxy.cs";
ClientProxies clientProxies = new ClientProxies(clientProxyNs);
foreach (PortType portType in serviceDesc.PortTypes)
{
ClientProxy clientProxy = new ClientProxy(portType.Name, platform);
foreach (Operation operation in portType.Operations)
{
// Create action names
// Apply special naming rules if this is a notification (event) operation
string inAction = serviceDesc.TargetNamespace + "/" + operation.Name + "Request";
string outAction = serviceDesc.TargetNamespace + "/" + operation.Name + ((operation.Messages.Flow == OperationFlow.Notification) ? "" : "Response");
clientProxy.AddOperation(operation, inAction, outAction);
}
foreach (Message message in serviceDesc.Messages)
{
clientProxy.Messages.Add(message);
}
if (clientProxy.ServiceOperations.Count > 0)
clientProxies.Add(clientProxy);
}
ClientProxyGenerator clientProxyGen = new ClientProxyGenerator();
clientProxyGen.GenerateCode(filename, clientProxies);
}
/// <summary>
/// Returns true if this code generator can generate a member for the
/// specified source property type.
/// </summary>
/// <remarks>The base method checks for DataContract serializability. If derived classes
/// override, they must be able to generate additional properties in
/// <see cref="GenerateNonSerializableProperty" />.</remarks>
/// <param name="propertyDescriptor">The source property.</param>
/// <returns>true if this code generator should/can generate a member for the Type.</returns>
protected virtual bool CanGenerateProperty(PropertyDescriptor propertyDescriptor)
{
Type type = propertyDescriptor.PropertyType;
// Make sure the member is serializable (based on data contract attributes, [Exclude], type support, etc.).
if (SerializationUtility.IsSerializableDataMember(propertyDescriptor))
{
// If property type is an enum that cannot be generated, we cannot expose this property, but only log a warning
string errorMessage = null;
Type enumType = TypeUtility.GetNonNullableType(type);
if (enumType.IsEnum)
{
if (!ClientProxyGenerator.CanExposeEnumType(enumType, out errorMessage))
{
ClientProxyGenerator.LogWarning(String.Format(CultureInfo.CurrentCulture, Resource.ClientCodeGen_Property_Enum_Error, Type, propertyDescriptor.Name, enumType.FullName, errorMessage));
return(false);
}
else
{
return(true);
}
}
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Users the shared types service to determine whether the given property is shared.
/// </summary>
/// <remarks>Derived classes can override this to insert extra behavior.</remarks>
/// <param name="pd">The property descriptor that could be shared.</param>
/// <returns>Returns true if the property is shared.</returns>
protected virtual bool IsPropertyShared(PropertyDescriptor pd)
{
// If this property is visible to the client already because of partial types,
// do not generate it again, or we will get a compile error
CodeMemberShareKind shareKind = ClientProxyGenerator.GetPropertyShareKind(Type, pd.Name);
return((shareKind & CodeMemberShareKind.Shared) != 0);
}
public virtual TChannel CreateChannel(System.ServiceModel.EndpointAddress address, Uri via)
{
#if FULL_AOT_RUNTIME
throw new InvalidOperationException("MonoTouch does not support dynamic proxy code generation. Override this method or its caller to return specific client proxy instance");
#else
var existing = Endpoint.Address;
try
{
Endpoint.Address = address;
EnsureOpened();
#if DISABLE_REAL_PROXY
Type type = ClientProxyGenerator.CreateProxyType(typeof(TChannel), Endpoint.Contract, false);
// in .NET and SL2, it seems that the proxy is RealProxy.
// But since there is no remoting in SL2 (and we have
// no special magic), we have to use different approach
// that should work either.
var proxy = (IClientChannel)Activator.CreateInstance(type, new object [] { Endpoint, this, address ?? Endpoint.Address, via });
#else
var proxy = (System.ServiceModel.IClientChannel) new ClientRealProxy(typeof(TChannel), new ClientRuntimeChannel(Endpoint, this, address ?? Endpoint.Address, via), false).GetTransparentProxy();
#endif
proxy.Opened += delegate {
OpenedChannels.Add(proxy);
};
proxy.Closing += delegate {
OpenedChannels.Remove(proxy);
};
return((TChannel)proxy);
}
catch (System.Reflection.TargetInvocationException ex)
{
if (ex.InnerException != null)
{
throw ex.InnerException;
}
else
{
throw;
}
}
finally
{
Endpoint.Address = existing;
}
#endif
}
/// <summary>
/// Generate a DPWSClientProxy source file from a wsdl service description.
/// </summary>
/// <param name="serviceDesc">A valid wsdl service description.</param>
public void GenerateClientProxy(ServiceDescription serviceDesc, TargetPlatform platform)
{
// Well here's a nasty used in an attempt to make up a name
string clientProxyClassName = serviceDesc.Name;
string clientProxyNs = CodeGenUtils.GenerateDotNetNamespace(serviceDesc.TargetNamespace);
string filename = serviceDesc.Name + "ClientProxy.cs";
ClientProxies clientProxies = new ClientProxies(clientProxyNs);
string ns = serviceDesc.TargetNamespace.Trim();
if (!ns.EndsWith("/"))
{
ns += "/";
}
foreach (PortType portType in serviceDesc.PortTypes)
{
ClientProxy clientProxy = new ClientProxy(portType.Name, platform);
foreach (Operation operation in portType.Operations)
{
// Create action names
// Apply special naming rules if this is a notification (event) operation
string inAction = ns + operation.Name + "Request";
string outAction = ns + operation.Name + ((operation.Messages.Flow == OperationFlow.Notification) ? "" : "Response");
clientProxy.AddOperation(operation, inAction, outAction);
}
foreach (Message message in serviceDesc.Messages)
{
clientProxy.Messages.Add(message);
}
if (clientProxy.ServiceOperations.Count > 0)
{
clientProxies.Add(clientProxy);
}
}
ClientProxyGenerator clientProxyGen = new ClientProxyGenerator();
clientProxyGen.GenerateCode(filename, clientProxies);
}
/// <summary>
/// CreateSourceFiles - Parse Wsdl Schema and generate DataContract, DataContractSerializer types,
/// HostedServices and Client Proxies.
/// </summary>
/// <remarks>Currently only generates C# source files.</remarks>
/// <param name="contractFilename">The name of a contract source code (.cs) file.</param>
/// <param name="hostedServiceFilename">The name of a hosted service source code (.cs) file.</param>
/// <param name="clientProxyFilename">The name of a client proxy source code (.cs) file.</param>
/// <param name="targetPlatform">Specifies the target runtime platform.</param>
public void CreateSourceFiles(string contractFilename, string hostedServiceFilename, string clientProxyFilename, TargetPlatform targetPlatform)
{
m_platform = targetPlatform;
Logger.WriteLine("", LogLevel.Normal);
Logger.WriteLine("Generating contract source: " + contractFilename + "...", LogLevel.Normal);
if (contractFilename == null)
throw new ArgumentNullException("codeFilename", "You must pass a valid code filename.");
if (m_svcDesc.Types == null)
{
throw new Exception("No wsdl types found.");
}
string path = Path.GetDirectoryName(contractFilename).Trim();
if(!string.IsNullOrEmpty(path) && !Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
// Create code file stream
FileStream dcStream = new FileStream(contractFilename, FileMode.Create, FileAccess.Write, FileShare.None);
StreamWriter dcStreamWriter = new StreamWriter(dcStream);
// Write the auto generated header
dcStreamWriter.Write(AutoGenTextHeader.Message);
try
{
// Set up data contract code generator
CSharpCodeProvider cSharpCP = new CSharpCodeProvider();
ICodeGenerator codeGen = cSharpCP.CreateGenerator(dcStreamWriter);
CodeGeneratorOptions codeGenOptions = new CodeGeneratorOptions();
codeGenOptions.BracingStyle = "C";
// Cobble up a valid .net namespace. Turn any progression that's not a-z or A-Z to a single '.'
string targetNamespaceName = CodeGenUtils.GenerateDotNetNamespace(m_svcDesc.TargetNamespace);
// For some reason we have to force schemas to compile. Though it was suppose to automatically. Huh!
foreach (XmlSchema schema in m_svcDesc.Types.Schemas)
{
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add(schema);
schemaSet.Compile();
}
// Create new code namespace
CodeNamespace targetNamespace = new CodeNamespace(targetNamespaceName);
// Add data contract using directives
CodeSnippetCompileUnit compileUnit = new CodeSnippetCompileUnit("using System;");
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using System.Xml;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
if (m_platform == TargetPlatform.MicroFramework)
{
compileUnit.Value = "using System.Ext;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using System.Ext.Xml;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
}
compileUnit.Value = "using Ws.ServiceModel;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using Ws.Services.Mtom;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using Ws.Services.Serialization;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using XmlElement = Ws.Services.Xml.WsXmlNode;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using XmlAttribute = Ws.Services.Xml.WsXmlAttribute;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using XmlConvert = Ws.Services.Serialization.WsXmlConvert;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Namespaces.Add(targetNamespace);
m_dcCodeGen.CodeNamespaces = compileUnit.Namespaces;
Logger.WriteLine("", LogLevel.Normal);
// Create HostedServices and ClientProxies collections
HostedServices hostedServices = new HostedServices(targetNamespaceName);
ClientProxies clientProxies = new ClientProxies(targetNamespaceName);
// For each PortType process
foreach (PortType portType in m_svcDesc.PortTypes)
{
// For each operation in the port type:
// Get input and output message parts.
// If the message part is a simple type:
// Build HostedService operation.
// Else if the message part is an element:
// Find elements in Schema
// If element type is native xml type:
// Build HostedService operation.
// Else if element references a simple or complex type:
// If simpleType is base xml type with restrictions:
// Build HostedService operation.
// Else
// Build DataContract and DataContractSerializer.
// Build HostedService Operation.
//
if (!CodeGenUtils.IsSoapBinding(portType, m_svcDesc))
{
continue;
}
// Create instance of a HostedService to hold the port type details
HostedService hostedService = new HostedService(portType.Name, m_svcDesc.TargetNamespace, m_platform);
// Create instance of ClientProxyGenerator
ClientProxy clientProxy = new ClientProxy(portType.Name, m_platform);
// Create service contract interface
CodeTypeDeclaration serviceCodeType = new CodeTypeDeclaration("I" + portType.Name);
CodeAttributeArgument codeAttr = new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(m_svcDesc.TargetNamespace));
CodeAttributeDeclaration codeAttrDecl = new CodeAttributeDeclaration("ServiceContract", codeAttr);
serviceCodeType.CustomAttributes.Add(codeAttrDecl);
// Check for Policy assertions. If found add policy assertion attributes. Policy assertion attributes
// are required to regenerate policy assertions when converting a service to Wsdl.
List<PolicyAssertion> policyAssertions = GetPolicyAssertions();
bool OptimizedMimeEncoded = false;
foreach (PolicyAssertion assert in policyAssertions)
{
serviceCodeType.CustomAttributes.Add(CreatePolicyAssertions(assert.Name, assert.Namespace.ToString(), assert.PolicyID));
// if Optimized Mime assertion id found set a processing flag
if (assert.Name == "OptimizedMimeSerialization")
{
OptimizedMimeEncoded = true;
}
}
// Add type declaration
serviceCodeType.TypeAttributes = TypeAttributes.Public;
serviceCodeType.IsInterface = true;
// Create service contract callback client interface
CodeTypeDeclaration serviceCallbackCodeType = new CodeTypeDeclaration("I" + portType.Name + "Callback");
// Add type declaration
serviceCallbackCodeType.TypeAttributes = TypeAttributes.Public;
serviceCallbackCodeType.IsInterface = true;
// If the binding contains a ref to Mtom encoding type set the Mtom flag
if (OptimizedMimeEncoded)
{
m_dcCodeGen.EncodingType = MessageEncodingType.Mtom;
hostedService.EncodingType = MessageEncodingType.Mtom;
clientProxy.EncodingType = MessageEncodingType.Mtom;
}
// Step through port operations, get method names and parse elements.
for (int pt_index = 0; pt_index < portType.Operations.Count; ++pt_index)
{
Operation operation = portType.Operations[pt_index];
string operationName = operation.Name;
string inputMessageName = null;
string outputMessageName = null;
MessagePartCollection inputMessageParts = null;
MessagePartCollection outputMessageParts = null;
string inAction = null;
string outAction = null;
GetAction(portType, operation, m_svcDesc.TargetNamespace, ref inAction, ref outAction);
// Oneway request port type
if (operation.Messages.Flow == OperationFlow.OneWay)
{
OperationInput input = operation.Messages.Input;
inputMessageName = input.Message.Name;
// Add operation for HostedService code generation
hostedService.AddOperation(operation, inAction, outAction);
// Add method for ClientProxy code generation
clientProxy.AddOperation(operation, inAction, outAction);
}
// Twoway request/response pattern
else if (operation.Messages.Flow == OperationFlow.RequestResponse)
{
OperationInput input = operation.Messages.Input;
inputMessageName = input.Message.Name;
OperationOutput output = operation.Messages.Output;
outputMessageName = output.Message.Name;
// Add operation for HostedService code generation
hostedService.AddOperation(operation, inAction, outAction);
// Add method for ClientProxy code generation
clientProxy.AddOperation(operation, inAction, outAction);
}
// Event pattern
else if (operation.Messages.Flow == OperationFlow.Notification)
{
OperationOutput output = operation.Messages.Output;
outputMessageName = output.Message.Name;
// Add operation for HostedService code generation
hostedService.AddOperation(operation, inAction, outAction);
// Add method for ClientProxy code generation
clientProxy.AddOperation(operation, inAction, outAction);
}
// Find input and output message parts collection in messages collection
// and store for later.
foreach (Message message in m_svcDesc.Messages)
{
if (inputMessageName != null)
if (message.Name == inputMessageName)
{
inputMessageParts = message.Parts;
// Add operation for HostedService code generation
hostedService.Messages.Add(message);
// Add Message to ClientProxy generator for later
clientProxy.Messages.Add(message);
}
if (outputMessageName != null)
if (message.Name == outputMessageName)
{
outputMessageParts = message.Parts;
// Add operation for HostedService code generation
hostedService.Messages.Add(message);
// Add Message to ClientProxy generator for later
clientProxy.Messages.Add(message);
}
}
try
{
// Try to generate Data Contracts and DataContractSerializers
GenerateTypeContracts(operation, inputMessageParts, outputMessageParts);
// If operation flow is notification (event) add OperationContract to ServiceContractCallback
// else add OperationContract to ServiceContract
if (operation.Messages.Flow == OperationFlow.Notification)
{
AddServiceOperationToInterface(operation, outAction, serviceCallbackCodeType);
}
else
AddServiceOperationToInterface(operation, inAction, serviceCodeType);
}
catch (Exception e)
{
dcStreamWriter.Close();
File.Delete(contractFilename);
Logger.WriteLine("Failed to generate service code. " + e.Message, LogLevel.Normal);
return;
}
}
// Add serviceCodeType Service Contract interface to namespace
// A serviceCodeType is added even if the wsdl only contains notifications. In that case
// the contract will be empty but the ServiceContract attribute and CallbackContract argument
// will be used to point to the notification or callback contract interace
targetNamespace.Types.Add(serviceCodeType);
// If service contract callback type contains members add callback contract to namespace
// and add CallbackContract reference attribute to serviceCodeType contract.
if (serviceCallbackCodeType.Members.Count > 0)
{
// Add the callback argument to the service description attribute
CodeAttributeArgument callbackArg = new CodeAttributeArgument("CallbackContract",
new CodeTypeOfExpression(serviceCallbackCodeType.Name)
);
serviceCodeType.CustomAttributes[0].Arguments.Add(callbackArg);
// Add the callback interface to namespace
targetNamespace.Types.Add(serviceCallbackCodeType);
}
// If the hosted service has opeations add to Hosted Services collection for Code Gen
if (hostedService.ServiceOperations.Count > 0)
hostedServices.Add(hostedService);
// If the client Proxy service has opeations add to client proxy collection for Code Gen
if (clientProxy.ServiceOperations.Count > 0)
clientProxies.Add(clientProxy);
}
// MOD: 12-02-08 Added code to handle multiple type namespaces
// Generate contract source file
foreach (CodeNamespace codeNamespace in compileUnit.Namespaces)
{
codeGen.GenerateCodeFromNamespace(codeNamespace, dcStreamWriter, codeGenOptions);
}
dcStreamWriter.Flush();
dcStreamWriter.Close();
// Generate Hosted Service code
Logger.WriteLine("Generating Hosted Service source: " + hostedServiceFilename + "...", LogLevel.Normal);
HostedServiceGenerator hsGen = new HostedServiceGenerator();
hsGen.GenerateCode(hostedServiceFilename, hostedServices);
// Generate Client proxy code
Logger.WriteLine("Generating Client Proxy source: " + clientProxyFilename + "...", LogLevel.Normal);
ClientProxyGenerator cpGen = new ClientProxyGenerator();
cpGen.GenerateCode(clientProxyFilename, clientProxies);
}
catch (Exception e)
{
dcStreamWriter.Close();
File.Delete(contractFilename);
Logger.WriteLine("Failed to generate service code. " + e.Message, LogLevel.Normal);
throw new Exception("Failed to generate service code. ", e);
}
}
/// <summary>
/// CreateSourceFiles - Parse Wsdl Schema and generate DataContract, DataContractSerializer types,
/// HostedServices and Client Proxies.
/// </summary>
/// <remarks>Currently only generates C# source files.</remarks>
/// <param name="contractFilename">The name of a contract source code (.cs) file.</param>
/// <param name="hostedServiceFilename">The name of a hosted service source code (.cs) file.</param>
/// <param name="clientProxyFilename">The name of a client proxy source code (.cs) file.</param>
/// <param name="targetPlatform">Specifies the target runtime platform.</param>
public void CreateSourceFiles(string contractFilename, string hostedServiceFilename, string clientProxyFilename, TargetPlatform targetPlatform)
{
m_platform = targetPlatform;
Logger.WriteLine("", LogLevel.Normal);
Logger.WriteLine("Generating contract source: " + contractFilename + "...", LogLevel.Normal);
if (contractFilename == null)
{
throw new ArgumentNullException("codeFilename", "You must pass a valid code filename.");
}
if (m_svcDesc.Types == null)
{
throw new Exception("No wsdl types found.");
}
string path = Path.GetDirectoryName(contractFilename).Trim();
if (!string.IsNullOrEmpty(path) && !Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
// Create code file stream
FileStream dcStream = new FileStream(contractFilename, FileMode.Create, FileAccess.Write, FileShare.None);
StreamWriter dcStreamWriter = new StreamWriter(dcStream);
// Write the auto generated header
dcStreamWriter.Write(AutoGenTextHeader.Message);
try
{
// Set up data contract code generator
CSharpCodeProvider cSharpCP = new CSharpCodeProvider();
ICodeGenerator codeGen = cSharpCP.CreateGenerator(dcStreamWriter);
CodeGeneratorOptions codeGenOptions = new CodeGeneratorOptions();
codeGenOptions.BracingStyle = "C";
// Cobble up a valid .net namespace. Turn any progression that's not a-z or A-Z to a single '.'
string targetNamespaceName = CodeGenUtils.GenerateDotNetNamespace(m_svcDesc.TargetNamespace);
// For some reason we have to force schemas to compile. Though it was suppose to automatically. Huh!
foreach (XmlSchema schema in m_svcDesc.Types.Schemas)
{
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add(schema);
schemaSet.Compile();
}
// Create new code namespace
CodeNamespace targetNamespace = new CodeNamespace(targetNamespaceName);
// Add data contract using directives
CodeSnippetCompileUnit compileUnit = new CodeSnippetCompileUnit("using System;");
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using System.Xml;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
if (m_platform == TargetPlatform.MicroFramework)
{
compileUnit.Value = "using System.Ext;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using System.Ext.Xml;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
}
compileUnit.Value = "using Ws.ServiceModel;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using Ws.Services.Mtom;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using Ws.Services.Serialization;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using XmlElement = Ws.Services.Xml.WsXmlNode;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using XmlAttribute = Ws.Services.Xml.WsXmlAttribute;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "using XmlConvert = Ws.Services.Serialization.WsXmlConvert;";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Value = "";
codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
compileUnit.Namespaces.Add(targetNamespace);
m_dcCodeGen.CodeNamespaces = compileUnit.Namespaces;
Logger.WriteLine("", LogLevel.Normal);
// Create HostedServices and ClientProxies collections
HostedServices hostedServices = new HostedServices(targetNamespaceName);
ClientProxies clientProxies = new ClientProxies(targetNamespaceName);
// For each PortType process
foreach (PortType portType in m_svcDesc.PortTypes)
{
// For each operation in the port type:
// Get input and output message parts.
// If the message part is a simple type:
// Build HostedService operation.
// Else if the message part is an element:
// Find elements in Schema
// If element type is native xml type:
// Build HostedService operation.
// Else if element references a simple or complex type:
// If simpleType is base xml type with restrictions:
// Build HostedService operation.
// Else
// Build DataContract and DataContractSerializer.
// Build HostedService Operation.
//
// Create instance of a HostedService to hold the port type details
HostedService hostedService = new HostedService(portType.Name, m_svcDesc.TargetNamespace, m_platform);
// Create instance of ClientProxyGenerator
ClientProxy clientProxy = new ClientProxy(portType.Name, m_platform);
// Create service contract interface
CodeTypeDeclaration serviceCodeType = new CodeTypeDeclaration("I" + portType.Name);
CodeAttributeArgument codeAttr = new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(m_svcDesc.TargetNamespace));
CodeAttributeDeclaration codeAttrDecl = new CodeAttributeDeclaration("ServiceContract", codeAttr);
serviceCodeType.CustomAttributes.Add(codeAttrDecl);
// Check for Policy assertions. If found add policy assertion attributes. Policy assertion attributes
// are required to regenerate policy assertions when converting a service to Wsdl.
List <PolicyAssertion> policyAssertions = GetPolicyAssertions();
bool OptimizedMimeEncoded = false;
foreach (PolicyAssertion assert in policyAssertions)
{
serviceCodeType.CustomAttributes.Add(CreatePolicyAssertions(assert.Name, assert.Namespace.ToString(), assert.PolicyID));
// if Optimized Mime assertion id found set a processing flag
if (assert.Name == "OptimizedMimeSerialization")
{
OptimizedMimeEncoded = true;
}
}
// Add type declaration
serviceCodeType.TypeAttributes = TypeAttributes.Public;
serviceCodeType.IsInterface = true;
// Create service contract callback client interface
CodeTypeDeclaration serviceCallbackCodeType = new CodeTypeDeclaration("I" + portType.Name + "Callback");
// Add type declaration
serviceCallbackCodeType.TypeAttributes = TypeAttributes.Public;
serviceCallbackCodeType.IsInterface = true;
// If the binding contains a ref to Mtom encoding type set the Mtom flag
if (OptimizedMimeEncoded)
{
m_dcCodeGen.EncodingType = MessageEncodingType.Mtom;
hostedService.EncodingType = MessageEncodingType.Mtom;
clientProxy.EncodingType = MessageEncodingType.Mtom;
}
// Step through port operations, get method names and parse elements.
for (int pt_index = 0; pt_index < portType.Operations.Count; ++pt_index)
{
Operation operation = portType.Operations[pt_index];
string operationName = operation.Name;
string inputMessageName = null;
string outputMessageName = null;
MessagePartCollection inputMessageParts = null;
MessagePartCollection outputMessageParts = null;
string inAction = null;
string outAction = null;
GetAction(portType, operation, m_svcDesc.TargetNamespace, ref inAction, ref outAction);
// Oneway request port type
if (operation.Messages.Flow == OperationFlow.OneWay)
{
OperationInput input = operation.Messages.Input;
inputMessageName = input.Message.Name;
// Add operation for HostedService code generation
hostedService.AddOperation(operation, inAction, outAction);
// Add method for ClientProxy code generation
clientProxy.AddOperation(operation, inAction, outAction);
}
// Twoway request/response pattern
else if (operation.Messages.Flow == OperationFlow.RequestResponse)
{
OperationInput input = operation.Messages.Input;
inputMessageName = input.Message.Name;
OperationOutput output = operation.Messages.Output;
outputMessageName = output.Message.Name;
// Add operation for HostedService code generation
hostedService.AddOperation(operation, inAction, outAction);
// Add method for ClientProxy code generation
clientProxy.AddOperation(operation, inAction, outAction);
}
// Event pattern
else if (operation.Messages.Flow == OperationFlow.Notification)
{
OperationOutput output = operation.Messages.Output;
outputMessageName = output.Message.Name;
// Add operation for HostedService code generation
hostedService.AddOperation(operation, inAction, outAction);
// Add method for ClientProxy code generation
clientProxy.AddOperation(operation, inAction, outAction);
}
// Find input and output message parts collection in messages collection
// and store for later.
foreach (Message message in m_svcDesc.Messages)
{
if (inputMessageName != null)
{
if (message.Name == inputMessageName)
{
inputMessageParts = message.Parts;
// Add operation for HostedService code generation
hostedService.Messages.Add(message);
// Add Message to ClientProxy generator for later
clientProxy.Messages.Add(message);
}
}
if (outputMessageName != null)
{
if (message.Name == outputMessageName)
{
outputMessageParts = message.Parts;
// Add operation for HostedService code generation
hostedService.Messages.Add(message);
// Add Message to ClientProxy generator for later
clientProxy.Messages.Add(message);
}
}
}
try
{
// Try to generate Data Contracts and DataContractSerializers
GenerateTypeContracts(operation, inputMessageParts, outputMessageParts);
// If operation flow is notification (event) add OperationContract to ServiceContractCallback
// else add OperationContract to ServiceContract
if (operation.Messages.Flow == OperationFlow.Notification)
{
AddServiceOperationToInterface(operation, outAction, serviceCallbackCodeType);
}
else
{
AddServiceOperationToInterface(operation, inAction, serviceCodeType);
}
}
catch (Exception e)
{
dcStreamWriter.Close();
File.Delete(contractFilename);
Logger.WriteLine("Failed to generate service code. " + e.Message, LogLevel.Normal);
return;
}
}
// Add serviceCodeType Service Contract interface to namespace
// A serviceCodeType is added even if the wsdl only contains notifications. In that case
// the contract will be empty but the ServiceContract attribute and CallbackContract argument
// will be used to point to the notification or callback contract interace
targetNamespace.Types.Add(serviceCodeType);
// If service contract callback type contains members add callback contract to namespace
// and add CallbackContract reference attribute to serviceCodeType contract.
if (serviceCallbackCodeType.Members.Count > 0)
{
// Add the callback argument to the service description attribute
CodeAttributeArgument callbackArg = new CodeAttributeArgument("CallbackContract",
new CodeTypeOfExpression(serviceCallbackCodeType.Name)
);
serviceCodeType.CustomAttributes[0].Arguments.Add(callbackArg);
// Add the callback interface to namespace
targetNamespace.Types.Add(serviceCallbackCodeType);
}
// If the hosted service has opeations add to Hosted Services collection for Code Gen
if (hostedService.ServiceOperations.Count > 0)
{
hostedServices.Add(hostedService);
}
// If the client Proxy service has opeations add to client proxy collection for Code Gen
if (clientProxy.ServiceOperations.Count > 0)
{
clientProxies.Add(clientProxy);
}
}
// MOD: 12-02-08 Added code to handle multiple type namespaces
// Generate contract source file
foreach (CodeNamespace codeNamespace in compileUnit.Namespaces)
{
codeGen.GenerateCodeFromNamespace(codeNamespace, dcStreamWriter, codeGenOptions);
}
dcStreamWriter.Flush();
dcStreamWriter.Close();
// Generate Hosted Service code
Logger.WriteLine("Generating Hosted Service source: " + hostedServiceFilename + "...", LogLevel.Normal);
HostedServiceGenerator hsGen = new HostedServiceGenerator();
hsGen.GenerateCode(hostedServiceFilename, hostedServices);
// Generate Client proxy code
Logger.WriteLine("Generating Client Proxy source: " + clientProxyFilename + "...", LogLevel.Normal);
ClientProxyGenerator cpGen = new ClientProxyGenerator();
cpGen.GenerateCode(clientProxyFilename, clientProxies);
}
catch (Exception e)
{
dcStreamWriter.Close();
File.Delete(contractFilename);
Logger.WriteLine("Failed to generate service code. " + e.Message, LogLevel.Normal);
throw new Exception("Failed to generate service code. ", e);
}
}
/// <summary>
/// Generates the client proxy code for the given type.
/// </summary>
public override void Generate()
{
// ----------------------------------------------------------------
// namespace
// ----------------------------------------------------------------
var ns = ClientProxyGenerator.GetOrGenNamespace(Type);
// Missing namespace bails out of code-gen -- error has been logged
if (ns == null)
{
return;
}
// ----------------------------------------------------------------
// public partial class {Type} : (Base)
// ----------------------------------------------------------------
ProxyClass = CodeGenUtilities.CreateTypeDeclaration(Type);
ProxyClass.IsPartial = true; // makes this a partial type
ProxyClass.TypeAttributes = TypeAttributes.Public;
// Abstract classes must be preserved as abstract to avoid explicit instantiation on client
bool isAbstract = (Type.IsAbstract);
if (isAbstract)
{
ProxyClass.TypeAttributes |= TypeAttributes.Abstract;
}
// Determine all types derived from this one.
// Note this list does not assume the current type is the visible root. That is a separate test.
IEnumerable <Type> derivedTypes = GetDerivedTypes();
// If this type doesn't have any derivatives, seal it. Cannot seal abstracts.
if (!isAbstract && !derivedTypes.Any())
{
ProxyClass.TypeAttributes |= TypeAttributes.Sealed;
}
// Add all base types including interfaces
AddBaseTypes(ns);
ns.Types.Add(ProxyClass);
AttributeCollection typeAttributes = Type.Attributes();
// Add <summary> xml comment to class
string comment = GetSummaryComment();
ProxyClass.Comments.AddRange(CodeGenUtilities.GenerateSummaryCodeComment(comment, ClientProxyGenerator.IsCSharp));
// ----------------------------------------------------------------
// Add default ctr
// ----------------------------------------------------------------
CodeConstructor constructor = new CodeConstructor();
// Default ctor is public for concrete types but protected for abstracts.
// This prevents direct instantiation on client
constructor.Attributes = isAbstract ? MemberAttributes.Family : MemberAttributes.Public;
// add default ctor doc comments
comment = string.Format(CultureInfo.CurrentCulture, Resource.CodeGen_Default_Constructor_Summary_Comments, Type.Name);
constructor.Comments.AddRange(CodeGenUtilities.GenerateSummaryCodeComment(comment, ClientProxyGenerator.IsCSharp));
// add call to default OnCreated method
constructor.Statements.Add(NotificationMethodGen.OnCreatedMethodInvokeExpression);
ProxyClass.Members.Add(constructor);
// ----------------------------------------------------------------
// [KnownType(...), ...]
// ----------------------------------------------------------------
// We need to generate a [KnownType] for all derived entities on the visible root.
if (!IsDerivedType)
{
// Generate a [KnownType] for every derived type.
// We specifically exclude [KnownTypes] from the set of attributes we ask
// the metadata pipeline to generate below, meaning we take total control
// here for which [KnownType] attributes get through the metadata pipeline.
//
// Note, we sort in alphabetic order to give predictability in baselines and
// client readability. For cosmetic reasons, we sort by short or long name
// depending on what our utility helpers will actually generated
foreach (Type derivedType in derivedTypes.OrderBy(t => ClientProxyGenerator.ClientProxyCodeGenerationOptions.UseFullTypeNames ? t.FullName : t.Name))
{
CodeAttributeDeclaration knownTypeAttrib = CodeGenUtilities.CreateAttributeDeclaration(typeof(System.Runtime.Serialization.KnownTypeAttribute), ClientProxyGenerator, ProxyClass);
knownTypeAttrib.Arguments.Add(new CodeAttributeArgument(new CodeTypeOfExpression(CodeGenUtilities.GetTypeReference(derivedType, ClientProxyGenerator, ProxyClass))));
ProxyClass.CustomAttributes.Add(knownTypeAttrib);
}
}
ValidateTypeAttributes(typeAttributes);
// ----------------------------------------------------------------
// [DataContract(Namespace=X, Name=Y)]
// ----------------------------------------------------------------
CodeAttributeDeclaration dataContractAttrib = CodeGenUtilities.CreateDataContractAttributeDeclaration(Type, ClientProxyGenerator, ProxyClass);
ProxyClass.CustomAttributes.Add(dataContractAttrib);
// ----------------------------------------------------------------
// Propagate all type-level Attributes across (except DataContractAttribute since that is handled above)
// -----------------------------------------------------------------
CustomAttributeGenerator.GenerateCustomAttributes(
ClientProxyGenerator,
ProxyClass,
ex => string.Format(CultureInfo.CurrentCulture, Resource.ClientCodeGen_Attribute_ThrewException_CodeType, ex.Message, ProxyClass.Name, ex.InnerException.Message),
FilterTypeAttributes(typeAttributes),
ProxyClass.CustomAttributes,
ProxyClass.Comments);
// ----------------------------------------------------------------
// gen proxy getter/setter for each property
// ----------------------------------------------------------------
GenerateProperties();
// ----------------------------------------------------------------
// gen additional methods/events
// ----------------------------------------------------------------
GenerateAdditionalMembers();
// Register created CodeTypeDeclaration with mapping
_typeMapping[Type] = ProxyClass;
}
/// <summary>
/// Generates all of the properties for the type.
/// </summary>
private void GenerateProperties()
{
IEnumerable <PropertyDescriptor> properties = TypeDescriptor.GetProperties(Type)
.Cast <PropertyDescriptor>()
.OrderBy(p => p.Name);
foreach (PropertyDescriptor pd in properties)
{
if (!ShouldDeclareProperty(pd))
{
continue;
}
// Generate a property getter/setter pair for every property whose type
// we support. Non supported property types will be skipped.
if (CanGenerateProperty(pd))
{
// Ensure the property is not virtual, abstract or new
// If there is a violation, we log the error and keep
// running to accumulate all such errors. This function
// may return an "okay" for non-error case polymorphics.
if (!CanGeneratePropertyIfPolymorphic(pd))
{
continue;
}
if (!GenerateNonSerializableProperty(pd))
{
Type propType = CodeGenUtilities.TranslateType(pd.PropertyType);
List <Type> typesToCodeGen = new List <Type>();
bool isTypeSafeToGenerate = true;
// Create a list containing the types we will require on the client
if (TypeUtility.IsPredefinedDictionaryType(propType))
{
typesToCodeGen.AddRange(CodeGenUtilities.GetDictionaryGenericArgumentTypes(propType));
}
else
{
typesToCodeGen.Add(TypeUtility.GetElementType(propType));
}
// We consider all predefined types as legal to code-gen *except* those
// that would generate a compile error on the client due to missing reference.
// We treat "don't know" and "false" as grounds for a warning.
// Note that we do this *after* TranslateType so that types like System.Data.Linq.Binary
// which cannot exist on the client anyway has been translated
foreach (Type type in typesToCodeGen)
{
// Enum (and nullable<enum>) types may require generation on client
Type nonNullableType = TypeUtility.GetNonNullableType(type);
if (nonNullableType.IsEnum)
{
// Register use of this enum type, which could cause deferred generation
ClientProxyGenerator.RegisterUseOfEnumType(nonNullableType);
}
// If this is not an enum or nullable<enum> and we're not generating the complex type, determine whether this
// property type is visible to the client. If it is not, log a warning.
else
{
// "Don't know" counts as "no"
CodeMemberShareKind enumShareKind = this.ClientProxyGenerator.GetTypeShareKind(nonNullableType);
if ((enumShareKind & CodeMemberShareKind.Shared) == 0)
{
this.ClientProxyGenerator.LogWarning(string.Format(CultureInfo.CurrentCulture, Resource.ClientCodeGen_PropertyType_Not_Shared, pd.Name, this.Type.FullName, type.FullName, this.ClientProxyGenerator.ClientProjectName));
isTypeSafeToGenerate = false; // Flag error but continue to allow accumulation of additional errors.
}
}
}
if (isTypeSafeToGenerate)
{
// Generate OnMethodXxxChanging/Changed partial methods.
// Note: the parameter type reference needs to handle the possibility the
// property type is defined in the project's root namespace and that VB prepends
// that namespace. The utility helper gives us the right type reference.
CodeTypeReference parameterTypeRef =
CodeGenUtilities.GetTypeReference(propType, ClientProxyGenerator, ProxyClass);
NotificationMethodGen.AddMethodFor(pd.Name + "Changing", new CodeParameterDeclarationExpression(parameterTypeRef, "value"), null);
NotificationMethodGen.AddMethodFor(pd.Name + "Changed", null);
GenerateProperty(pd);
}
}
}
else
{
OnPropertySkipped(pd);
}
}
}
