C# Field.ToString方法代码示例

 public static string FilterDisplayName(Field filter)
 {
     switch (filter)
     {
         case Field.CompanyName:
             return "Company";
         case Field.Date:
             return "Date";
         case Field.EducationCode:
             return "Education Code";
         case Field.FieldOfStudy:
             return "Field of Study";
         case Field.JobTitle:
             return "Job Title";
         case Field.Keyword:
             return "Keyword";
         case Field.Location:
             return "Location";
         case Field.Salary:
             return "Salary";
         case Field.Source:
             return "Source";
         case Field.JobType:
             return "Job Type";
         default:
             return filter.ToString();
     }
 }

        public void Create_Field()
        {
            var field = new Field("Create_Field");

            var expected = Comparer.Create_Field();
            var actual = field.ToString();

            Assert.AreEqual(expected, actual);
            Console.WriteLine(actual);
        }

        public void Create_Field_ReadOnly()
        {
            var field = new Field("Create_Field_ReadOnly")
                .AddModifiers(MODIFIER.READ_ONLY);

            var expected = Comparer.Create_Field_ReadOnly();
            var actual = field.ToString();

            Assert.AreEqual(expected, actual);
            Console.WriteLine(actual);
        }

        public void Create_Field_With_Modifier_Type_And_Value()
        {
            var field = new Field("Create_Field_With_Modifier_Type_And_Value")
                .WithModifiers(MODIFIER.PROTECTED)
                .WithType<Int32>()
                .WithInitializer("42");

            var expected = Comparer.Create_Field_With_Modifier_Type_And_Value();
            var actual = field.ToString();

            Assert.AreEqual(expected, actual);
            Console.WriteLine(actual);
        }

        private string BuildParameterString(Field argName, Field argType, Field inOut)
        {
            var sb = new StringBuilder();
            sb.Append(argName.ToString());
            sb.Append(" ");
            sb.Append(argType.ToString());

            if (!inOut.IsNull)
                sb.Append(" ")
                    .Append(inOut.Value);

            return sb.ToString();
        }

 public void SetTrackerVal(Field fieldName, object value){
   handler._set(fieldName.ToString(), value);
 }

 public void ToString_FieldIsBlack_ContainsTheColorInString()
 {
     fTestObj = new Field(uiNumber, Field.Black);
     StringAssert.Contains("black", fTestObj.ToString());
 }

 public void ToString_FieldIsRed_ContainsTheColorInString()
 {
     fTestObj = new Field(uiNumber, Field.Red);
     StringAssert.Contains("red", fTestObj.ToString());
 }

 public void ToString_FieldIsGreen_ContainsTheColorInString()
 {
     fTestObj = new Field(uiNumber, Field.Green);
     StringAssert.Contains("green", fTestObj.ToString());
 }

 internal void SetTrackerVal(Field fieldName, object value)
 {
     object[] args = new object[] { fieldName.ToString(), value };
     tracker.Call("set", args);
 }

        /// <summary>
        /// OBSOLETE: Handles a scenario where there is a term in the condition
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="binOp"></param>
        /// <param name="fmt"></param>
        private void handleAConstantInTerm(TermManager termManager, Term left, Term right,
            BinaryOperator binOp, bool bNegated, SafeDictionary<Field, FieldValueHolder> fieldValues, Field culpritField,
            out FieldModificationType fmt, out int fitnessval)
        {
            fitnessval = Int32.MaxValue;
            fmt = FieldModificationType.UNKNOWN;
            Term non_constant_term = null;
            Term constant_term = null;

            bool bleftRightMaintainted = true;
            if (termManager.IsValue(left))
            {
                non_constant_term = right;
                constant_term = left;
                bleftRightMaintainted = true;
            }
            else if (termManager.IsValue(right))
            {
                non_constant_term = left;
                constant_term = right;
                bleftRightMaintainted = false;
            }

            int value;
            if (termManager.TryGetI4Constant(constant_term, out value))
            {
                fmt = FieldModificationType.INCREMENT;

                FieldValueHolder fvh;
                if (fieldValues.TryGetValue(culpritField, out fvh))
                {
                    int non_constant_field_value = fvh.intValue;    //TODO: Assuming that the fieldType is Int32
                    if (bleftRightMaintainted)
                        fitnessval = FitnessMeasure.ComputeFitnessValue(this.host, binOp, value, non_constant_field_value, bNegated);
                    else
                        fitnessval = FitnessMeasure.ComputeFitnessValue(this.host, binOp, non_constant_field_value, value, bNegated);
                }
                else
                    this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fitness measure",
                        "Failed to retrieve value for field " + culpritField.ToString());
            }
            else if (termManager.IsDefaultValue(constant_term))
            {
                if (binOp == BinaryOperator.Ceq)
                {
                    if (culpritField.Type.ToString() == "System.Boolean")
                    {
                        fmt = bNegated ? FieldModificationType.TRUE_SET : FieldModificationType.FALSE_SET;
                    }
                    else
                        fmt = bNegated ? FieldModificationType.NON_NULL_SET : FieldModificationType.NULL_SET;
                }
            }

            Term objectValue;
            ObjectProperty objectProperty;
            if (termManager.TryGetObjectProperty(constant_term, out objectValue, out objectProperty))
            {
                //TODO??? How to handle this scenario?
            }
        }