//<snippet1>
private void Run()
{
WSHttpBinding b = new WSHttpBinding(SecurityMode.Message);
Uri baseAddress = new Uri("http://localhost:1066/calculator");
ServiceHost sh = new ServiceHost(typeof(Calculator), baseAddress);
sh.AddServiceEndpoint(typeof(ICalculator), b, "");
// Find the ContractDescription of the operation to find.
ContractDescription cd = sh.Description.Endpoints[0].Contract;
OperationDescription myOperationDescription = cd.Operations.Find("Add");
// Find the serializer behavior.
XmlSerializerOperationBehavior serializerBehavior =
myOperationDescription.Behaviors.
Find <XmlSerializerOperationBehavior>();
// If the serializer is not found, create one and add it.
if (serializerBehavior == null)
{
serializerBehavior = new XmlSerializerOperationBehavior(myOperationDescription);
myOperationDescription.Behaviors.Add(serializerBehavior);
}
// Change style of the serialize attribute.
serializerBehavior.XmlSerializerFormatAttribute.Style = OperationFormatStyle.Document;
sh.Open();
Console.WriteLine("Listening");
Console.ReadLine();
sh.Close();
}
private List <Type> CollectXmlSerializerTypes(Assembly assembly, List <XmlMapping> mappings)
{
List <Type> types = new List <Type>();
ExportModule.ContractLoader contractLoader = new ExportModule.ContractLoader(new Assembly[] { assembly }, _isTypeExcluded);
contractLoader.ContractLoadErrorCallback = delegate(Type contractType, string errorMessage)
{
ToolConsole.WriteWarning(SR.Format(SR.WrnUnableToLoadContractForSGen, contractType, errorMessage));
};
foreach (ContractDescription contract in contractLoader.GetContracts())
{
types.Add(contract.ContractType);
foreach (OperationDescription operation in contract.Operations)
{
XmlSerializerOperationBehavior behavior = operation.Behaviors.Find <XmlSerializerOperationBehavior>();
if (behavior != null)
{
foreach (XmlMapping map in behavior.GetXmlMappings())
{
mappings.Add(map);
}
}
}
}
return(types);
}
void FixupProxyBehavior()
{
ClientOperation operation = null;
if (useXmlSerializer)
{
XmlSerializerOperationBehavior.AddBehaviors(contractDescription);
}
foreach (OperationDescription opDesc in contractDescription.Operations)
{
operation = serviceChannelFactory.ClientRuntime.Operations[opDesc.Name];
operation.SerializeRequest = true;
operation.DeserializeReply = true;
if (useXmlSerializer)
{
operation.Formatter = XmlSerializerOperationBehavior.CreateOperationFormatter(opDesc);
}
else
{
operation.Formatter = new DataContractSerializerOperationFormatter(opDesc, TypeLoader.DefaultDataContractFormatAttribute, null);
}
}
}
static void FillBehaviorInfo(IOperationBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
{
Fx.Assert(null != existingInstance, "");
Fx.Assert(null != behavior, "");
instance = null;
if (behavior is DataContractSerializerOperationBehavior)
{
instance = existingInstance.NewInstance("DataContractSerializerOperationBehavior");
DataContractSerializerOperationBehavior specificBehavior = (DataContractSerializerOperationBehavior)behavior;
instance.SetProperty(AdministrationStrings.IgnoreExtensionDataObject, specificBehavior.IgnoreExtensionDataObject);
instance.SetProperty(AdministrationStrings.MaxItemsInObjectGraph, specificBehavior.MaxItemsInObjectGraph);
if (null != specificBehavior.DataContractFormatAttribute)
{
instance.SetProperty(AdministrationStrings.Style, specificBehavior.DataContractFormatAttribute.Style.ToString());
}
}
else if (behavior is OperationBehaviorAttribute)
{
instance = existingInstance.NewInstance("OperationBehaviorAttribute");
OperationBehaviorAttribute specificBehavior = (OperationBehaviorAttribute)behavior;
instance.SetProperty(AdministrationStrings.AutoDisposeParameters, specificBehavior.AutoDisposeParameters);
instance.SetProperty(AdministrationStrings.Impersonation, specificBehavior.Impersonation.ToString());
instance.SetProperty(AdministrationStrings.ReleaseInstanceMode, specificBehavior.ReleaseInstanceMode.ToString());
instance.SetProperty(AdministrationStrings.TransactionAutoComplete, specificBehavior.TransactionAutoComplete);
instance.SetProperty(AdministrationStrings.TransactionScopeRequired, specificBehavior.TransactionScopeRequired);
}
else if (behavior is TransactionFlowAttribute)
{
instance = existingInstance.NewInstance("TransactionFlowAttribute");
TransactionFlowAttribute specificBehavior = (TransactionFlowAttribute)behavior;
instance.SetProperty(AdministrationStrings.TransactionFlowOption, specificBehavior.Transactions.ToString());
}
else if (behavior is XmlSerializerOperationBehavior)
{
instance = existingInstance.NewInstance("XmlSerializerOperationBehavior");
XmlSerializerOperationBehavior specificBehavior = (XmlSerializerOperationBehavior)behavior;
if (null != specificBehavior.XmlSerializerFormatAttribute)
{
instance.SetProperty(AdministrationStrings.Style, specificBehavior.XmlSerializerFormatAttribute.Style.ToString());
instance.SetProperty(AdministrationStrings.Use, specificBehavior.XmlSerializerFormatAttribute.Use.ToString());
instance.SetProperty(AdministrationStrings.SupportFaults, specificBehavior.XmlSerializerFormatAttribute.SupportFaults.ToString());
}
}
else if (behavior is IWmiInstanceProvider)
{
IWmiInstanceProvider instanceProvider = (IWmiInstanceProvider)behavior;
instance = existingInstance.NewInstance(instanceProvider.GetInstanceType());
instanceProvider.FillInstance(instance);
}
else
{
instance = existingInstance.NewInstance("Behavior");
}
if (null != instance)
{
instance.SetProperty(AdministrationStrings.Type, behavior.GetType().FullName);
}
}
private static void FillBehaviorInfo(IOperationBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance)
{
instance = null;
if (behavior is DataContractSerializerOperationBehavior)
{
instance = existingInstance.NewInstance("DataContractSerializerOperationBehavior");
DataContractSerializerOperationBehavior behavior2 = (DataContractSerializerOperationBehavior)behavior;
instance.SetProperty("IgnoreExtensionDataObject", behavior2.IgnoreExtensionDataObject);
instance.SetProperty("MaxItemsInObjectGraph", behavior2.MaxItemsInObjectGraph);
if (behavior2.DataContractFormatAttribute != null)
{
instance.SetProperty("Style", behavior2.DataContractFormatAttribute.Style.ToString());
}
}
else if (behavior is OperationBehaviorAttribute)
{
instance = existingInstance.NewInstance("OperationBehaviorAttribute");
OperationBehaviorAttribute attribute = (OperationBehaviorAttribute)behavior;
instance.SetProperty("AutoDisposeParameters", attribute.AutoDisposeParameters);
instance.SetProperty("Impersonation", attribute.Impersonation.ToString());
instance.SetProperty("ReleaseInstanceMode", attribute.ReleaseInstanceMode.ToString());
instance.SetProperty("TransactionAutoComplete", attribute.TransactionAutoComplete);
instance.SetProperty("TransactionScopeRequired", attribute.TransactionScopeRequired);
}
else if (behavior is TransactionFlowAttribute)
{
instance = existingInstance.NewInstance("TransactionFlowAttribute");
TransactionFlowAttribute attribute2 = (TransactionFlowAttribute)behavior;
instance.SetProperty("TransactionFlowOption", attribute2.Transactions.ToString());
}
else if (behavior is XmlSerializerOperationBehavior)
{
instance = existingInstance.NewInstance("XmlSerializerOperationBehavior");
XmlSerializerOperationBehavior behavior3 = (XmlSerializerOperationBehavior)behavior;
if (behavior3.XmlSerializerFormatAttribute != null)
{
instance.SetProperty("Style", behavior3.XmlSerializerFormatAttribute.Style.ToString());
instance.SetProperty("Use", behavior3.XmlSerializerFormatAttribute.Use.ToString());
instance.SetProperty("SupportFaults", behavior3.XmlSerializerFormatAttribute.SupportFaults.ToString());
}
}
else if (behavior is IWmiInstanceProvider)
{
IWmiInstanceProvider provider = (IWmiInstanceProvider)behavior;
instance = existingInstance.NewInstance(provider.GetInstanceType());
provider.FillInstance(instance);
}
else
{
instance = existingInstance.NewInstance("Behavior");
}
if (instance != null)
{
instance.SetProperty("Type", behavior.GetType().FullName);
}
}
private static void ValidateOperationDescription(OperationDescription operation)
{
Fx.Assert(operation != null, "The 'operationDescription' parameter should not be null.");
// Ensure no operations with XmlSerializer Rpc style
XmlSerializerOperationBehavior xmlSerializerOperationBehavior = operation.Behaviors.Find <XmlSerializerOperationBehavior>();
if (xmlSerializerOperationBehavior != null &&
(xmlSerializerOperationBehavior.XmlSerializerFormatAttribute.Style == OperationFormatStyle.Rpc))
{
throw Fx.Exception.AsError(
new InvalidOperationException(
SR.InvalidXmlSerializerFormatAttribute(
operation.Name,
operation.DeclaringContract.Name,
xmlSerializerFormatAttributeType.Name)));
}
// Ensure operations don't have message headers
if (operation.Messages[0].Headers.Count > 0 ||
(operation.Messages.Count > 1 &&
operation.Messages[1].Headers.Count > 0))
{
throw Fx.Exception.AsError(
new InvalidOperationException(
SR.InvalidOperationWithMessageHeaders(
operation.Name,
operation.DeclaringContract.Name)));
}
// Ensure operations don't have typed messages
if (operation.Messages[0].MessageType != null)
{
throw Fx.Exception.AsError(
new InvalidOperationException(
SR.InvalidMessageContractParameter(
operation.Name,
operation.DeclaringContract.Name,
messageContractAttributeType.Name,
operation.Messages[0].MessageType.Name)));
}
if (operation.Messages.Count > 1 &&
operation.Messages[1].MessageType != null)
{
throw Fx.Exception.AsError(
new InvalidOperationException(
SR.InvalidMessageContractParameter(
operation.Name,
operation.DeclaringContract.Name,
messageContractAttributeType.Name,
operation.Messages[1].MessageType.Name)));
}
}
public static SingleBodyParameterMessageFormatter CreateXmlFormatter(OperationDescription operation, Type type, bool isRequestFormatter, UnwrappedTypesXmlSerializerManager xmlSerializerManager)
{
DataContractSerializerOperationBehavior dcsob = operation.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (dcsob != null)
{
return(new SingleBodyParameterDataContractMessageFormatter(operation, type, isRequestFormatter, false, dcsob));
}
XmlSerializerOperationBehavior xsob = operation.Behaviors.Find <XmlSerializerOperationBehavior>();
if (xsob != null)
{
return(new SingleBodyParameterXmlSerializerMessageFormatter(operation, type, isRequestFormatter, xsob, xmlSerializerManager));
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.OnlyDataContractAndXmlSerializerTypesInUnWrappedMode, operation.Name)));
}
public static void XmlSerializerOperationBehavior_BasicUsage()
{
XmlSerializerOperationBehavior serializerBehavior;
BasicHttpBinding binding = new BasicHttpBinding();
string baseAddress = "http://localhost:1066/SomeService";
ChannelFactory<IXmlTestingType> factory = new ChannelFactory<IXmlTestingType>(binding, new EndpointAddress(baseAddress));
ContractDescription cd = factory.Endpoint.Contract;
OperationDescriptionCollection collection = cd.Operations;
foreach (OperationDescription description in collection)
{
// Find the serializer behavior for those operations that have the attribute set via the interface.
serializerBehavior = description.Behaviors.Find<XmlSerializerOperationBehavior>();
if (serializerBehavior == null)
{
// This operation was not set with XmlSerializerFormatAttribute
// Here we add the attribute programatically using defaults.
if (String.Equals(description.Name, nameof(IXmlTestingType.XmlSerializerFormatAttribute_NotSet_One)))
{
// Default OperationFormatStyle is "Document"
serializerBehavior = new XmlSerializerOperationBehavior(description);
description.Behaviors.Add(serializerBehavior);
}
// There is one additional operation not set with XmlSerializerFormatAttribute
// Here we add the attribute programatically and further set the OperationFormatStyle to 'Rpc'
else
{
XmlSerializerFormatAttribute serializerAttribute = new XmlSerializerFormatAttribute();
serializerAttribute.Style = OperationFormatStyle.Rpc;
serializerBehavior = new XmlSerializerOperationBehavior(description, serializerAttribute);
description.Behaviors.Add(serializerBehavior);
}
}
if (String.Equals(description.Name, nameof(IXmlTestingType.XmlSerializerFormatAttribute_Set_StyleSetTo_Rpc)) || (String.Equals(description.Name, nameof(IXmlTestingType.XmlSerializerFormatAttribute_NotSet_Two))))
{
Assert.True(String.Equals(serializerBehavior.XmlSerializerFormatAttribute.Style.ToString(), "Rpc"));
}
else
{
Assert.True(String.Equals(serializerBehavior.XmlSerializerFormatAttribute.Style.ToString(), "Document"));
}
}
}
public XmlRpcOperationFormatterBehavior(DataContractSerializerOperationBehavior dcs, XmlSerializerOperationBehavior xcs)
{
_dcs = dcs;
_xcs = xcs;
}
public SingleBodyParameterXmlSerializerMessageFormatter(OperationDescription operation, Type parameterType, bool isRequestFormatter, XmlSerializerOperationBehavior xsob, UnwrappedTypesXmlSerializerManager serializerManager)
: base(operation, isRequestFormatter, "XmlSerializer")
{
if (operation == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("operation");
}
if (parameterType == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parameterType");
}
if (xsob == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xsob");
}
if (serializerManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serializerManager");
}
this.serializerManager = serializerManager;
this.parameterType = parameterType;
List <Type> operationTypes = new List <Type>();
operationTypes.Add(parameterType);
this.knownTypes = new List <Type>();
if (operation.KnownTypes != null)
{
foreach (Type knownType in operation.KnownTypes)
{
this.knownTypes.Add(knownType);
operationTypes.Add(knownType);
}
}
Type nullableType = SingleBodyParameterDataContractMessageFormatter.UnwrapNullableType(this.parameterType);
if (nullableType != this.parameterType)
{
this.knownTypes.Add(nullableType);
operationTypes.Add(nullableType);
}
this.serializerManager.RegisterType(this, operationTypes);
thisLock = new Object();
}
private static bool IsNotSoapEncoding(OperationDescription op)
{
XmlSerializerOperationBehavior behavior = op.Behaviors.Find <XmlSerializerOperationBehavior>();
return(behavior == null || behavior.XmlSerializerFormatAttribute.Use != OperationFormatUse.Encoded);
}
