C# Protocols类代码示例

 public RejectRule(FireWallChains chain, string networkInterface, Protocols protocol, ICMPTypes? icmpType, IPAddress source, IPAddress sourceNetworkMask,
     FirewallPort sourcePort, IPAddress destination, IPAddress destinationNetworkMask, FirewallPort destinationPort,
     ConnectionStateTypes[] connectionStates,string note,RejectOptions rejectWith) :
     base(chain,networkInterface, protocol, icmpType, source, sourceNetworkMask, sourcePort, destination, destinationNetworkMask, destinationPort, connectionStates,note) 
 {
     _rejectWith = rejectWith;
 }

        public bool IsGameContinuation(Protocols.UciGameData data,
            out List<Move> extra_moves)
        {
            Debug.Assert(data != null);
            extra_moves = null;

            if (m_initial_position != data.m_initial_position
                || m_moves.Count > (data.m_moves == null ? 0 : data.m_moves.Count))
            {
                return false;
            }

            for (int i = 0; i < m_moves.Count; ++i)
            {
                if (NotationHelper.ToCoordinateNotation(m_moves[i])
                    != data.m_moves[i])
                {
                    return false;
                }
            }

            if (data.m_moves != null && data.m_moves.Count > m_moves.Count)
            {
                extra_moves = new List<Move>(data.m_moves.Count - m_moves.Count);
                for (int i = m_moves.Count; i < data.m_moves.Count; ++i)
                {
                    extra_moves.Add(Move.MakeFromCoordinates(data.m_moves[i]));
                }
            }

            return true;
        }

 public CommandSetPosition(Protocols.UciGameData data)
 {
     if (data == null)
     {
         throw new ArgumentNullException();
     }
     m_uci_data = data;
 }

 public Tunnel(bool is_server, ulong remote_userid, Service service, Protocols protocols, ushort server_port)
 {
     _remote_userid = remote_userid;
     _is_server = is_server;
     _service = service;
     _server_port = server_port;
     _protocols = protocols;
     state = TunnelState.Initial;
 }

 /// <summary>
 /// Returns signed cookies that grants universal access to private content until a given date.
 /// </summary>
 /// <param name="protocol">The protocol used to access content using signed cookies.</param>
 /// <param name="distributionDomain">The domain name of the distribution.</param>
 /// <param name="resourcePath">The path for the resource.</param>
 /// <param name="privateKey">The private key file. RSA private key (.pem) are supported.</param>
 /// <param name="keyPairId">The key pair id corresponding to the private key file given.</param>
 /// <param name="expiresOn">The expiration date till which content can be accessed using the generated cookies.</param>
 /// <returns>The signed cookies.</returns>
 public static CookiesForCannedPolicy GetCookiesForCannedPolicy(Protocols protocol,
                                         string distributionDomain,
                                         TextReader privateKey,
                                         string resourcePath,
                                         string keyPairId,
                                         DateTime expiresOn)
 {
     string url = GenerateResourcePath(protocol, distributionDomain, resourcePath);
     return GetCookiesForCannedPolicy(url, keyPairId, privateKey, expiresOn);
 }

        /// <summary>
        /// Initializes a new instance of the Protocol class to be extended by derived types.
        /// </summary>
        /// <param name="connectionString">Connection string to be parsed.</param>
        /// <param name="protocol">Derived protocol type.</param>
        protected Protocol(string connectionString, Protocols protocol)
        {
            this.Type = protocol;
            var fields = Parse(connectionString);
            var properties = this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);

            foreach (var property in properties.Where(property => property.Name != "Type" && fields.ContainsKey(property.Name)))
            {
                property.SetValue(this, fields[property.Name], null);
            }
        }

 /// <summary>
 /// Returns signed cookies that grants universal access to private content until a given date.
 /// </summary>
 /// <param name="protocol">The protocol used to access content using signed cookies.</param>
 /// <param name="distributionDomain">The domain name of the distribution.</param>
 /// <param name="resourcePath">The path for the resource.</param>
 /// <param name="privateKey">The private key file. RSA private key (.pem) are supported.</param>
 /// <param name="keyPairId">The key pair id corresponding to the private key file given.</param>
 /// <param name="expiresOn">The expiration date till which content can be accessed using the generated cookies.</param>
 /// <returns>The signed cookies.</returns>
 public static CookiesForCannedPolicy GetCookiesForCannedPolicy(Protocols protocol,
                                         string distributionDomain,
                                         FileSystemInfo privateKey,
                                         string resourcePath,
                                         string keyPairId,
                                         DateTime expiresOn)
 {
     using (var reader = new StreamReader(File.OpenRead(privateKey.FullName)))
     {
         return GetCookiesForCannedPolicy(protocol, distributionDomain, reader, resourcePath, keyPairId, expiresOn);
     }
 }

 public LogRule(FireWallChains chain, string networkInterface, Protocols protocol, ICMPTypes? icmpType, IPAddress source, IPAddress sourceNetworkMask,
     FirewallPort sourcePort, IPAddress destination, IPAddress destinationNetworkMask, FirewallPort destinationPort,
     ConnectionStateTypes[] connectionStates,string note,LogLevels level,string logPrefix,bool logTcpOptions,bool logTcpSequence,bool logIPOptions) :
     base(chain,networkInterface, protocol, icmpType, source, sourceNetworkMask, sourcePort, destination, destinationNetworkMask, destinationPort, connectionStates,note) 
 {
     _logLevel = level;
     _logPrefix = logPrefix;
     _logTcpOptions = logTcpOptions;
     _logTcpSequence = logTcpSequence;
     _logIPOptions = logIPOptions;
     if (_logPrefix != null)
     {
         if (_logPrefix.Length > 29)
             throw new Exception("The log prefix " + _logPrefix + " is too long, it cannot exceed 29 characters.");
     }
 }

        protected Protocols.Http.Request CreateRequest(Protocols.Http.Methods.Base method, Uri uri,
            string contentType)
        {
            Protocols.Http.Request request;
            MultisourcedStream fullStream;
            long fullContentLength;

            request = new Protocols.Http.Request(method, uri);

            fullStream = MakeStream(out fullContentLength);

            request.Headers.Add(new Protocols.Http.Message.ContentLengthHeader(fullContentLength));

            request.Body.IsChunked = false;
            request.Body.SendStream = fullStream;

            return request;
        }

 public ULogRule(FireWallChains chain, string networkInterface, Protocols protocol, ICMPTypes? icmpType, IPAddress source, IPAddress sourceNetworkMask,
     FirewallPort sourcePort, IPAddress destination, IPAddress destinationNetworkMask, FirewallPort destinationPort,
     ConnectionStateTypes[] connectionStates,string note,byte logGroup,string prefix,uint bytesToCopy,ushort queueSize) :
     base(chain,networkInterface, protocol, icmpType, source, sourceNetworkMask, sourcePort, destination, destinationNetworkMask, destinationPort, connectionStates,note) 
 {
     _logGroup = logGroup;
     _prefix = prefix;
     _bytesToCopy = bytesToCopy;
     _queueSize = queueSize;
     if (_prefix != null)
     {
         if (_prefix.Length > 32)
             throw new Exception("Unable to create ULog rule with a message prefix greater than 32 characters.");
     }
     if (_logGroup < 1 || _logGroup > 32)
         throw new Exception("Unable to create ULog rule with a log group not from 1-32.");
     if (_queueSize < 1)
         throw new Exception("Unable to create a ULog rule with a queue size less than 1.");
 }

        public Protocols.ToolkitResultProtocol AcceptQuote(Protocols.Contracts.AcceptQuoteSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.AcceptQuoteSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Contracts.AcceptQuoteSetup(setupParam.QuoteIDNum);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.QuoteIDNum = setupParam.QuoteIDNum;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.AcceptDate = setupParam.AcceptDate;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.WipBin = setupParam.WipBin;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.AcceptQuote(setup) );
        }

        public Protocols.ToolkitResultProtocol ApplyEco(Protocols.DepotRepair.ApplyEcoSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit toolkit = new FChoice.Toolkits.Clarify.DepotRepair.DepotRepairToolkit( session );
            FChoice.Toolkits.Clarify.DepotRepair.ApplyEcoSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.DepotRepair.ApplyEcoSetup(setupParam.DemandDetailObjid, setupParam.EcoHeaderIDNum);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.DemandDetailObjid = setupParam.DemandDetailObjid;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.EcoHeaderIDNum = setupParam.EcoHeaderIDNum;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.CreateDate = setupParam.CreateDate;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.ApplyEco(setup) );
        }

		/// <summary>
		/// Returns null if the custom settings file is not found so check for null object reference.
		/// </summary>
		internal List<string> ReadCustomDispatcherDestinationSettings(Protocols protocol)
		{
			// This generates a sample settings file for future reference
			/*this.dispatcherDestinations.Add("Just testing this stuff.");
			var serializer = new XmlSerializer(typeof(List<string>));
			using (FileStream stream = new FileStream("DispatcherDestinations.xml", FileMode.Create))
			{
				serializer.Serialize(stream, this.dispatcherDestinations);
			}*/

			// Make sure that settings are red and cached only once during the object lifetime
			if (this.dispatcherDestinations == null)
			{
				this.dispatcherDestinations = new List<string>();
				var path = Path.Combine(Settings.NBugDirectory, "DispatcherDestinations.xml");

				if (!File.Exists(path))
				{
					path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Docs\\ASFT\\Dev\\_Tools\\Settings\\DispatcherDestinations.xml");

					if (!File.Exists(path))
					{
						return null;
					}
				}

				var serializer = new XmlSerializer(typeof(List<string>));
				using (var stream = new FileStream(path, FileMode.Open))
				{
					this.dispatcherDestinations = (List<string>)serializer.Deserialize(stream);
				} 
			}

			return (from destination in this.dispatcherDestinations
							where Enum.Parse(typeof(Protocols), Protocol.Parse(destination)["Type"], true).Equals(protocol)
							select destination).ToList();
		}

        public Protocols.ToolkitResultProtocol LogContractNote(Protocols.Contracts.LogContractNoteSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.LogContractNoteSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Contracts.LogContractNoteSetup(setupParam.ContractIDNum, setupParam.Notes);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.ContractIDNum = setupParam.ContractIDNum;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.ActionType = setupParam.ActionType;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.Notes = setupParam.Notes;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.InternalUseOnlyNotes = setupParam.InternalUseOnlyNotes;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.LogDate = setupParam.LogDate;
            }

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
            }

            if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
            {
                foreach(Protocols.AdditionalFieldProtocol field in setupParam.AdditionalFields){setup.AdditionalFields.Append( field.FieldName, field.FieldType, field.FieldValue);}
            }

            return new Protocols.ToolkitResultProtocol( toolkit.LogContractNote(setup) );
        }

        public Protocols.ToolkitResultProtocol DeleteSitePart(Protocols.Contracts.DeleteSitePartSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.DeleteSitePartSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Contracts.DeleteSitePartSetup(setupParam.SitePartObjid);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.SitePartObjid = setupParam.SitePartObjid;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.DeleteSitePart(setup) );
        }