/**
* The execution of this behavior comes rather late.
* Anyone that inspects the service description in the meantime,
* such as for metadata generation, won't see the protection level that we want to use.
*
* One way of doing it is at when create HostFactory
*
* ServiceEndpoint endpoint = host.Description.Endpoints.Find(typeof(IService));
* OperationDescription operation = endpoint.Contract.Operations.Find("Action");
* MessageDescription message = operation.Messages.Find("http://tempuri.org/IService/ActionResponse");
* MessageHeaderDescription header = message.Headers[new XmlQualifiedName("aheader", "http://tempuri.org/")];
* header.ProtectionLevel = ProtectionLevel.Sign;
*
* **/
public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
{
ChannelProtectionRequirements requirements = bindingParameters.Find<ChannelProtectionRequirements>();
XmlQualifiedName qName = new XmlQualifiedName(header, ns);
MessagePartSpecification part = new MessagePartSpecification(qName);
requirements.OutgoingSignatureParts.AddParts(part, action);
}
public void ApplyDispatchBehavior(
ContractDescription contractDescription,
ServiceEndpoint endpoint,
DispatchRuntime dispatchRuntime)
{
dispatchRuntime.InstanceProvider = this;
}
public ComPlusThreadInitializer(ContractDescription contract, DispatchOperation operation, ServiceInfo info)
{
this.info = info;
this.iid = contract.ContractType.GUID;
if (info.CheckRoles)
{
string[] serviceRoleMembers = null;
string[] contractRoleMembers = null;
string[] operationRoleMembers = null;
serviceRoleMembers = info.ComponentRoleMembers;
foreach (ContractInfo info2 in this.info.Contracts)
{
if (!(info2.IID == this.iid))
{
continue;
}
contractRoleMembers = info2.InterfaceRoleMembers;
foreach (System.ServiceModel.ComIntegration.OperationInfo info3 in info2.Operations)
{
if (info3.Name == operation.Name)
{
operationRoleMembers = info3.MethodRoleMembers;
break;
}
}
if (operationRoleMembers == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(System.ServiceModel.SR.GetString("ComOperationNotFound", new object[] { contract.Name, operation.Name })));
}
break;
}
this.comAuth = new ComPlusAuthorization(serviceRoleMembers, contractRoleMembers, operationRoleMembers);
}
}
private static void ConfigureRouterViaCode(ServiceHost serviceHost)
{
//This code sets up the Routing Sample via code. Rename or delete the App.config file
//and comment out this method call to run a config-based Routing Service
//set up some communication defaults
string deadAddress = "net.tcp://localhost:9090/servicemodelsamples/fakeDestination";
string realAddress = "net.tcp://localhost:8080/servicemodelsamples/service";
string routerAddress = "http://localhost/routingservice/router";
//note that the calculator client will be communicating to the Routing Service via basic
//HTTP, while the Routing Service is using Net.TCP to communicate to the calculator service.
//This demonstrates the Routing Service's capability of bridging between different message
//transports, formats, bindings, etc. This automatic message conversion is governed by
//whether or not SoapProcessing (enabled by default) is enabled on the Routing Configuration.
Binding routerBinding = new BasicHttpBinding();
Binding clientBinding = new NetTcpBinding();
//add the endpoint the router will use to recieve messages
serviceHost.AddServiceEndpoint(typeof(IRequestReplyRouter), routerBinding, routerAddress);
//create the client endpoint the router will route messages to
//note that the contract description on the client endpoints is actually unused, so
//this could be any string. The contract specified here goes unused
//because the Routing Service replaces this contract with one of the Router
//contracts at runtime, depending on the contract that a message was received with.
ContractDescription contract = new ContractDescription("IRequestReplyRouter");
ServiceEndpoint fakeDestination = new ServiceEndpoint(contract, clientBinding, new EndpointAddress(deadAddress));
ServiceEndpoint realDestination = new ServiceEndpoint(contract, clientBinding, new EndpointAddress(realAddress));
//create the endpoint list that contains the service endpoints we want to route to
List<ServiceEndpoint> backupList = new List<ServiceEndpoint>();
//add the endpoints in the order that the Routing Service should contact them
//first add the endpoint that we know will be down
//clearly, normally you wouldn't know that this endpoint was down by default
backupList.Add(fakeDestination);
//then add the endpoint that will work
//the Routing Service will attempt to send to this endpoint only if it
//encounters a TimeOutException or CommunicationException when sending
//to the previous endpoint in the list.
backupList.Add(realDestination);
//create the default RoutingConfiguration option
RoutingConfiguration rc = new RoutingConfiguration();
//add a MatchAll filter to the Routing Configuration's filter table
//map it to the list of endpoints defined above
//when a message matches this filter, it will be sent to the endpoints in the list in order
//if an endpoint is down or doesn't respond (which the first client won't
//since no service exists at that endpoint), the Routing Service will automatically move the message
//to the next endpoint in the list and try again.
rc.FilterTable.Add(new MatchAllMessageFilter(), backupList);
//create the Routing Behavior with the Routing Configuration and add it to the
//serviceHost's Description.
serviceHost.Description.Behaviors.Add(new RoutingBehavior(rc));
}
private static void ApplyOperationBehaviors(ContractDescription contractDescription)
{
foreach (OperationDescription description in contractDescription.Operations)
{
switch (description.Name)
{
case "Abandon":
case "Cancel":
case "Run":
case "Suspend":
case "Terminate":
case "Unsuspend":
EnsureDispatch(description);
break;
case "TransactedCancel":
case "TransactedRun":
case "TransactedSuspend":
case "TransactedTerminate":
case "TransactedUnsuspend":
EnsureDispatch(description);
EnsureTransactedInvoke(description);
break;
}
}
}
public ServiceContractGenerationContext (
ServiceContractGenerator serviceContractGenerator,
ContractDescription contract,
CodeTypeDeclaration contractType)
: this (serviceContractGenerator, contract, contractType, null)
{
}
public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,
ClientRuntime clientRuntime)
{
if (!TypeHelper.IsTypeOf<IClientMessageInspector>(_inspectorType)) return;
var inspector = TypeHelper.CreateInstance<IClientMessageInspector>(_inspectorType);
clientRuntime.MessageInspectors.Add(inspector);
}
/// <summary>
///
/// </summary>
/// <param name="contractDescription"></param>
/// <param name="endpoint"></param>
/// <param name="dispatchRuntime">The runtime object that can be used to modify the default service behavior.</param>
public void ApplyDispatchBehavior(
ContractDescription contractDescription,
ServiceEndpoint endpoint,
DispatchRuntime dispatchRuntime)
{
dispatchRuntime.InstanceProvider = this; // set the provider to manage service objects instantiation
}
public static void ComputeContractRequirements(ContractDescription contractDescription, out ChannelRequirements requirements)
{
requirements = new ChannelRequirements();
requirements.usesInput = false;
requirements.usesReply = false;
requirements.usesOutput = false;
requirements.usesRequest = false;
requirements.sessionMode = contractDescription.SessionMode;
for (int i = 0; i < contractDescription.Operations.Count; i++)
{
OperationDescription description = contractDescription.Operations[i];
bool isOneWay = description.IsOneWay;
if (!description.IsServerInitiated())
{
if (isOneWay)
{
requirements.usesInput = true;
}
else
{
requirements.usesReply = true;
}
}
else if (isOneWay)
{
requirements.usesOutput = true;
}
else
{
requirements.usesRequest = true;
}
}
}
void IContractBehavior.AddBindingParameters (
ContractDescription description,
ServiceEndpoint endpoint,
BindingParameterCollection parameters)
{
throw new NotImplementedException ();
}
internal MethodInfoOperationSelector(ContractDescription description, MessageDirection directionThatRequiresClientOpSelection)
{
operationMap = new Dictionary<object, string>();
for (int i = 0; i < description.Operations.Count; i++)
{
OperationDescription operation = description.Operations[i];
if (operation.Messages[0].Direction == directionThatRequiresClientOpSelection)
{
if (operation.SyncMethod != null)
{
if (!operationMap.ContainsKey(operation.SyncMethod.MethodHandle))
operationMap.Add(operation.SyncMethod.MethodHandle, operation.Name);
}
if (operation.BeginMethod != null)
{
if (!operationMap.ContainsKey(operation.BeginMethod.MethodHandle))
{
operationMap.Add(operation.BeginMethod.MethodHandle, operation.Name);
operationMap.Add(operation.EndMethod.MethodHandle, operation.Name);
}
}
if (operation.TaskMethod != null)
{
if (!operationMap.ContainsKey(operation.TaskMethod.MethodHandle))
{
operationMap.Add(operation.TaskMethod.MethodHandle, operation.Name);
}
}
}
}
}
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
{
var behavior =
dispatchRuntime.ChannelDispatcher.Host.Description.FindBehavior
<WebAuthenticationConfigurationBehavior,
WebAuthenticationConfigurationAttribute>(b => b.BaseBehavior);
if (behavior == null)
behavior = contractDescription.FindBehavior
<WebAuthenticationConfigurationBehavior,
WebAuthenticationConfigurationAttribute>(b => b.BaseBehavior);
if (behavior == null)
throw new ServiceAuthenticationConfigurationMissingException();
var authorizationBehavior =
dispatchRuntime.ChannelDispatcher.Host.Description.FindBehavior
<WebAuthorizationConfigurationBehavior,
WebAuthorizationConfigurationAttribute>(b => b.BaseBehavior);
Type authorizationPolicy = null;
if (authorizationBehavior != null)
authorizationPolicy = authorizationBehavior.AuthorizationPolicyType;
foreach (var endpointDispatcher in dispatchRuntime.ChannelDispatcher.Endpoints)
endpointDispatcher.DispatchRuntime.MessageInspectors.Add(
new ServiceAuthenticationInspector(
behavior.ThrowIfNull().AuthenticationHandler,
behavior.UsernamePasswordValidatorType,
behavior.RequireSecureTransport,
behavior.Source,
authorizationPolicy));
}
/// <summary>
/// 注册 服务实例创建提供者,将基于PIAB的实例生成器注入WCF扩展
/// </summary>
/// <param name="contractDescription"></param>
/// <param name="endpoint"></param>
/// <param name="dispatchRuntime"></param>
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,
DispatchRuntime dispatchRuntime)
{
Type serviceContractType = contractDescription.ContractType;
dispatchRuntime.InstanceProvider = new PolicyInjectionInstanceProvider(serviceContractType,
this.PolicyInjectorName);
}
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
{
if (dispatchRuntime == null)
throw new ArgumentNullException("dispatchRuntime");
dispatchRuntime.InstanceProvider = this.instanceProvider;
dispatchRuntime.InstanceContextInitializers.Add((IInstanceContextInitializer) new UnityInstanceContextInitializer());
}
void IContractBehavior.ApplyDispatchBehavior(ContractDescription description, ServiceEndpoint endpoint, DispatchRuntime dispatch)
{
if (dispatch.ClientRuntime != null)
{
dispatch.ClientRuntime.OperationSelector = new MethodInfoOperationSelector(description, MessageDirection.Output);
}
}
internal static ComProxy Create(IntPtr outer, ContractDescription contract, IProvideChannelBuilderSettings channelBuilderSettings)
{
DispatchProxy proxy = null;
ComProxy proxy3;
IntPtr zero = IntPtr.Zero;
ComProxy proxy2 = null;
try
{
proxy = new DispatchProxy(contract, channelBuilderSettings);
zero = OuterProxyWrapper.CreateDispatchProxy(outer, proxy);
proxy2 = new ComProxy(zero, proxy);
proxy3 = proxy2;
}
finally
{
if (proxy2 == null)
{
if (proxy != null)
{
((IDisposable) proxy).Dispose();
}
if (zero != IntPtr.Zero)
{
Marshal.Release(zero);
}
}
}
return proxy3;
}
public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
{
if (endpoint.Binding.CreateBindingElements().Find<MessageEncodingBindingElement>() == null)
{
bindingParameters.Add(new BinaryMessageEncodingBindingElement());
}
}
public void ApplyDispatchBehavior(ContractDescription description, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatch)
{
foreach (OperationDescription opDesc in description.Operations)
{
ApplyDataContractSurrogate(opDesc);
}
}
static void FillContract(IWmiInstance contract, ContractDescription contractDescription)
{
Fx.Assert(null != contractDescription, "contractDescription cannot be null");
contract.SetProperty(AdministrationStrings.Type, contractDescription.ContractType.Name);
if (null != contractDescription.CallbackContractType)
{
contract.SetProperty(AdministrationStrings.CallbackContract, ContractReference(contractDescription.CallbackContractType.Name));
}
contract.SetProperty(AdministrationStrings.Name, contractDescription.Name);
contract.SetProperty(AdministrationStrings.Namespace, contractDescription.Namespace);
contract.SetProperty(AdministrationStrings.SessionMode, contractDescription.SessionMode.ToString());
IWmiInstance[] operations = new IWmiInstance[contractDescription.Operations.Count];
for (int j = 0; j < operations.Length; ++j)
{
OperationDescription operationDescription = contractDescription.Operations[j];
Fx.Assert(operationDescription.Messages.Count > 0, "");
IWmiInstance operation = contract.NewInstance(AdministrationStrings.Operation);
FillOperation(operation, operationDescription);
operations[j] = operation;
}
contract.SetProperty(AdministrationStrings.Operations, operations);
FillBehaviorsInfo(contract, contractDescription.Behaviors);
}
/// <summary>
///
/// </summary>
/// <param name="contractDescription"></param>
/// <param name="endpoint"></param>
/// <param name="clientRuntime"></param>
public void ApplyClientBehavior(
ContractDescription contractDescription,
ServiceEndpoint endpoint,
ClientRuntime clientRuntime)
{
// empty
}
void IContractBehavior.ApplyDispatchBehavior (
ContractDescription description,
ServiceEndpoint endpoint,
DispatchRuntime dispatch)
{
throw new NotImplementedException ();
}
void IContractBehavior.ApplyClientBehavior (
ContractDescription description,
ServiceEndpoint endpoint,
ClientRuntime proxy)
{
throw new NotImplementedException ();
}
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime)
{
// We iterate over the operation descriptions in the contract and
// try to locate an DispatchBodyElementAttribute behaviors on each
// operation. If found, we add the operation, keyed by QName of the body element
// that selects which calls shall be dispatched to this operation to a
// dictionary.
Dictionary<XmlQualifiedName,string> dispatchDictionary = new Dictionary<XmlQualifiedName,string>();
foreach( OperationDescription operationDescription in contractDescription.Operations )
{
DispatchBodyElementAttribute dispatchBodyElement =
operationDescription.Behaviors.Find<DispatchBodyElementAttribute>();
if ( dispatchBodyElement != null )
{
dispatchDictionary.Add(dispatchBodyElement.QName, operationDescription.Name);
}
}
// Lastly, we create and assign and instance of our operation selector that
// gets the dispatch dictionary we've just created.
dispatchRuntime.OperationSelector =
new DispatchByBodyElementOperationSelector(
dispatchDictionary,
dispatchRuntime.UnhandledDispatchOperation.Name);
}
/// <summary>
///
/// </summary>
/// <param name="contractDescription"></param>
/// <param name="endpoint"></param>
/// <param name="bindingParameters"></param>
public void AddBindingParameters(
ContractDescription contractDescription,
ServiceEndpoint endpoint,
BindingParameterCollection bindingParameters)
{
// empty
}
/// <summary>
/// Implement to confirm that the contract and endpoint can support the contract behavior.
/// </summary>
/// <param name="contractDescription">The contract to validate.</param>
/// <param name="endpoint">The endpoint to validate.</param>
/// <exception cref="System.ArgumentNullException">The <paramref name="contractDescription"/> is <c>null</c>.</exception>
public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint)
{
Argument.IsNotNull("contractDescription", contractDescription);
var messageDescriptions = contractDescription.Operations.SelectMany(operationDescription => operationDescription.Messages);
foreach (var messageDescription in messageDescriptions)
{
ValidateMessagePartDescription(messageDescription.Body.ReturnValue);
var messagePartDescriptions = messageDescription.Body.Parts;
foreach (var messagePartDescription in messagePartDescriptions)
{
ValidateMessagePartDescription(messagePartDescription);
}
var messageHeaderDescriptions = messageDescription.Headers;
foreach (var messageHeaderDescription in messageHeaderDescriptions)
{
ValidateBinarySerializableType(messageHeaderDescription.Type);
}
}
}
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,
DispatchRuntime dispatchRuntime)
{
if (!TypeHelper.IsTypeOf<IDispatchMessageInspector>(_inspectorType)) return;
var inspector = TypeHelper.CreateInstance<IDispatchMessageInspector>(_inspectorType);
dispatchRuntime.MessageInspectors.Add(inspector);
}
internal static ComProxy Create(IntPtr outer, ContractDescription contract, IProvideChannelBuilderSettings channelBuilderSettings)
{
DispatchProxy proxy = null;
IntPtr inner = IntPtr.Zero;
ComProxy comProxy = null;
try
{
proxy = new DispatchProxy(contract, channelBuilderSettings);
inner = OuterProxyWrapper.CreateDispatchProxy(outer, proxy);
comProxy = new ComProxy(inner, proxy);
return comProxy;
}
finally
{
if (comProxy == null)
{
if (proxy != null)
{
((IDisposable)proxy).Dispose();
}
if (inner != IntPtr.Zero)
{
Marshal.Release(inner);
}
}
}
}
internal void CreateMyDataContractSerializerOperationBehaviors(ContractDescription contractDescription)
{
foreach (var operation in contractDescription.Operations)
{
CreateMyDataContractSerializerOperationBehavior(operation);
}
}
public OperationDescription (string name,
ContractDescription declaringContract)
{
this.name = name;
contract = declaringContract;
is_initiating = true;
}
/// <summary>
/// Add the Ping method to the existing contract
/// </summary>
private void AddPingToContractDescription(ContractDescription contractDescription)
{
OperationDescription pingOperationDescription = new OperationDescription(PingOperationName, contractDescription);
MessageDescription inputMessageDescription = new MessageDescription(
GetAction(contractDescription, PingOperationName),
MessageDirection.Input);
MessageDescription outputMessageDescription = new MessageDescription(
GetAction(contractDescription, PingResponse),
MessageDirection.Output);
MessagePartDescription returnValue = new MessagePartDescription("PingResult", contractDescription.Namespace);
returnValue.Type = typeof(DateTime);
outputMessageDescription.Body.ReturnValue = returnValue;
inputMessageDescription.Body.WrapperName = PingOperationName;
inputMessageDescription.Body.WrapperNamespace = contractDescription.Namespace;
outputMessageDescription.Body.WrapperName = PingResponse;
outputMessageDescription.Body.WrapperNamespace = contractDescription.Namespace;
pingOperationDescription.Messages.Add(inputMessageDescription);
pingOperationDescription.Messages.Add(outputMessageDescription);
pingOperationDescription.Behaviors.Add(new DataContractSerializerOperationBehavior(pingOperationDescription));
pingOperationDescription.Behaviors.Add(new PingOperationBehavior());
contractDescription.Operations.Add(pingOperationDescription);
}
public ClientRuntimeChannel(System.ServiceModel.Dispatcher.ClientRuntime runtime, ContractDescription contract, TimeSpan openTimeout, TimeSpan closeTimeout, IChannel contextChannel, IChannelFactory factory, MessageVersion messageVersion, System.ServiceModel.EndpointAddress remoteAddress, Uri via)
{
if (runtime == null)
{
throw new ArgumentNullException("runtime");
}
if (messageVersion == null)
{
throw new ArgumentNullException("messageVersion");
}
this.runtime = runtime;
this.remote_address = remoteAddress;
if (runtime.Via == null)
{
runtime.Via = via ?? (remote_address != null ? remote_address.Uri : null);
}
this.contract = contract;
this.message_version = messageVersion;
default_open_timeout = openTimeout;
default_close_timeout = closeTimeout;
_processDelegate = new ProcessDelegate(Process);
requestDelegate = new RequestDelegate(Request);
sendDelegate = new SendDelegate(Send);
AllowInitializationUI = true;
if (contextChannel != null)
{
channel = contextChannel;
}
else
{
var method = factory.GetType().GetMethod("CreateChannel", new Type[] {
typeof(System.ServiceModel.EndpointAddress),
typeof(Uri)
});
try
{
channel = (IChannel)method.Invoke(factory, new object[] {
remote_address,
Via
});
this.factory = factory;
}
catch (System.Reflection.TargetInvocationException ex)
{
if (ex.InnerException != null)
{
throw ex.InnerException;
}
else
{
throw;
}
}
}
}
internal WebServiceEndpoint(ContractDescription contract, EndpointAddress address)
: base(contract, new WebHttpBinding(), address)
{
Behaviors.Add(new WebHttpBehavior());
}
public ServiceEndpoint(ContractDescription contract)
{
_contract = contract ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(contract));
}
public ServiceEndpoint(ContractDescription contract, Binding binding, EndpointAddress address)
{
_contract = contract ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(contract));
Binding = binding;
Address = address;
}
