C# FieldType.ToString方法代码示例

 /// <summary>
 /// Initializes a new instance of the <see cref="CAMLQueryGenericFilter"/> class.
 /// </summary>
 /// <param name="fieldName">Name of the field.</param>
 /// <param name="fieldType">Type of the field.</param>
 /// <param name="fieldValue">The field value.</param>
 /// <param name="queryType">Type of the query.</param>
 public CAMLQueryGenericFilter(string fieldName, FieldType fieldType, string fieldValue, QueryType queryType)
 {
     try
     {
         this.FieldName = fieldName;
         this.FieldType = fieldType;
         this.FieldValue = fieldValue;
         string filterMarkUp = string.Empty;
         filterMarkUp = string.Format(this.GetQueryTypeMarkUp(queryType), CAMLQueryFilter.QueryFIELDREFMarkUp, CAMLQueryFilter.QueryVALUEMarkUp);
         this.Query = string.Format(filterMarkUp, fieldName, fieldType.ToString(), fieldValue);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }

        /// <summary>
        ///     获取字段创建字符串
        /// </summary>
        /// <param name="fieldName">字段名称</param>
        /// <param name="isPrimaryKey">是否为主键</param>
        /// <param name="isIdentity">是否自增长</param>
        /// <param name="isNotNull">是否不为空</param>
        /// <param name="fieldType">字段类型</param>
        /// <param name="fieldLength">字段长度</param>
        /// <param name="fieldDefaultValue">字段默认值</param>
        protected override string CreateFieldString(string fieldName, bool isPrimaryKey, bool isIdentity, bool isNotNull,
                                                    FieldType fieldType, int? fieldLength, object fieldDefaultValue)
        {
            if (fieldDefaultValue is Enum)
            {
                fieldDefaultValue = (int) fieldDefaultValue;
            }
            if (fieldDefaultValue != null)
            {
                if (
                    !fieldDefaultValue.ToString().StartsWith("'") &&
                    (fieldType == FieldType.Char ||
                     fieldType == FieldType.NChar ||
                     fieldType == FieldType.Ntext ||
                     fieldType == FieldType.Nvarchar ||
                     fieldType == FieldType.Text ||
                     fieldType == FieldType.Varchar))
                {
                    fieldDefaultValue = "'" + fieldDefaultValue + "'";
                }
            }
            var sql = new StringBuilder();

            sql.AppendFormat("{0} ", dbProvider.CreateTableAegis(fieldName));
            sql.AppendFormat("{0} ", fieldType.ToString());
            if (fieldLength != null)
            {
                sql.AppendFormat("({0}) ", fieldLength);
            }
            if (isIdentity)
            {
                sql.Append("AUTO_INCREMENT ");
            }
            sql.Append(isNotNull ? "NOT NULL " : "NULL ");
            if (isPrimaryKey)
            {
                sql.Append("PRIMARY KEY ");
            }
            if (fieldDefaultValue != null && fieldDefaultValue.ToString().Length > 0)
            {
                sql.AppendFormat("DEFAULT {0} ", fieldDefaultValue);
            }
            ;

            return sql.ToString();
        }

 void warn_add_OBJ_field_mismatch_with_archetype_field(Obj obj, string field_name, FieldType obj_field_type)
 {
     warn_at();
     Form1.stdout.print("         Field type mismatch with Archetype '{1}', ignoring OBJ field '{0}',\n" +
                        "         obj_field_type '{2}' != arch_field_type '{3}'\n",
                         field_name, obj.archetype.tag, obj_field_type.ToString(), obj.archetype[field_name].type.ToString());
 }

 private static string FormatFieldType(FieldType fieldType)
 {
     if (fieldType == FieldType.Short || fieldType == FieldType.Byte)
     {
         return string.Format("({0})", fieldType.ToString().ToLower());
     }
     return "";
 }

 /// <summary>
 /// Create field to web remotely
 /// </summary>
 /// <param name="web">Site to be processed - can be root web or sub site</param>
 /// <param name="id">Guid for the new field.</param>
 /// <param name="internalName">Internal name of the field</param>
 /// <param name="fieldType">Field type to be created.</param>
 /// <param name="displayName">The display name of the field</param>
 /// <param name="group">The field group name</param>
 /// <returns>The newly created field or existing field.</returns>
 public static Field CreateField(this Web web, Guid id, string internalName, FieldType fieldType, string displayName, string group, string additionalXmlAttributes = "", bool executeQuery = true)
 {
     return CreateField(web, id, internalName, fieldType.ToString(), displayName, group, additionalXmlAttributes, executeQuery);
 }

 void warn_add_OBJ_field_defaulting_to_basic_field_type(string field_name, string arch_tag, FieldType type)
 {
     warn_at();
     Form1.stdout.print("         Archetype '{1}' does not define OBJ field '{0}', defaulting type to '{2}'\n",
                        field_name, arch_tag, type.ToString());
 }

        static string FormatField(Guid fieldId, string internalName, FieldType fieldType, string displayName, string description, string groupName, string attributes)
        {
            if (attributes == null)
                attributes = string.Empty;

            description = description.Replace("<", "&lt;").Replace(">", "&gt;").Replace("\"", "&quot;");
            attributes += string.Format(" Description=\"{0}\"", description);
            return FormatFieldXml(fieldId, internalName, fieldType.ToString(), displayName, groupName, attributes);
        }

        private Type TranslateOgrType(FieldType ogrType)
        {
            switch (ogrType)
            {
                case FieldType.OFTInteger:
                    return typeof(Int32);

                case FieldType.OFTReal:
                    return typeof(Double);

                case FieldType.OFTWideString:
                case FieldType.OFTString:
                    return typeof(String);

                case FieldType.OFTBinary:
                    return typeof(Byte[]);

                case FieldType.OFTDate:
                case FieldType.OFTTime:
                case FieldType.OFTDateTime:
                    return typeof(DateTime);

                case FieldType.OFTIntegerList:
                case FieldType.OFTRealList:
                case FieldType.OFTStringList:
                case FieldType.OFTWideStringList:
                    throw new NotSupportedException("Type not supported: " + ogrType.ToString());

                default:
                    throw new NotSupportedException("Type not supported: " + ogrType.ToString());
            }
        }

 public FieldCreationInformation(FieldType fieldType)
 {
     this.FieldType = fieldType.ToString();
 }

        /// <summary>
        /// Loads a node field.
        /// <param name="fieldType">The target field type enum.</param>
        /// <param name="type">The real target field type.</param>
        /// <param name="fieldPath">The field path.</param>
        /// </summary>
        object LoadNodeField (FieldType fieldType, System.Type type, string fieldPath) {
            var fieldIndex = m_FieldIndex[m_NextFieldIndex];
            // value types
            switch (fieldType) {
                // It's a none var?
                case FieldType.None:
                    // Get generic type
                    var genericType = TypeUtility.GetType(m_StringValue[fieldIndex]);
                    
                    if (genericType == null) {
                        // Try to get the field type
                        if (type != null)
                            genericType = type.IsAbstract ? TypeUtility.GetConcreteType(type) : type;
                    }
                    else if (genericType.IsAbstract) {
                        // Try to get the concrete type
                        genericType = TypeUtility.GetConcreteType(genericType) ?? TypeUtility.GetConcreteType(type);
                    }
                    else if (genericType.IsInterface) {
                        Print.LogError("Can't serialize abstract or interface fields: " + genericType.ToString());
                        return null;
                    }

                    // Create the generic object
                    if (typeof(GameObjectVar).IsAssignableFrom(genericType))
                        return Activator.CreateInstance(genericType, new object[] {m_GameObject});
                    else
                        return Activator.CreateInstance(genericType);
                // It's a constant var?
                case FieldType.Constant:
                    // Get generic type
                    genericType = TypeUtility.GetType(m_GenericFieldType[fieldIndex]);

                    if (genericType == null) {
                        // Try to get the field type
                        if (type != null)
                            genericType = type.IsAbstract ? TypeUtility.GetConcreteType(type) : type;
                    }
                    else if (genericType.IsAbstract) {
                        // Try to get the concrete type
                        genericType = TypeUtility.GetConcreteType(genericType) ?? TypeUtility.GetConcreteType(type);
                    }
                    else if (genericType.IsInterface) {
                        Print.LogError("Can't serialize interface fields: " + genericType.ToString());
                        return null;
                    }

                    // Create the generic object
                    var variable = Activator.CreateInstance(genericType) as BehaviourMachine.Variable;

                    if (variable == null)
                        return null;

                    // The type has changed?
                    if (m_GenericFieldHash[fieldIndex] != TypeToHash(genericType)) {
                        var fieldSize = m_GenericFieldSize[fieldIndex];
                        m_NextFieldIndex++;
                        TryLoadFields(variable, fieldSize, fieldPath);
                    }
                    else {
                        m_NextFieldIndex++;
                        LoadFields(variable, fieldPath);
                    }

                    variable.SetAsConstant();
                    m_NextFieldIndex--;

                    return variable;
                // FloatVar
                case FieldType.FloatVar:
                    // Get variable id
                    var varId = m_IntValue[fieldIndex];
                    // Get variable
                    if (varId > 0)
                        return m_Blackboard.GetFloatVar(varId);
                    else if (InternalGlobalBlackboard.Instance != null)
                        return InternalGlobalBlackboard.Instance.GetFloatVar(varId);
                    else
                        return new ConcreteFloatVar();
                // IntVar
                case FieldType.IntVar:
                    // Get variable id
                    varId = m_IntValue[fieldIndex];
                    // Get variable
                    if (varId > 0)
                        return m_Blackboard.GetIntVar(varId);
                    else if (InternalGlobalBlackboard.Instance != null)
                        return InternalGlobalBlackboard.Instance.GetIntVar(varId);
                    else
                        return new ConcreteIntVar();
                // BoolVar
                case FieldType.BoolVar:
                    // Get variable id
                    varId = m_IntValue[fieldIndex];
//.........这里部分代码省略.........

        /// <summary>
        ///   Executes the provided <see cref="Action"/> several times to average out the time spent in execution.
        /// </summary>
        /// <param name="action">The action representing the test.</param>
        /// <param name="fieldType">The field type to test (Delimited or FixedWidth).</param>
        /// <param name="lngFileLength">The length of the file being parsed in bytes.</param>
        /// <param name="strTestName">The name of the test.</param>
        private static void _TestRunner(Action action, FieldType fieldType, long lngFileLength, string strTestName)
        {
            Stopwatch sw;
            double dblAvgDuration;

            // Clear out the trash so as to minimize the likelyhood of the garbage being taken out during the tests.
            GC.Collect();
            GC.WaitForFullGCComplete();
            GC.WaitForPendingFinalizers();

            sw = Stopwatch.StartNew();

            for (int intTestIteration = 0; intTestIteration < PerformanceTests.ITERATIONS_OF_TESTS; ++intTestIteration)
            {
                action();
            }

            sw.Stop();

            dblAvgDuration = ((double)sw.ElapsedMilliseconds) / ((double)PerformanceTests.ITERATIONS_OF_TESTS);

            Console.WriteLine(string.Format("{0,-10} {1,21} - Avg. Time {2,10:#0.0} (ms) [{3,14}]",
                fieldType.ToString(),
                strTestName,
                dblAvgDuration,
                PerformanceTests._CalculateThroughput(lngFileLength, dblAvgDuration)));
        }