void IOperationContractGenerationExtension.GenerateOperation(OperationContractGenerationContext context)
{
DataContractSerializerOperationBehavior behavior = context.Operation.Behaviors.Find <DataContractSerializerOperationBehavior>();
DataContractFormatAttribute attribute = (behavior == null) ? new DataContractFormatAttribute() : behavior.DataContractFormatAttribute;
OperationFormatStyle style = attribute.Style;
this.operationGenerator.GenerateOperation(context, ref style, false, new WrappedBodyTypeGenerator(this, context), this.knownTypes);
attribute.Style = style;
if (attribute.Style != TypeLoader.DefaultDataContractFormatAttribute.Style)
{
context.SyncMethod.CustomAttributes.Add(System.ServiceModel.Description.OperationGenerator.GenerateAttributeDeclaration(context.Contract.ServiceContractGenerator, attribute));
}
if (this.knownTypes != null)
{
Dictionary <CodeTypeReference, object> operationKnownTypes = new Dictionary <CodeTypeReference, object>(new CodeTypeReferenceComparer());
foreach (MessageDescription description in context.Operation.Messages)
{
foreach (MessagePartDescription description2 in description.Body.Parts)
{
this.AddKnownTypesForPart(context, description2, operationKnownTypes);
}
foreach (MessageHeaderDescription description3 in description.Headers)
{
this.AddKnownTypesForPart(context, description3, operationKnownTypes);
}
if (OperationFormatter.IsValidReturnValue(description.Body.ReturnValue))
{
this.AddKnownTypesForPart(context, description.Body.ReturnValue, operationKnownTypes);
}
}
}
UpdateTargetCompileUnit(context, this.codeCompileUnit);
}
public void ApplyContractExtensions(ServiceEndpoint endpoint)
{
var contract = endpoint.Contract;
foreach (var extension in Extensions)
{
var operationDescriptions = contract.Operations.Find(extension.Metadata.FunctionName);
if (operationDescriptions != null)
{
var serializerBehavior = operationDescriptions.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (serializerBehavior == null)
{
serializerBehavior = new DataContractSerializerOperationBehavior(operationDescriptions);
operationDescriptions.Behaviors.Add(serializerBehavior);
}
serializerBehavior.DataContractResolver = extension.Value.GetResolver();
}
else
{
Logger.Log(string.Format("No operation descriptions found for function name: {0}", extension.Metadata.FunctionName);
}
}
}
private static bool GetStyleAndUse(OperationDescription operation, Type messageContractExporterType, out bool isRpc, out bool isEncoded)
{
isRpc = isEncoded = false;
if ((messageContractExporterType == typeof(DataContractSerializerMessageContractExporter)) || (messageContractExporterType == null))
{
DataContractSerializerOperationBehavior behavior = operation.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (behavior != null)
{
isRpc = behavior.DataContractFormatAttribute.Style == OperationFormatStyle.Rpc;
isEncoded = false;
return(true);
}
if (messageContractExporterType == typeof(DataContractSerializerMessageContractExporter))
{
return(false);
}
}
if ((messageContractExporterType == typeof(XmlSerializerMessageContractExporter)) || (messageContractExporterType == null))
{
XmlSerializerOperationBehavior behavior2 = operation.Behaviors.Find <XmlSerializerOperationBehavior>();
if (behavior2 != null)
{
isRpc = behavior2.XmlSerializerFormatAttribute.Style == OperationFormatStyle.Rpc;
isEncoded = behavior2.XmlSerializerFormatAttribute.IsEncoded;
return(true);
}
}
return(false);
}
/// <summary>
/// Changes the data contract serializer used on a service operation.
/// </summary>
/// <param name="operationDescription"></param>
public static void ReplaceDataContractSerializer(OperationDescription operationDescription)
{
if (operationDescription == null)
{
throw new ArgumentNullException("operationDescription");
}
System.ServiceModel.Description.DataContractSerializerOperationBehavior
dataContractSerializerOperationBehavior =
operationDescription.Behaviors
.Find <System.ServiceModel.Description.DataContractSerializerOperationBehavior>();
if (dataContractSerializerOperationBehavior != null)
{
// Remove old behavior
operationDescription.Behaviors.Remove(dataContractSerializerOperationBehavior);
// Add custom data contract resolver
dataContractSerializerOperationBehavior.DataContractResolver = new DataContractResolver();
}
// Add custom behavior
if (operationDescription.Behaviors.Find <DataContractSerializerOperationBehavior>() == null)
{
operationDescription.Behaviors.Add(new DataContractSerializerOperationBehavior(operationDescription));
}
}
// Assumption: gets called exactly once per operation
void IOperationContractGenerationExtension.GenerateOperation(OperationContractGenerationContext context)
{
DataContractSerializerOperationBehavior DataContractSerializerOperationBehavior = context.Operation.Behaviors.Find <DataContractSerializerOperationBehavior>() as DataContractSerializerOperationBehavior;
DataContractFormatAttribute dataContractFormatAttribute = (DataContractSerializerOperationBehavior == null) ? new DataContractFormatAttribute() : DataContractSerializerOperationBehavior.DataContractFormatAttribute;
OperationFormatStyle style = dataContractFormatAttribute.Style;
operationGenerator.GenerateOperation(context, ref style, false /*isEncoded*/, new WrappedBodyTypeGenerator(this, context), knownTypes);
dataContractFormatAttribute.Style = style;
if (dataContractFormatAttribute.Style != TypeLoader.DefaultDataContractFormatAttribute.Style)
{
context.SyncMethod.CustomAttributes.Add(OperationGenerator.GenerateAttributeDeclaration(context.Contract.ServiceContractGenerator, dataContractFormatAttribute));
}
if (knownTypes != null)
{
Dictionary <CodeTypeReference, object> operationKnownTypes = new Dictionary <CodeTypeReference, object>(new CodeTypeReferenceComparer());
foreach (MessageDescription message in context.Operation.Messages)
{
foreach (MessagePartDescription part in message.Body.Parts)
{
AddKnownTypesForPart(context, part, operationKnownTypes);
}
foreach (MessageHeaderDescription header in message.Headers)
{
AddKnownTypesForPart(context, header, operationKnownTypes);
}
if (OperationFormatter.IsValidReturnValue(message.Body.ReturnValue))
{
AddKnownTypesForPart(context, message.Body.ReturnValue, operationKnownTypes);
}
}
}
UpdateTargetCompileUnit(context, this.codeCompileUnit);
}
public DataContractSerializerOperationFormatter(OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute, DataContractSerializerOperationBehavior serializerFactory) : base(description, dataContractFormatAttribute.Style == OperationFormatStyle.Rpc, false)
{
if (description == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
}
this.serializerFactory = serializerFactory ?? new DataContractSerializerOperationBehavior(description);
foreach (System.Type type in description.KnownTypes)
{
if (this.knownTypes == null)
{
this.knownTypes = new List<System.Type>();
}
if (type == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxKnownTypeNull", new object[] { description.Name })));
}
this.ValidateDataContractType(type);
this.knownTypes.Add(type);
}
this.requestMessageInfo = this.CreateMessageInfo(dataContractFormatAttribute, base.RequestDescription, this.serializerFactory);
if (base.ReplyDescription != null)
{
this.replyMessageInfo = this.CreateMessageInfo(dataContractFormatAttribute, base.ReplyDescription, this.serializerFactory);
}
}
private static ServiceHost Start()
{
var sh = new ServiceHost(typeof(MyService2));
sh.Closing += SVClose;
sh.Open();
sh = new ServiceHost(typeof(MyService));
sh.Closing += SVClose;
sh.Open();
sh = new ServiceHost(typeof(CommonCRUDService));
var cd = sh.Description.Endpoints[0].Contract;
//查找的是需要更改数据契约
var myOperationDescription = cd.Operations.Find("Add");
var serializerBehavior = myOperationDescription.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (serializerBehavior == null)
{
serializerBehavior = new DataContractSerializerOperationBehavior(myOperationDescription);
myOperationDescription.Behaviors.Add(serializerBehavior);
}
serializerBehavior.DataContractResolver = new MyDataContractResolver(typeof(CommonCRUDService).Assembly);
sh.Open();
//var result = PolicyInjection.Create<MyService>();
////var result = PolicyInjection.Wrap<MyService>(serviceInstance);
//result.DoWork();
return sh;
}
public CompressionMessageFormatter(CompressionAlgorithm algorithm, OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute, DataContractSerializerOperationBehavior serializerFactory)
{
this.MessageCompressor = new MessageCompressor(algorithm);
Type innerFormatterType = Type.GetType(DataContractSerializerOperationFormatterTypeName);
var innerFormatter = Activator.CreateInstance(innerFormatterType, description, dataContractFormatAttribute, serializerFactory);
this.InnerClientMessageFormatter = innerFormatter as IClientMessageFormatter;
this.InnerDispatchMessageFormatter = innerFormatter as IDispatchMessageFormatter;
}
internal static IDispatchMessageFormatter GetDispatcherFormatterFromRuntime(OperationDescription operationDescription)
{
System.ServiceModel.Dispatcher.DispatchOperation dispatchOperation = new System.ServiceModel.Dispatcher.DispatchOperation(DummyDispatchRuntime, operationDescription.Name, operationDescription.Messages[0].Action);
IOperationBehavior operationBehavior = new DataContractSerializerOperationBehavior(operationDescription);
operationBehavior.ApplyDispatchBehavior(operationDescription, dispatchOperation);
return dispatchOperation.Formatter;
}
public static void Main(string[] argv)
{
AppDomain.CurrentDomain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) =>
{
Exception ex = ((Exception)e.ExceptionObject);
Console.WriteLine("Domain: {0}: {1}: Unhandled Exception: {2}\n{3}", DateTime.Now, sender ?? "(null)", ex.GetType().FullName, ex);
};
AppDomain.CurrentDomain.AssemblyLoad += (object sender, AssemblyLoadEventArgs args) =>
{
Console.WriteLine("Domain: {0}: {1}: Load Assembly: {2}", DateTime.Now, sender, args.LoadedAssembly.GetName());
};
AppDomain.CurrentDomain.DomainUnload += (object sender, EventArgs e) =>
{
Console.WriteLine("Domain: {0}: {1}: Domain Unload", DateTime.Now, sender ?? "(null)");
};
AppDomain.CurrentDomain.ProcessExit += (object sender, EventArgs e) =>
{
Console.WriteLine("Domain: {0}: {1}: Process Exit", DateTime.Now, sender ?? "(null)");
};
ProcessArgs(argv);
// AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => Assembly.LoadFile(args.);
using (Host = new ServiceHost(typeof(TraceService)))
{
Host.OpenTimeout = Host.CloseTimeout = Timeout;
ServiceEndpoint epTraceService = Host.AddServiceEndpoint(typeof(ITraceService), Binding, BaseUri);
foreach (OperationDescription op in epTraceService.Contract.Operations)
{
DataContractSerializerOperationBehavior dcsob = op.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (dcsob == null)
op.Behaviors.Add(dcsob = new DataContractSerializerOperationBehavior(op, new DataContractFormatAttribute() { }));
dcsob.DataContractSurrogate = new TraceServiceSurrogate(); // dcsob.DataContractResolver = new System.Runtime.Serialization.DataContractResolver
}
Host.Opening += (sender, e) => {
Console.WriteLine("Service: {0}: {1}: Opening: {2}{3}: {4}", DateTime.Now, sender.ToString(),
Host.Description.Namespace, Host.Description.Name, Host.Description.ServiceType.FullName);
foreach (Uri baseUri in Host.BaseAddresses)
Console.WriteLine(" Base Address: {0}", Host.BaseAddresses[0]);
foreach (ServiceEndpoint endpoint in Host.Description.Endpoints)
Console.WriteLine(" Endpoint: {0}{1} {2}", endpoint.Contract.Namespace, endpoint.Contract.Name, endpoint.Address.Uri.ToString());
};
Host.Opened += (sender, e) => Console.WriteLine("Service: {0}: {1}: Opened", DateTime.Now, sender.ToString());
Host.Closing += (sender, e) => Console.WriteLine("Service: {0}: {1}: Closing", DateTime.Now, sender.ToString());
Host.Closed += (sender, e) => Console.WriteLine("Service: {0}: {1}: Closed", DateTime.Now, sender.ToString());
Host.UnknownMessageReceived += (sender, e) => Console.WriteLine("Service: {0}: {1}: UnknownMessageReceived: {2}", DateTime.Now, sender.ToString(), e.Message.ToString());
Host.Open();
// while (Host.State == CommunicationState.Opening || Host.State == CommunicationState.Opened)
// {
Thread.Sleep(HostThreadLoopDelay);
// }
Process.GetCurrentProcess().WaitForExit();
}
}
/// <summary>
/// Applies the type resolver behavior to an
/// operation
/// </summary>
/// <param name="desc">
/// The WCF operation description
/// </param>
protected override void ApplyOperationBehavior(OperationDescription desc)
{
DataContractSerializerOperationBehavior dcsob =
desc.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (dcsob == null)
desc.Behaviors.Add(
dcsob = new DataContractSerializerOperationBehavior(desc)
);
dcsob.DataContractResolver = this.resolver;
}
internal JsonQueryStringConverter(OperationDescription operationDescription)
: base()
{
if (operationDescription == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("operationDescription");
}
this.operationDescription = operationDescription;
this.dataContractSerializerOperationBehavior = this.operationDescription.Behaviors.Find<DataContractSerializerOperationBehavior>();
}
private static void ConfigureService(Type iface, ServiceHost host)
{
var proxyConfig = ProxyConfiguration.Create(new Config(), iface.Name.Substring(1));
//host.Authorization.ServiceAuthorizationManager = new CompanyNameServiceAuthorizationManager();
var ep = host.AddServiceEndpoint(iface, new BindingFactory().CreateBinding(proxyConfig), string.Empty);
//ep.Behaviors.Add(new ContextPropagator());
if (proxyConfig.BindingType == typeof(WebHttpBinding))
{
ep.Behaviors.Add(new WebHttpBehavior());
}
foreach (var op in ep.Contract.Operations)
{
var dataContract = op.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (dataContract == null)
{
dataContract = new DataContractSerializerOperationBehavior(op) { MaxItemsInObjectGraph = proxyConfig.MaxItemsInObjectGraph };
op.Behaviors.Add(dataContract);
}
else
{
dataContract.MaxItemsInObjectGraph = proxyConfig.MaxItemsInObjectGraph;
}
}
var serviceDebugBehavior = host.Description.Behaviors.Find<ServiceDebugBehavior>();
if (serviceDebugBehavior == null)
{
serviceDebugBehavior = new ServiceDebugBehavior { IncludeExceptionDetailInFaults = proxyConfig.IncludeExceptionDetailInFaults };
host.Description.Behaviors.Add(serviceDebugBehavior);
}
else
{
serviceDebugBehavior.IncludeExceptionDetailInFaults = proxyConfig.IncludeExceptionDetailInFaults;
}
var metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();
if (metadataBehavior == null)
{
metadataBehavior = new ServiceMetadataBehavior { HttpGetEnabled = true };
host.Description.Behaviors.Add(metadataBehavior);
}
else
{
metadataBehavior.HttpGetEnabled = true;
}
}
public static void AttachDataResolver(this ServiceEndpoint endpoint)
{
ContractDescription cd = endpoint.Contract;
foreach (var operation in cd.Operations)
{
var serializerBehavior = operation.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (serializerBehavior == null)
{
serializerBehavior = new DataContractSerializerOperationBehavior(operation);
operation.Behaviors.Add(serializerBehavior);
}
serializerBehavior.DataContractResolver = new SharedTypeResolver();
}
}
internal static NetDataContractSerializerOperationBehavior ApplyTo(OperationDescription operation)
{
NetDataContractSerializerOperationBehavior item = null;
DataContractSerializerOperationBehavior behavior2 = operation.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (behavior2 != null)
{
item = new NetDataContractSerializerOperationBehavior(operation);
operation.Behaviors.Remove(behavior2);
operation.Behaviors.Add(item);
return(item);
}
return(null);
}
private void ReplaceSerializerOperationBehavior(OperationDescription description)
{
DataContractSerializerOperationBehavior dcs = description.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (dcs != null)
{
dcs.DataContractSurrogate = Activator.CreateInstance(m_SurrogatedType) as IDataContractSurrogate;
}
else
{
dcs = new DataContractSerializerOperationBehavior(description);
dcs.DataContractSurrogate = Activator.CreateInstance(m_SurrogatedType) as IDataContractSurrogate;
description.Behaviors.Add(dcs);
}
}
internal static NetDataContractSerializerOperationBehavior ApplyTo(OperationDescription operation)
{
NetDataContractSerializerOperationBehavior netDataContractSerializerOperationBehavior = null;
DataContractSerializerOperationBehavior dataContractSerializerOperationBehavior = operation.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (dataContractSerializerOperationBehavior != null)
{
netDataContractSerializerOperationBehavior = new NetDataContractSerializerOperationBehavior(operation);
operation.Behaviors.Remove(dataContractSerializerOperationBehavior);
operation.Behaviors.Add(netDataContractSerializerOperationBehavior);
return(netDataContractSerializerOperationBehavior);
}
return(null);
}
private void AttachDataContractResolver(ServiceEndpoint endpoint)
{
ContractDescription cd = endpoint.Contract;
foreach (OperationDescription operationDescription in cd.Operations)
{
DataContractSerializerOperationBehavior serializerBehavior =
operationDescription.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (serializerBehavior == null)
{
serializerBehavior = new DataContractSerializerOperationBehavior(operationDescription);
operationDescription.Behaviors.Add(serializerBehavior);
}
serializerBehavior.DataContractResolver = new SchedulerTaskDataContractResolver();
}
}
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime)
{
foreach (OperationDescription op in endpoint.Contract.Operations)
{
DataContractSerializerOperationBehavior dataContractBehavior = op.Behaviors.Find<DataContractSerializerOperationBehavior>() as DataContractSerializerOperationBehavior;
if (dataContractBehavior != null)
{
dataContractBehavior.DataContractSurrogate = new BinarySurrogate(typeProvider, surrogateConverter);
}
else
{
dataContractBehavior = new DataContractSerializerOperationBehavior(op);
dataContractBehavior.DataContractSurrogate = new BinarySurrogate(typeProvider, surrogateConverter);
op.Behaviors.Add(dataContractBehavior);
}
}
}
internal static void AddToEndpoints(IEnumerable<ServiceEndpoint> endpoints)
{
var operations = endpoints
.Select(endpoint => endpoint.Contract)
.SelectMany(contract => contract.Operations);
foreach (var operation in operations)
{
var behavior = operation.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (behavior == null)
{
behavior = new DataContractSerializerOperationBehavior(operation);
operation.Behaviors.Add(behavior);
}
behavior.DataContractResolver = new BusReceiverDataContractResolver();
}
}
private void ConfigureOperationDescriptionBehaviors(OperationDescription operation, IDataContractSurrogate contractSurrogate)
{
DataContractSerializerOperationBehavior item = new DataContractSerializerOperationBehavior(operation, TypeLoader.DefaultDataContractFormatAttribute);
if (contractSurrogate != null)
{
item.DataContractSurrogate = contractSurrogate;
}
operation.Behaviors.Add(item);
operation.Behaviors.Add(new OperationInvokerBehavior());
if ((this.info.TransactionOption == TransactionOption.Supported) || (this.info.TransactionOption == TransactionOption.Required))
{
operation.Behaviors.Add(new TransactionFlowAttribute(TransactionFlowOption.Allowed));
}
OperationBehaviorAttribute attribute = new OperationBehaviorAttribute {
TransactionAutoComplete = true,
TransactionScopeRequired = false
};
operation.Behaviors.Add(attribute);
}
internal static IClientMessageFormatter GetFormatterFromRuntime(OperationDescription operationDescription)
{
System.ServiceModel.Dispatcher.ClientOperation clientOperation = new System.ServiceModel.Dispatcher.ClientOperation(DummyClientRuntime, operationDescription.Name, operationDescription.Messages[0].Action);
// Default to DataContractSerializerOperationBehavior
if (operationDescription.Behaviors.Count == 0)
{
IOperationBehavior operationBehavior = new DataContractSerializerOperationBehavior(operationDescription);
operationBehavior.ApplyClientBehavior(operationDescription, clientOperation);
}
else
{
foreach (IOperationBehavior operationBehavior in operationDescription.Behaviors)
{
operationBehavior.ApplyClientBehavior(operationDescription, clientOperation);
}
}
return clientOperation.Formatter;
}
public SingleBodyParameterDataContractMessageFormatter(OperationDescription operation, Type parameterType, bool isRequestFormatter, bool useJsonFormat, DataContractSerializerOperationBehavior dcsob)
: base(operation, isRequestFormatter, "DataContractSerializer")
{
if (operation == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("operation");
}
if (parameterType == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parameterType");
}
if (dcsob == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dcsob");
}
this.parameterDataContractType = DataContractSerializerOperationFormatter.GetSubstituteDataContractType(parameterType, out isQueryable);
this.isParameterCollectionInterfaceDataContract = IsTypeCollectionInterface(this.parameterDataContractType);
List<Type> tmp = new List<Type>();
if (operation.KnownTypes != null)
{
foreach (Type knownType in operation.KnownTypes)
{
tmp.Add(knownType);
}
}
Type nullableType = UnwrapNullableType(this.parameterDataContractType);
if (nullableType != this.parameterDataContractType)
{
tmp.Add(nullableType);
}
this.surrogate = dcsob.DataContractSurrogate;
this.ignoreExtensionData = dcsob.IgnoreExtensionDataObject;
this.maxItemsInObjectGraph = dcsob.MaxItemsInObjectGraph;
this.knownTypes = tmp.AsReadOnly();
ValidateType(this.parameterDataContractType, surrogate, this.knownTypes);
this.useJsonFormat = useJsonFormat;
CreateInputSerializers(this.parameterDataContractType);
thisLock = new Object();
}
public DataContractSerializerOperationFormatter(OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute,
DataContractSerializerOperationBehavior serializerFactory)
: base(description, dataContractFormatAttribute.Style == OperationFormatStyle.Rpc, false/*isEncoded*/)
{
if (description == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
_serializerFactory = serializerFactory ?? new DataContractSerializerOperationBehavior(description);
foreach (Type type in description.KnownTypes)
{
if (_knownTypes == null)
_knownTypes = new List<Type>();
if (type == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxKnownTypeNull, description.Name)));
ValidateDataContractType(type);
_knownTypes.Add(type);
}
requestMessageInfo = CreateMessageInfo(dataContractFormatAttribute, RequestDescription, _serializerFactory);
if (ReplyDescription != null)
replyMessageInfo = CreateMessageInfo(dataContractFormatAttribute, ReplyDescription, _serializerFactory);
}
static void Main(string[] args)
{
var logger = LogManager.GetLogger("Client");
//MyService.MyServiceClient client = new MyServiceClient();
//client.DoWork();
try
{
var client = new CommonCRUDService.CommonCRUDServiceClient();
var cd = client.Endpoint.Contract;
//查找的是需要更改数据契约
var myOperationDescription = cd.Operations.Find("Add");
var serializerBehavior = myOperationDescription.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (serializerBehavior == null)
{
serializerBehavior = new DataContractSerializerOperationBehavior(myOperationDescription);
myOperationDescription.Behaviors.Add(serializerBehavior);
}
serializerBehavior.DataContractResolver = new MyDataContractResolver(typeof(ICommonCRUDService).Assembly);
client.Add(new BusinessEntity() { Code = "MyBizDTO", Name = "MYDTO" });
client.Close();
//CodeTimer.Initialize();
//CodeTimer.Time("预热", 1, SVInvoke);
//CodeTimer.Time("1000次服务执行", 1000, SVInvoke);
//SVInvoke();
}
catch (Exception ex)
{
logger.Error(ex);
}
Console.ReadLine();
}
public DataContractSerializerOperationBehaviorExtended(DataContractSerializerOperationBehavior inner,
OperationDescription operation)
: base(operation, inner.DataContractFormatAttribute)
{
this.DataContractSurrogate = inner.DataContractSurrogate;
this.IgnoreExtensionDataObject = inner.IgnoreExtensionDataObject;
this.MaxItemsInObjectGraph = inner.MaxItemsInObjectGraph;
}
/// <summary>
/// 处理当前主机节点，将当前节点做为服务HOST启动
/// </summary>
/// <param name="node">当前主机节点</param>
private void ProcessNode(NetNode node)
{
if (node.Info != null && !string.IsNullOrEmpty(node.Info.Url))
{
ServiceHost host = new ServiceHost(typeof(SyncService));
//if (host.State == CommunicationState.Created)
//{
// _logger.Info(string.Format("主机节点{0}已启动", node.Info.Url));
// return;
//}
NetTcpBinding binding = new NetTcpBinding("SyncBinding");
host.AddServiceEndpoint(typeof(ISyncService), binding, node.Info.Url);
ContractDescription cd = host.Description.Endpoints[0].Contract;
OperationDescription myOperationDescription = cd.Operations.Find("Excute");
DataContractSerializerOperationBehavior serializerBehavior = myOperationDescription.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (serializerBehavior == null)
{
serializerBehavior = new DataContractSerializerOperationBehavior(myOperationDescription);
myOperationDescription.Behaviors.Add(serializerBehavior);
}
serializerBehavior.MaxItemsInObjectGraph = 1000000000;
ServiceDebugBehavior behavior = host.Description.Behaviors.Find<ServiceDebugBehavior>();
if (behavior == null)
{
behavior = new ServiceDebugBehavior();
host.Description.Behaviors.Add(behavior);
}
behavior.IncludeExceptionDetailInFaults = true;
host.Opened += (obj, e) => { _logger.Info(string.Format("主机节点{0}已启动", node.Info.Url)); };
host.Open();
}
else
{
_logger.Error("没有找到可用于启动的主机节点");
}
}
internal override DataContractJsonSerializerOperationFormatter CreateDataContractJsonSerializerOperationFormatter(OperationDescription od, DataContractSerializerOperationBehavior dcsob, bool isWrapped)
{
return(new DataContractJsonSerializerOperationFormatter(od, dcsob.MaxItemsInObjectGraph, dcsob.IgnoreExtensionDataObject, dcsob.DataContractSurrogate, isWrapped, true, this.JavascriptCallbackParameterName));
}
static void Main(string[] args)
{
using (ServiceHost host = new ServiceHost(typeof(WcfServiceLibrary1.Service1)))
{
// surrogate definition..
foreach (ServiceEndpoint ep in host.Description.Endpoints)
{
foreach (OperationDescription op in ep.Contract.Operations)
{
DataContractSerializerOperationBehavior dataContractBehavior =
op.Behaviors.Find<DataContractSerializerOperationBehavior>()
as DataContractSerializerOperationBehavior;
if (dataContractBehavior != null)
{
dataContractBehavior.DataContractSurrogate = new valToTransferAsBytes();
}
else
{
dataContractBehavior = new DataContractSerializerOperationBehavior(op);
dataContractBehavior.DataContractSurrogate = new valToTransferAsBytes();
op.Behaviors.Add(dataContractBehavior);
}
}
}
// set up exporter with surrogate definition..
WsdlExporter exporter = new WsdlExporter();
object dataContractExporter;
XsdDataContractExporter xsdInventoryExporter;
if (!exporter.State.TryGetValue(typeof(XsdDataContractExporter),
out dataContractExporter))
{
xsdInventoryExporter = new XsdDataContractExporter(exporter.GeneratedXmlSchemas);
}
else
xsdInventoryExporter = (XsdDataContractExporter)dataContractExporter;
exporter.State.Add(typeof(XsdDataContractExporter), xsdInventoryExporter);
if (xsdInventoryExporter.Options == null)
xsdInventoryExporter.Options = new ExportOptions();
xsdInventoryExporter.Options.DataContractSurrogate = new valToTransferAsBytes();
// export the endpoints..
ServiceEndpointCollection sec = host.Description.Endpoints;
foreach (ServiceEndpoint se in sec)
{
Console.WriteLine(se.Name);
exporter.ExportEndpoint(se);
}
MetadataSet docs = null;
docs = exporter.GetGeneratedMetadata();
host.Description.
host.Open();
PrintDescription(host);
Console.WriteLine("The Trading Service is available. Press any key to exit.");
Console.ReadKey();
host.Close();
}
}
public DataContractMessagesFormatter (OperationDescription desc, DataContractFormatAttribute attr)
: base (desc)
{
#if !NET_2_1
this.serializerBehavior = desc.Behaviors.Find<DataContractSerializerOperationBehavior>();
#endif
this.attr = attr;
}
internal override DataContractJsonSerializerOperationFormatter CreateDataContractJsonSerializerOperationFormatter(OperationDescription od, DataContractSerializerOperationBehavior dcsob, bool isWrapped)
{
return new DataContractJsonSerializerOperationFormatter(od, dcsob.MaxItemsInObjectGraph, dcsob.IgnoreExtensionDataObject, dcsob.DataContractSurrogate, isWrapped, true, this.JavascriptCallbackParameterName);
}
public XmlRpcOperationFormatterBehavior(DataContractSerializerOperationBehavior dcs, XmlSerializerOperationBehavior xcs)
{
_dcs = dcs;
_xcs = xcs;
}
internal override void SetOperationStyle(OperationDescription operation, OperationFormatStyle style)
{
DataContractSerializerOperationBehavior operationBehavior = operation.Behaviors.Find<DataContractSerializerOperationBehavior>();
if (operationBehavior == null)
{
operationBehavior = new DataContractSerializerOperationBehavior(operation, new DataContractFormatAttribute());
operation.Behaviors.Add(operationBehavior);
}
operationBehavior.DataContractFormatAttribute.Style = style;
}
private MessageInfo CreateMessageInfo(DataContractFormatAttribute dataContractFormatAttribute, MessageDescription messageDescription, DataContractSerializerOperationBehavior serializerFactory)
{
if (messageDescription.IsUntypedMessage)
{
return null;
}
MessageInfo info = new MessageInfo();
MessageBodyDescription body = messageDescription.Body;
if (body.WrapperName != null)
{
info.WrapperName = base.AddToDictionary(body.WrapperName);
info.WrapperNamespace = base.AddToDictionary(body.WrapperNamespace);
}
MessagePartDescriptionCollection parts = body.Parts;
info.BodyParts = new PartInfo[parts.Count];
for (int i = 0; i < parts.Count; i++)
{
info.BodyParts[i] = this.CreatePartInfo(parts[i], dataContractFormatAttribute.Style, serializerFactory);
}
if (OperationFormatter.IsValidReturnValue(messageDescription.Body.ReturnValue))
{
info.ReturnPart = this.CreatePartInfo(messageDescription.Body.ReturnValue, dataContractFormatAttribute.Style, serializerFactory);
}
info.HeaderDescriptionTable = new OperationFormatter.MessageHeaderDescriptionTable();
info.HeaderParts = new PartInfo[messageDescription.Headers.Count];
for (int j = 0; j < messageDescription.Headers.Count; j++)
{
MessageHeaderDescription message = messageDescription.Headers[j];
if (message.IsUnknownHeaderCollection)
{
info.UnknownHeaderDescription = message;
}
else
{
this.ValidateDataContractType(message.Type);
info.HeaderDescriptionTable.Add(message.Name, message.Namespace, message);
}
info.HeaderParts[j] = this.CreatePartInfo(message, OperationFormatStyle.Document, serializerFactory);
}
info.AnyHeaders = (info.UnknownHeaderDescription != null) || (info.HeaderDescriptionTable.Count > 0);
return info;
}
void CreateWorkflowManagementEndpoint(WorkflowServiceHost workflowServiceHost)
{
Binding controlEndpointBinding;
if (workflowServiceHost.InternalBaseAddresses.Contains(Uri.UriSchemeNetPipe))
{
controlEndpointBinding = NamedPipeControlEndpointBinding;
}
else if (workflowServiceHost.InternalBaseAddresses.Contains(Uri.UriSchemeHttp))
{
controlEndpointBinding = HttpControlEndpointBinding;
}
else
{
return;
}
Uri controlEndpointAddress = ServiceHost.GetVia(controlEndpointBinding.Scheme, new Uri(ControlEndpointAddress, UriKind.Relative), workflowServiceHost.InternalBaseAddresses);
XmlQualifiedName contractName = new XmlQualifiedName(XD2.WorkflowInstanceManagementService.ContractName, XD2.WorkflowServices.Namespace);
//Create the Endpoint Dispatcher
EndpointAddress address = new EndpointAddress(controlEndpointAddress.AbsoluteUri);
EndpointDispatcher endpointDispatcher = new EndpointDispatcher(address,
XD2.WorkflowInstanceManagementService.ContractName,
XD2.WorkflowServices.Namespace, true)
{
ContractFilter = new ActionMessageFilter(
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Abandon, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Cancel, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Run, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Suspend, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Terminate, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedCancel, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedRun, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedSuspend, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedTerminate, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedUnsuspend, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.TransactedUpdate, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Unsuspend, null, false),
NamingHelper.GetMessageAction(contractName, XD2.WorkflowInstanceManagementService.Update, null, false)),
};
//Create Listener
ServiceEndpoint endpoint = new ServiceEndpoint(WorkflowControlEndpoint.WorkflowControlServiceContract, controlEndpointBinding, address);
BindingParameterCollection parameters = workflowServiceHost.GetBindingParameters(endpoint);
IChannelListener listener;
if (controlEndpointBinding.CanBuildChannelListener<IDuplexSessionChannel>(controlEndpointAddress, parameters))
{
listener = controlEndpointBinding.BuildChannelListener<IDuplexSessionChannel>(controlEndpointAddress, parameters);
}
else if (controlEndpointBinding.CanBuildChannelListener<IReplySessionChannel>(controlEndpointAddress, parameters))
{
listener = controlEndpointBinding.BuildChannelListener<IReplySessionChannel>(controlEndpointAddress, parameters);
}
else
{
listener = controlEndpointBinding.BuildChannelListener<IReplyChannel>(controlEndpointAddress, parameters);
}
//Add the operations
bool formatRequest;
bool formatReply;
foreach (OperationDescription operation in WorkflowControlEndpoint.WorkflowControlServiceContract.Operations)
{
DataContractSerializerOperationBehavior dataContractSerializerOperationBehavior = new DataContractSerializerOperationBehavior(operation);
DispatchOperation operationDispatcher = new DispatchOperation(endpointDispatcher.DispatchRuntime, operation.Name,
NamingHelper.GetMessageAction(operation, false), NamingHelper.GetMessageAction(operation, true))
{
Formatter = (IDispatchMessageFormatter)dataContractSerializerOperationBehavior.GetFormatter(operation, out formatRequest, out formatReply, false),
Invoker = new ControlOperationInvoker(
operation,
new WorkflowControlEndpoint(controlEndpointBinding, address),
null,
workflowServiceHost),
};
endpointDispatcher.DispatchRuntime.Operations.Add(operationDispatcher);
OperationBehaviorAttribute operationAttribute = operation.Behaviors.Find<OperationBehaviorAttribute>();
((IOperationBehavior)operationAttribute).ApplyDispatchBehavior(operation, operationDispatcher);
}
DispatchRuntime dispatchRuntime = endpointDispatcher.DispatchRuntime;
dispatchRuntime.ConcurrencyMode = ConcurrencyMode.Multiple;
dispatchRuntime.InstanceContextProvider = new DurableInstanceContextProvider(workflowServiceHost);
dispatchRuntime.InstanceProvider = new DurableInstanceProvider(workflowServiceHost);
dispatchRuntime.ServiceAuthorizationManager = new WindowsAuthorizationManager(this.WindowsGroup);
//Create the Channel Dispatcher
ServiceDebugBehavior serviceDebugBehavior = workflowServiceHost.Description.Behaviors.Find<ServiceDebugBehavior>();
ServiceBehaviorAttribute serviceBehaviorAttribute = workflowServiceHost.Description.Behaviors.Find<ServiceBehaviorAttribute>();
bool includeDebugInfo = false;
if (serviceDebugBehavior != null)
{
includeDebugInfo |= serviceDebugBehavior.IncludeExceptionDetailInFaults;
}
if (serviceBehaviorAttribute != null)
{
includeDebugInfo |= serviceBehaviorAttribute.IncludeExceptionDetailInFaults;
}
ChannelDispatcher channelDispatcher = new ChannelDispatcher(listener, controlEndpointBinding.Name, controlEndpointBinding)
{
MessageVersion = controlEndpointBinding.MessageVersion,
Endpoints = { endpointDispatcher },
ServiceThrottle = workflowServiceHost.ServiceThrottle
};
workflowServiceHost.ChannelDispatchers.Add(channelDispatcher);
}
public PartInfo(MessagePartDescription description, XmlDictionaryString dictionaryName, XmlDictionaryString dictionaryNamespace, IList<System.Type> knownTypes, DataContractSerializerOperationBehavior behavior)
{
this.dictionaryName = dictionaryName;
this.dictionaryNamespace = dictionaryNamespace;
this.description = description;
this.knownTypes = knownTypes;
this.serializerFactory = behavior;
}
/// <summary>
/// 创建和打开服务代理
/// </summary>
/// <returns></returns>
public static TService CreateService()
{
Type t = typeof(TService);
string bindingKey = "binding:" + t.Name.ToLower();
Binding binding = GetBinding(bindingKey);
string urlKey = "url:" + t.Name.ToLower();
try
{
// new ContractDescriptionColletion
if (!Configs.ContainsKey(urlKey))
{
throw new KeyNotFoundException(string.Format("键URL:{0}未找到(键不区分大小写)。", t.Name));
}
if (!_factoryList.ContainsKey(urlKey))
{
// ServiceEndpoint endPoint = new ServiceEndpoint(null, binding, GetEndpointAddress(urlKey));
// new ContractDescription{ Operations = new OperationDescriptionCollection()}
ChannelFactory <TService> factory = new ChannelFactory <TService>(binding, GetEndpointAddress(urlKey));
foreach (System.ServiceModel.Description.OperationDescription op in factory.Endpoint.Contract.Operations)
{
System.ServiceModel.Description.DataContractSerializerOperationBehavior dataContractBehavior =
op.Behaviors.Find <System.ServiceModel.Description.DataContractSerializerOperationBehavior>()
as System.ServiceModel.Description.DataContractSerializerOperationBehavior;
if (dataContractBehavior != null)
{
dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue;
}
}
try
{
_factoryList.Add(urlKey, factory);
}
catch { }
}
}
catch (Exception ex)
{
//LogHelper.LogWriter(ex);
}
return(_factoryList[urlKey].CreateChannel());
}
private PartInfo CreatePartInfo(MessagePartDescription part, OperationFormatStyle style, DataContractSerializerOperationBehavior serializerFactory)
{
this.ValidateDataContractType(part.Type);
string s = ((style == OperationFormatStyle.Rpc) || (part.Namespace == null)) ? string.Empty : part.Namespace;
return new PartInfo(part, base.AddToDictionary(part.Name), base.AddToDictionary(s), this.knownTypes, serializerFactory);
}
void StartWCFService(Dictionary <Type, Type> serviceTypes, string servicePort)
{
servicePort = XML.Read(ConfigFile, "Service", "Port", servicePort);
string endpointAddress = string.Empty;
string tName = string.Empty;
foreach (var item in serviceTypes)
{
tName = item.Key.Name.Substring(1);
endpointAddress = string.Format("http://localhost:{0}/{1}", servicePort, tName);
ServiceHost host = new ServiceHost(item.Value, new Uri(endpointAddress));
WSHttpBinding wsHttpBinding = new WSHttpBinding();
wsHttpBinding.MaxBufferPoolSize = int.MaxValue;
wsHttpBinding.MaxReceivedMessageSize = int.MaxValue;
wsHttpBinding.ReceiveTimeout = new TimeSpan(1, 0, 0);
wsHttpBinding.Security = new System.ServiceModel.WSHttpSecurity();
wsHttpBinding.Security.Mode = SecurityMode.None;
host.AddServiceEndpoint(item.Key, wsHttpBinding, string.Empty);
ServiceMetadataBehavior behavior = host.Description.Behaviors.Find <ServiceMetadataBehavior>();
{
if (behavior == null)
{
behavior = new ServiceMetadataBehavior();
behavior.HttpGetEnabled = true;
host.Description.Behaviors.Add(behavior);
}
else
{
behavior.HttpGetEnabled = true;
}
}
{
System.ServiceModel.Description.DataContractSerializerOperationBehavior dataContractBehavior =
host.Description.Behaviors.Find <System.ServiceModel.Description.DataContractSerializerOperationBehavior>()
as System.ServiceModel.Description.DataContractSerializerOperationBehavior;
if (dataContractBehavior != null)
{
dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue;
}
}
host.Open();
serviceHosts.Add(host);
}
}
static void StartWCFService(Dictionary <Type, Type> serviceTypes, string servicePort)
{
servicePort = XML.Read(ConfigFile, "Service", "Port", servicePort);
string endpointAddress = string.Empty;
string tName = string.Empty;
foreach (var item in serviceTypes)
{
tName = item.Key.Name.Substring(1);
endpointAddress = string.Format("http://localhost:{0}/{1}", servicePort, tName);
ServiceHost host = new ServiceHost(item.Value, new Uri(endpointAddress));
CustomBinding customBinding = new CustomBinding("GZipHttpBinding");
customBinding.ReceiveTimeout = new TimeSpan(1, 0, 0);
host.AddServiceEndpoint(item.Key, customBinding, string.Empty);
ServiceMetadataBehavior behavior = host.Description.Behaviors.Find <ServiceMetadataBehavior>();
{
if (behavior == null)
{
behavior = new ServiceMetadataBehavior();
behavior.HttpGetEnabled = true;
host.Description.Behaviors.Add(behavior);
}
else
{
behavior.HttpGetEnabled = true;
}
}
{
System.ServiceModel.Description.DataContractSerializerOperationBehavior dataContractBehavior =
host.Description.Behaviors.Find <System.ServiceModel.Description.DataContractSerializerOperationBehavior>()
as System.ServiceModel.Description.DataContractSerializerOperationBehavior;
if (dataContractBehavior != null)
{
dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue;
}
}
host.Opened += delegate
{
Console.WriteLine("{0}已经启动，按任意键终止服务！", tName);
};
host.Open();
serviceHosts.Add(host);
}
Console.Read();
if (serviceHosts != null)
{
foreach (ServiceHost t in serviceHosts)
{
if (t != null)
{
t.Close();
}
}
}
}