// Methods public ServiceEndpoint(ContractDescription contract) { if (contract == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract"); } this.contract = contract; }
public ServiceEndpoint(ContractDescription contract, Binding binding, EndpointAddress address) { if (contract == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract"); } this.contract = contract; this.binding = binding; this.address = address; }
public static void Ctor_Taking_Name_Initializes() { const string expectedName = "testName"; ContractDescription cd = new ContractDescription(expectedName); Assert.Equal<string>(expectedName, cd.Name); Assert.Equal<string>("http://tempuri.org/", cd.Namespace); Assert.Null(cd.ContractType); Assert.Null(cd.CallbackContractType); Assert.NotNull(cd.Operations); Assert.Equal<int>(0, cd.Operations.Count); Assert.NotNull(cd.Behaviors); Assert.Equal<int>(0, cd.Behaviors.Count); Assert.NotNull(cd.ContractBehaviors); Assert.Equal<int>(0, cd.ContractBehaviors.Count); }
// Methods public ServiceContractGenerationContext(ServiceContractGenerator serviceContractGenerator, ContractDescription contract, CodeTypeDeclaration contractType) { this.operations = new Collection<OperationContractGenerationContext>(); if (serviceContractGenerator == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("serviceContractGenerator")); } if (contract == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("contract")); } if (contractType == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("contractType")); } this.serviceContractGenerator = serviceContractGenerator; this.contract = contract; this.contractType = contractType; }
// Methods public OperationDescription(string name, ContractDescription declaringContract) { this.validateRpcWrapperName = true; if (name == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name"); } if (name.Length == 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("name", SR.GetString("SFxOperationDescriptionNameCannotBeEmpty"))); } this.name = new XmlName(name, true); if (declaringContract == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("declaringContract"); } this.declaringContract = declaringContract; this.isInitiating = true; this.isTerminating = false; this.faults = new FaultDescriptionCollection(); this.messages = new MessageDescriptionCollection(); this.behaviors = new KeyedByTypeCollection<IOperationBehavior>(); this.knownTypes = new Collection<Type>(); }
public static void ProtectionLevel_Property_Sets(ProtectionLevel level) { ContractDescription cd = new ContractDescription("test"); cd.ProtectionLevel = level; Assert.Equal<ProtectionLevel>(level, cd.ProtectionLevel); }
public void AddBindingParameters(ContractDescription description, ServiceEndpoint endpoint, BindingParameterCollection parameters) { return; }
private void VisitContract(ContractDescription contract) { this.Visit(contract); foreach (OperationDescription description in contract.Operations) { this.Visit(description); } }
private static bool IsDuplex(ContractDescription contract) { foreach (OperationDescription description in contract.Operations) { if (description.IsServerInitiated()) { return true; } } return false; }
public void Validate(ContractDescription description, ServiceEndpoint endpoint) { return; }
void IContractBehavior.ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime) { }
public static void Name_Property_With_Empty_String_Throws() { ContractDescription cd = new ContractDescription("test"); Assert.Throws <ArgumentOutOfRangeException>(() => cd.Name = String.Empty); }
private bool LoadBizProxy(string bindingName, string bindingConfigName, string address) { Binding binding; Uri uri; ServiceEndpoint serviceEndpoint; ChannelFactory <IServiceString> channelFactory; //ChannelFactory<IServiceAsync> _ChannelFactoryAsync; try { if (this.listServicePool.Count == 0) { //this.LoadBinding(); //this.LoadBinding(this.GetttributeInnerXml("system.serviceModel", 0)); //this.LoadBinding(Factory.FactoryConfig.XmlDocument.SelectNodes(this.GetType().FullName.Replace(".", "/") + "/system.serviceModel").Item(0).InnerXml); } switch (bindingName) { case "BasicHttpBinding": if (bindingConfigName.IsNullOrEmpty()) { binding = this.GetBasicHttpBinding(); } else { binding = this.GetBasicHttpBinding(bindingConfigName); } break; case "CustomBinding": if (bindingConfigName.IsNullOrEmpty()) { binding = this.GetCustomBinding(); } else { binding = this.GetCustomBinding(bindingConfigName); } break; case "NetMsmqBinding": if (bindingConfigName.IsNullOrEmpty()) { binding = this.GetNetMsmqBinding(); } else { binding = this.GetNetMsmqBinding(bindingConfigName); } break; case "NetNamedPipeBinding": if (bindingConfigName.IsNullOrEmpty()) { binding = this.GetNetNamedPipeBinding(); } else { binding = this.GetNetNamedPipeBinding(bindingConfigName); } break; //case "NetPeerTcpBinding": // binding = new NetPeerTcpBinding(bindingConfigName); // ((NetPeerTcpBinding)binding).MaxReceivedMessageSize = 2147483647; // break; case "NetTcpBinding": if (bindingConfigName.IsNullOrEmpty()) { binding = this.GetNetTcpBinding(); } else { binding = this.GetNetTcpBinding(bindingConfigName); } break; case "WSDualHttpBinding": if (bindingConfigName.IsNullOrEmpty()) { binding = this.GetWSDualHttpBinding(); } else { binding = this.GetWSDualHttpBinding(bindingConfigName); } break; case "WSHttpBinding": if (bindingConfigName.IsNullOrEmpty()) { binding = this.GetWSHttpBinding(); } else { binding = this.GetWSHttpBinding(bindingConfigName); } break; default: binding = null; break; } try { string[] tmps = this.GetAttribute("Timeout").Split(','); int hours = tmps[0].ToInt(); int minute = tmps[1].ToInt(); int seconds = tmps[2].ToInt(); binding.OpenTimeout = new TimeSpan(hours, minute, seconds); binding.CloseTimeout = new TimeSpan(hours, minute, seconds); binding.SendTimeout = new TimeSpan(hours, minute, seconds); binding.ReceiveTimeout = new TimeSpan(hours, minute, seconds); } catch (Exception ex) { binding.OpenTimeout = new TimeSpan(0, 10, 0); binding.CloseTimeout = new TimeSpan(0, 10, 0); binding.SendTimeout = new TimeSpan(0, 10, 0); binding.ReceiveTimeout = new TimeSpan(0, 10, 0); DiagnosticsTool.MyTrace(ex); } //_Binding.ReceiveTimeout = new TimeSpan(0, 10, 0); uri = new Uri(address); serviceEndpoint = new ServiceEndpoint(ContractDescription.GetContract(this.GetType()), binding, new EndpointAddress(uri)); channelFactory = new ChannelFactory <IServiceString>(serviceEndpoint); //this.Service = _ChannelFactory.CreateChannel(); //_ServiceEndpoint = new ServiceEndpoint(ContractDescription.GetContract(this.GetType()), _Binding, new EndpointAddress(_Uri)); //_ChannelFactoryAsync = new ChannelFactory<IServiceAsync>(_ServiceEndpoint); //this.ServiceAsync = _ChannelFactoryAsync.CreateChannel(); this.listServicePool.Add(new ServiceInfo() { Service = channelFactory.CreateChannel(), IsBusy = false }); return(true); } catch (AtomusException exception) { throw exception; } catch (Exception exception) { throw new AtomusException(exception); } }
/// <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> public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint) { _contractBehavior.Validate(contractDescription, endpoint); }
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime) { dispatchRuntime.OperationSelector = new DispatchByBodyElementOperationSelector(); }
public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime) { // this is a dispatch-side behavior which doesn't require // any action on the client return; }
public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { // no binding parameters need to be set here return; }
public static void CallbackContractType_Property_Sets(Type contractType) { ContractDescription cd = new ContractDescription("test"); cd.CallbackContractType = contractType; Assert.Equal<Type>(contractType, cd.CallbackContractType); }
public void ApplyClientBehavior(ContractDescription description, ServiceEndpoint endpoint, ClientRuntime proxy) { return; }
public static void Name_Property_With_Null_Throws() { ContractDescription cd = new ContractDescription("test"); Assert.Throws<ArgumentNullException>(() => cd.Name = null); }
public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { }
void IContractBehavior.AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { }
void IContractBehavior.ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, ClientRuntime clientRuntime) { }
public static void Namespace_Property_Set_With_Invalid_Value_Throws(string nameSpace) { ContractDescription cd = new ContractDescription("test"); Assert.Throws <ArgumentException>(() => cd.Namespace = nameSpace); }
public void ApplyDispatchBehavior(ContractDescription description, ServiceEndpoint endpoint, DispatchRuntime dispatch) { this.contractDescription = description; Debug.WriteLine("Added the {0} contract description to exporter.", description.Name); }
public static string GetFaultMessageAction(ContractDescription contractName, string opname, string action) { return(ServiceUtility.GetMessageAction(contractName, opname, action, /* isResponse */ false) + typeof(DomainServiceFault).Name); }
public static void ProtectionLevel_Property_Set_With_Invalid_Value_Throws() { ContractDescription cd = new ContractDescription("test"); Assert.Throws <ArgumentOutOfRangeException>(() => cd.ProtectionLevel = (ProtectionLevel)99); }
public static void Name_Property_With_Null_Throws() { ContractDescription cd = new ContractDescription("test"); Assert.Throws <ArgumentNullException>(() => cd.Name = null); }
public ServiceContractGenerationContext CreateContext(ContractDescription contractDescription) { this.VisitContract(contractDescription); return this.context; }
/// <summary> /// Implements a modification or extension of the client across a contract. /// </summary> /// <param name="contractDescription">The contract description to be modified.</param> /// <param name="endpoint">The endpoint that exposes the contract.</param> /// <param name="dispatchRuntime">The dispatch runtime that controls service execution.</param> public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime) { ReplaceSerializerOperationBehavior(contractDescription); }
private void Visit(ContractDescription contractDescription) { bool flag = IsDuplex(contractDescription); this.contractMemberScope = new UniqueCodeIdentifierScope(); this.callbackMemberScope = flag new UniqueCodeIdentifierScope() null; UniqueCodeNamespaceScope scope = new UniqueCodeNamespaceScope(this.parent.NamespaceManager.EnsureNamespace(contractDescription.Namespace)); CodeTypeDeclaration codeType = this.typeFactory.CreateInterfaceType(); CodeTypeReference reference = scope.AddUnique(codeType, contractDescription.CodeName, IContract); CodeTypeDeclaration declaration2 = null; CodeTypeReference reference2 = null; if (flag) { declaration2 = this.typeFactory.CreateInterfaceType(); reference2 = scope.AddUnique(declaration2, contractDescription.CodeName + Callback, IContract); } this.context = new ServiceContractGenerationContext(this.parent, contractDescription, codeType, declaration2); this.context.Namespace = scope.CodeNamespace; this.context.TypeFactory = this.typeFactory; this.context.ContractTypeReference = reference; this.context.DuplexCallbackTypeReference = reference2; this.AddServiceContractAttribute(this.context); }
/// <summary> /// The constructor for this. In addition to initializing all of the parameters it attempts to open and connect /// to the network. This is done asynchronously with ProcessOpen being called either after a timeout (hard coded to 1 minute) /// or when a response is received. /// </summary> /// <param name="nodeName">the unique nodename</param> /// <param name="networkName">the name of the network</param> /// <param name="password">the password for the network</param> public bool PeerChannelWrapperStart(String nodeName, String networkName, String password) { CheckDisposed(); ////////////////////////////////////////////////////////////////////////// //Initialize all the parameters... ////////////////////////////////////////////////////////////////////////// mNodeName = nodeName; mNetworkName = networkName; //password cannot be empty otherwise mFactory.CreateChannel() below will throw an exception if (string.IsNullOrEmpty(password)) { mPassword = "******"; } else { mPassword = password.Trim(); } //Construct InstanceContext to handle messages on callback interface. mInstanceContext = new InstanceContext(this); ////////////////////////////////////////////////////////////////////////// //Create the PeerTcpBinding ////////////////////////////////////////////////////////////////////////// NetPeerTcpBinding p2pBinding = new NetPeerTcpBinding(); p2pBinding.Name = "BindingDefault"; p2pBinding.Port = 0; //dynamic port p2pBinding.MaxReceivedMessageSize = 70000000; //set the max message size in bytes (70mb) p2pBinding.Resolver.Mode = PeerResolverMode.Pnrp; //use the standard pnrp for our resolver to find the network ////////////////////////////////////////////////////////////////////////// //create the Endpoint Address and Service Endpoint. ////////////////////////////////////////////////////////////////////////// String bindingInfo = "net.p2p://"; //the endpoint address for a NetPeerTcpBinding must start with net.p2p EndpointAddress epa = new EndpointAddress(String.Concat(bindingInfo, mNetworkName)); ServiceEndpoint serviceEndpoint = new ServiceEndpoint(ContractDescription.GetContract(typeof(IPeerChannel)), p2pBinding, epa); ////////////////////////////////////////////////////////////////////////// // Create the participant with the given endpoint configuration // Each participant opens a duplex channel to the mesh // participant is an instance of the channel to the mesh ////////////////////////////////////////////////////////////////////////// mFactory = new DuplexChannelFactory <IPeerChannelWrapper>(mInstanceContext, serviceEndpoint); mFactory.Credentials.Peer.MeshPassword = mPassword; mParticipant = mFactory.CreateChannel(); mPicture = new PictureHelper(mParticipant.SharePicture, mNodeName); mTextPeerChannelHelper = new ChatHelper(mParticipant.ShareTextMessage); mFilePeerChannelHelper = new FileHelper(mParticipant.ShareFile); mStreamedAudio = new StreamingHelper(mParticipant, mNodeName, mParticipant.ShareStreamedAudio); mStreamedVideo = new StreamingHelper(mParticipant, mNodeName, mParticipant.ShareStreamedVideo); ////////////////////////////////////////////////////////////////////////// //Start an asynchronous call that will try to open a connection to the network. //if one is not found, but the pnrp resolver is running then a new network will be //created. ////////////////////////////////////////////////////////////////////////// try { AsyncCallback callBack = new AsyncCallback(ProcessOpen); TimeSpan ts = new TimeSpan(0, 1, 0); //wait a minute mParticipant.BeginOpen(ts, callBack, this); } catch (CommunicationException e) { System.Windows.MessageBox.Show(String.Format("Error while joining the network: {0}", e.Message)); mParticipant = null; return(false); } return(true); }
private static IEnumerableIServiceContractGenerationExtension EnumerateBehaviorExtensions(ContractDescription contract) { EnumerateBehaviorExtensionsd__8 d__ = new EnumerateBehaviorExtensionsd__8(-2); d__.3__contract = contract; return d__; }
/// <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> public void Validate( ContractDescription contractDescription, ServiceEndpoint endpoint) { // Not implemented. }
public static void Namespace_Property_Set_With_Invalid_Value_Throws(string nameSpace) { ContractDescription cd = new ContractDescription("test"); Assert.Throws<ArgumentException>(() => cd.Namespace = nameSpace); }
protected override ServiceEndpoint CreateDescription() { return(new ServiceEndpoint(ContractDescription.GetContract(typeof(ICtorUseCase2)))); }
public static void ProtectionLevel_Property_Set_With_Invalid_Value_Throws() { ContractDescription cd = new ContractDescription("test"); Assert.Throws<ArgumentOutOfRangeException>(() => cd.ProtectionLevel = (ProtectionLevel)99); }
public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime) { dispatchRuntime.ChannelDispatcher.ChannelInitializers.Add(this); }
public static void Name_Property_Sets(string name) { ContractDescription cd = new ContractDescription("test"); cd.Name = name; Assert.Equal<string>(name, cd.Name); }
public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { }
public static void Name_Property_With_Empty_String_Throws() { ContractDescription cd = new ContractDescription("test"); Assert.Throws<ArgumentOutOfRangeException>(() => cd.Name = String.Empty); }
public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime) { }
internal OperationDescription(string name, ContractDescription declaringContract, bool validateRpcWrapperName) : this(name, declaringContract) { this.validateRpcWrapperName = validateRpcWrapperName; }
void IContractBehavior.ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime) { dispatchRuntime.InstanceProvider = this; }
void IContractBehavior.Validate(ContractDescription contractDescription, ServiceEndpoint endpoint) { }
public CSharpClientBuilderBuilder(ContractDescription contract) { _contract = contract; }
public ServiceContractGenerationContext(ServiceContractGenerator serviceContractGenerator, ContractDescription contract, CodeTypeDeclaration contractType, CodeTypeDeclaration duplexCallbackType) : this(serviceContractGenerator, contract, contractType) { this.duplexCallbackType = duplexCallbackType; }
public PipeCommunication() : base(new ServiceEndpoint(ContractDescription.GetContract(typeof(IPipeCommunication)), new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/sdc/FoxSDC-Agent-Comm"))) { }
public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint) { }
public static string GetResponseMessageAction(ContractDescription contractName, string opname, string action) { return(ServiceUtility.GetMessageAction(contractName, opname, action, /* isResponse */ true)); }