C# StringBuilder.append方法代码示例

 public void TestStackOverflow() {
    StringBuilder builder = new StringBuilder();
    Persister persister = new Persister();
    builder.append("<delivery>");
    bool isNewBenefit = true;
    for(int i = 0; i < ITERATIONS; i++) {
       String text = null;
       if(isNewBenefit) {
          text = NEW_BENEFIT;
       } else {
          text = BENEFIT_MUTATION;
       }
       isNewBenefit = !isNewBenefit ;
       builder.append(text);
    }
    builder.append("</delivery>");
    Delivery delivery = persister.read(Delivery.class, builder.toString());

		public synchronized String toString() {
			StringBuilder builder = new StringBuilder();
			int peers = numBroadcastPeers();
			if (peers > 0) {
				builder.append("Seen by ");
				builder.append(peers);
				if (peers > 1)
					builder.append(" peers. ");
				else
					builder.append(" peer. ");
			}
			switch (getConfidenceType()) {
				case UNKNOWN:
					builder.append("Unknown confidence level.");
					break;
				case DEAD:
					builder.append("Dead: overridden by double spend and will not confirm.");
					break;
				case NOT_IN_BEST_CHAIN: 
					builder.append("Seen in side chain but not best chain.");
					break;
				case NOT_SEEN_IN_CHAIN:
					builder.append("Not seen in chain.");
					break;
				case BUILDING:
					builder.append(String.format("Appeared in best chain at height %d, depth %d, work done %s.",
							getAppearedAtChainHeight(), getDepthInBlocks(), getWorkDone()));
					break;
			}
			return builder.toString();
		}

 /// <summary>
 /// This is used to build a string from the annotation. The string
 /// produces adheres to the typical string representation of a
 /// normal annotation. This ensures that an exceptions that are
 /// thrown with a string representation of the annotation are
 /// identical to those thrown with a normal annotation.
 /// </summary>
 /// <param name="builder">
 /// this is the builder used to compose the text
 /// </param>
 public void Attributes(StringBuilder builder) {
    Method[] list = type.getDeclaredMethods();
    for(int i = 0; i < list.length; i++) {
       String attribute = list[i].getName();
       Object value = Value(list[i]);
       if(i > 0) {
          builder.append(',');
          builder.append(' ');
       }
       builder.append(attribute);
       builder.append('=');
       builder.append(value);
    }
    builder.append(')');
 }

        /**
         * Returns a string containing the string representation of all modifiers
         * present in the specified modifiers. Modifiers appear in the order
         * specified by the Java Language Specification:
         *
         * {@code public private protected abstract static readonly transient volatile native synchronized interface strict}
         *
         * @param modifiers
         *            the modifiers to print
         * @return a printable representation of the modifiers
         */
        public static String toString(int modifiers)
        {
            StringBuilder buf = new StringBuilder();

            if (isPublic(modifiers))
            {
                buf.append("public ");
            }
            if (isProtected(modifiers))
            {
                buf.append("protected ");
            }
            if (isPrivate(modifiers))
            {
                buf.append("private ");
            }
            if (isAbstract(modifiers))
            {
                buf.append("abstract ");
            }
            if (isStatic(modifiers))
            {
                buf.append("static ");
            }
            if (isFinal(modifiers))
            {
                buf.append("readonly ");
            }
            if (isTransient(modifiers))
            {
                buf.append("transient ");
            }
            if (isVolatile(modifiers))
            {
                buf.append("volatile ");
            }
            if (isSynchronized(modifiers))
            {
                buf.append("synchronized ");
            }
            if (isNative(modifiers))
            {
                buf.append("native ");
            }
            if (isStrict(modifiers))
            {
                buf.append("strictfp ");
            }
            if (isInterface(modifiers))
            {
                buf.append("interface ");
            }
            if (buf.length() == 0)
            {
                return "";
            }
            buf.setLength(buf.length() - 1);
            return buf.toString();
        }

 /// <summary>
 /// This is used to build a string from the annotation. The string
 /// produces adheres to the typical string representation of a
 /// normal annotation. This ensures that an exceptions that are
 /// thrown with a string representation of the annotation are
 /// identical to those thrown with a normal annotation.
 /// </summary>
 /// <param name="builder">
 /// this is the builder used to compose the text
 /// </param>
 public void Name(StringBuilder builder) {
    String name = type.getName();
    if(name != null) {
       builder.append('@');
       builder.append(name);
       builder.append('(');
    }
 }