C# TokenTypes类代码示例

        /// <summary>
        /// Initializes a new instance of the <see cref="CilRuntimeType"/> class.
        /// </summary>
        /// <param name="moduleTypeSystem">The module type system.</param>
        /// <param name="token">The token.</param>
        /// <param name="typeDefRow">The type def row.</param>
        /// <param name="maxField">The max field.</param>
        /// <param name="maxMethod">The max method.</param>
        /// <param name="packing">The packing.</param>
        /// <param name="size">The size.</param>
        public CilRuntimeType(IModuleTypeSystem moduleTypeSystem, TokenTypes token, TypeDefRow typeDefRow, TokenTypes maxField, TokenTypes maxMethod, int packing, int size)
            : base(moduleTypeSystem, (int)token)
        {
            this.baseTypeToken = typeDefRow.Extends;
            this.nameIdx = typeDefRow.TypeNameIdx;
            this.namespaceIdx = typeDefRow.TypeNamespaceIdx;

            base.Attributes = typeDefRow.Flags;
            base.Pack = packing;
            base.Size = size;

            // Load all fields of the type
            int members = maxField - typeDefRow.FieldList;
            if (0 < members)
            {
                int i = (int)(typeDefRow.FieldList & TokenTypes.RowIndexMask) - 1;
                base.Fields = new ReadOnlyRuntimeFieldListView((IModuleTypeSystemInternalList)moduleTypeSystem, i, members);
            }
            else
            {
                base.Fields = ReadOnlyRuntimeFieldListView.Empty;
            }

            // Load all methods of the type
            members = maxMethod - typeDefRow.MethodList;
            if (0 < members)
            {
                int i = (int)(typeDefRow.MethodList & TokenTypes.RowIndexMask) - 1;
                base.Methods = new ReadOnlyRuntimeMethodListView((IModuleTypeSystemInternalList)moduleTypeSystem, i, members);
            }
            else
            {
                base.Methods = ReadOnlyRuntimeMethodListView.Empty;
            }
        }

 public Parameter(TokenTypes tokType, object column, object value)
 {
     this.TokType = tokType;
     this.ParType = ParameterType.Initial;
     this.Column = column.ToString();
     this.Value = value;
 }

        public void Roundtrip_BugWithPath(TokenTypes types)
        {
            var parameters = new Dictionary<string, string>
            {
                { "template", "thumbnailUrl" },
                { "url", "C:\\Work\\Samsung\\InMotion\\InMotion.Frontend\\media\\1594\\jazz-initiative.jpg" },
            };

            List<string> keysAndValues = new List<string>(parameters.Count * 2);
            foreach (var keyValuePair in parameters)
            {
                keysAndValues.Add(keyValuePair.Key);
                keysAndValues.Add(keyValuePair.Value);
            }

            SecureTokenBuilder tokenBuilder = new SecureTokenBuilder("2z!6Wd0vghEQtkalNS9a", types);
            string token = tokenBuilder.EncodeObject(keysAndValues.ToArray());

            string[] values = (string[])tokenBuilder.DecodeObject(token);

            for(int i = 0; i < keysAndValues.Count; ++i)
            {
                Assert.AreEqual(keysAndValues[i], values[i]);
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="GenericParamRow"/> struct.
 /// </summary>
 /// <param name="number">The number.</param>
 /// <param name="flags">The flags.</param>
 /// <param name="ownerTableIdx">The owner table idx.</param>
 /// <param name="nameStringIdx">The name string idx.</param>
 public GenericParamRow(ushort number, GenericParamAttributes flags, TokenTypes ownerTableIdx, TokenTypes nameStringIdx)
 {
     _number = number;
     _flags = flags;
     _ownerTableIdx = ownerTableIdx;
     _nameStringIdx = nameStringIdx;
 }

 /// <summary>
 /// Writes a coded index value in a metadata table.
 /// </summary>
 /// <param name="token">The indexed token.</param>
 public void WriteHasCustomAttributeIndex(TokenTypes token)
 {
     WriteIndex(token, new[]
     {
         TokenTypes.MethodDef,
         TokenTypes.Field,
         TokenTypes.TypeRef,
         TokenTypes.TypeDef,
         TokenTypes.Param,
         TokenTypes.InterfaceImpl,
         TokenTypes.MemberRef,
         TokenTypes.Module,
         TokenTypes.DeclSecurity,
         TokenTypes.Property,
         TokenTypes.Event,
         TokenTypes.StandAloneSig,
         TokenTypes.ModuleRef,
         TokenTypes.TypeSpec,
         TokenTypes.Assembly,
         TokenTypes.AssemblyRef,
         TokenTypes.File,
         TokenTypes.ExportedType,
         TokenTypes.ManifestResource
     });
 }

 ///<summary>
 ///Get conditions by object with Multi-TokenType.
 ///</summary>
 public static ParameterCollection GetConditionsByObject(DO_Title.UO_Title parameterObj, bool isAnd, TokenTypes tokenTypes, Dictionary<DO_Title.Columns, TokenTypes> extTokens)
 {
     ParameterCollection objectConditions = new ParameterCollection();
     TokenTypes tt = tokenTypes;
     ParameterType pt = isAnd ? ParameterType.And : ParameterType.Or;
     if (!string.IsNullOrEmpty(parameterObj.BigDateCode))
     {
         objectConditions.AddCondition(pt, GetColumnTokenType(tt, DO_Title.Columns.BigDateCode, extTokens), DO_Title.Columns.BigDateCode, parameterObj.BigDateCode);
     }
     if (!string.IsNullOrEmpty(parameterObj.TitleCode))
     {
         objectConditions.AddCondition(pt, GetColumnTokenType(tt, DO_Title.Columns.TitleCode, extTokens), DO_Title.Columns.TitleCode, parameterObj.TitleCode);
     }
     if (!string.IsNullOrEmpty(parameterObj.TitleName))
     {
         objectConditions.AddCondition(pt, GetColumnTokenType(tt, DO_Title.Columns.TitleName, extTokens), DO_Title.Columns.TitleName, parameterObj.TitleName);
     }
     if (parameterObj.CreateOn != DateTime.MinValue)
     {
         objectConditions.AddCondition(pt, GetColumnTokenType(tt, DO_Title.Columns.CreateOn, extTokens), DO_Title.Columns.CreateOn, parameterObj.CreateOn);
     }
     if (!string.IsNullOrEmpty(parameterObj.CreateBy))
     {
         objectConditions.AddCondition(pt, GetColumnTokenType(tt, DO_Title.Columns.CreateBy, extTokens), DO_Title.Columns.CreateBy, parameterObj.CreateBy);
     }
     if (parameterObj.UpdateOn != DateTime.MinValue)
     {
         objectConditions.AddCondition(pt, GetColumnTokenType(tt, DO_Title.Columns.UpdateOn, extTokens), DO_Title.Columns.UpdateOn, parameterObj.UpdateOn);
     }
     if (!string.IsNullOrEmpty(parameterObj.UpdateBy))
     {
         objectConditions.AddCondition(pt, GetColumnTokenType(tt, DO_Title.Columns.UpdateBy, extTokens), DO_Title.Columns.UpdateBy, parameterObj.UpdateBy);
     }
     return objectConditions;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AssemblyRefOSRow"/> struct.
 /// </summary>
 /// <param name="platformId">The platform id.</param>
 /// <param name="majorVersion">The major version.</param>
 /// <param name="minorVersion">The minor version.</param>
 /// <param name="assemblyRefIdx">The assembly ref idx.</param>
 public AssemblyRefOSRow(uint platformId, uint majorVersion, uint minorVersion, TokenTypes assemblyRefIdx)
 {
     _platformId = platformId;
     _majorVersion = majorVersion;
     _minorVersion = minorVersion;
     _assemblyRefIdx = assemblyRefIdx;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MethodSemanticsRow"/> struct.
        /// </summary>
        /// <param name="semantics">The semantics.</param>
        /// <param name="methodTableIdx">The method table idx.</param>
        /// <param name="associationTableIdx">The association table idx.</param>
        public MethodSemanticsRow(MethodSemanticsAttributes semantics, TokenTypes methodTableIdx,
									TokenTypes associationTableIdx)
        {
            _semantics = semantics;
            _methodTableIdx = methodTableIdx;
            _associationTableIdx = associationTableIdx;
        }

 public SqlToken(TokenTypes type, int oneBasedLineNumber, int oneBasedStartCharacterIndex)
 {
     StartCharacterIndex = oneBasedStartCharacterIndex;
     LineNumber = oneBasedLineNumber;
     TokenType = type;
     IsOpen = false;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ManifestResourceRow"/> struct.
 /// </summary>
 /// <param name="offset">The offset.</param>
 /// <param name="flags">The flags.</param>
 /// <param name="nameStringIndex">Index of the name string.</param>
 /// <param name="implementationTableIdx">The implementation table idx.</param>
 public ManifestResourceRow(uint offset, ManifestResourceAttributes flags, TokenTypes nameStringIndex,
     TokenTypes implementationTableIdx)
 {
     _offset = offset;
     _flags = flags;
     _nameStringIdx = nameStringIndex;
     _implementationTableIdx = implementationTableIdx;
 }

        public void Roundtrip(string text, TokenTypes types)
        {
            SecureTokenBuilder builder = new SecureTokenBuilder("[email protected]", types);
            string token = builder.EncodeToken(text);
            string decoded = builder.DecodeToken(token);

            Assert.AreEqual(text, decoded);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ImplMapRow"/> struct.
        /// </summary>
        /// <param name="mappingFlags">The mapping flags.</param>
        /// <param name="memberForwardedTableIdx">The member forwarded table idx.</param>
        /// <param name="importNameStringIdx">The import name string idx.</param>
        /// <param name="importScopeTableIdx">The import scope table idx.</param>
        public ImplMapRow(PInvokeAttributes mappingFlags, TokenTypes memberForwardedTableIdx,
			TokenTypes importNameStringIdx, TokenTypes importScopeTableIdx)
        {
            _mappingFlags = mappingFlags;
            _memberForwardedTableIdx = memberForwardedTableIdx;
            _importNameStringIdx = importNameStringIdx;
            _importScopeTableIdx = importScopeTableIdx;
        }

 /// <summary>
 /// Loads the signature.
 /// </summary>
 /// <param name="provider">The provider.</param>
 /// <param name="token">The token.</param>
 public void LoadSignature(IMetadataProvider provider, TokenTypes token)
 {
     byte[] buffer;
     int index = 0;
     provider.Read(token, out buffer);
     ParseSignature(buffer, ref index);
     Debug.Assert(index == buffer.Length, @"Signature parser didn't complete.");
 }

 /// <summary>
 /// Writes a coded index value in a metadata table.
 /// </summary>
 /// <param name="token">The indexed token.</param>
 public void WriteHasConstantIndex(TokenTypes token)
 {
     WriteIndex(token, new[]
     {
         TokenTypes.Field,
         TokenTypes.Param,
         TokenTypes.Property
     });
 }

		/// <summary>
		/// Initializes a new instance of the Token class.
		/// </summary>
		internal Token(string value, int startLine, int startCol, int endLine, int endCol, TokenTypes type)
		{
			Value = value;
			StartLine = startLine;
			EndLine = endLine;
			StartCol = startCol;
			EndCol = endCol;
			Type = type;
		}